src/HEXABLOCK_SWIG/hexablock_swig_wrap.cc

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.12
   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
  12 #ifndef SWIGPYTHON
  13 #define SWIGPYTHON
  14 #endif
  15
  16 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
 168 /* Use debug wrappers with the Python release dll */
 169 # undef _DEBUG
 170 # include <Python.h>
 171 # define _DEBUG
 172 #else
 173 # include <Python.h>
 174 #endif
 175
 176 /* -----------------------------------------------------------------------------
 177  * swigrun.swg
 178  *
 179  * This file contains generic C API SWIG runtime support for pointer
 180  * type checking.
 181  * ----------------------------------------------------------------------------- */
 182
 183 /* This should only be incremented when either the layout of swig_type_info changes,
 184    or for whatever reason, the runtime changes incompatibly */
 185 #define SWIG_RUNTIME_VERSION "4"
 186
 187 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 188 #ifdef SWIG_TYPE_TABLE
 189 # define SWIG_QUOTE_STRING(x) #x
 190 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 191 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 192 #else
 193 # define SWIG_TYPE_TABLE_NAME
 194 #endif
 195
 196 /*
 197   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 198   creating a static or dynamic library from the SWIG runtime code.
 199   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
 200
 201   But only do this if strictly necessary, ie, if you have problems
 202   with your compiler or suchlike.
 203 */
 204
 205 #ifndef SWIGRUNTIME
 206 # define SWIGRUNTIME SWIGINTERN
 207 #endif
 208
 209 #ifndef SWIGRUNTIMEINLINE
 210 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 211 #endif
 212
 213 /*  Generic buffer size */
 214 #ifndef SWIG_BUFFER_SIZE
 215 # define SWIG_BUFFER_SIZE 1024
 216 #endif
 217
 218 /* Flags for pointer conversions */
 219 #define SWIG_POINTER_DISOWN        0x1
 220 #define SWIG_CAST_NEW_MEMORY       0x2
 221
 222 /* Flags for new pointer objects */
 223 #define SWIG_POINTER_OWN           0x1
 224
 225
 226 /*
 227    Flags/methods for returning states.
 228
 229    The SWIG conversion methods, as ConvertPtr, return an integer
 230    that tells if the conversion was successful or not. And if not,
 231    an error code can be returned (see swigerrors.swg for the codes).
 232
 233    Use the following macros/flags to set or process the returning
 234    states.
 235
 236    In old versions of SWIG, code such as the following was usually written:
 237
 238      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 239        // success code
 240      } else {
 241        //fail code
 242      }
 243
 244    Now you can be more explicit:
 245
 246     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 247     if (SWIG_IsOK(res)) {
 248       // success code
 249     } else {
 250       // fail code
 251     }
 252
 253    which is the same really, but now you can also do
 254
 255     Type *ptr;
 256     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 257     if (SWIG_IsOK(res)) {
 258       // success code
 259       if (SWIG_IsNewObj(res) {
 260         ...
 261         delete *ptr;
 262       } else {
 263         ...
 264       }
 265     } else {
 266       // fail code
 267     }
 268
 269    I.e., now SWIG_ConvertPtr can return new objects and you can
 270    identify the case and take care of the deallocation. Of course that
 271    also requires SWIG_ConvertPtr to return new result values, such as
 272
 273       int SWIG_ConvertPtr(obj, ptr,...) {
 274         if (<obj is ok>) {
 275           if (<need new object>) {
 276             *ptr = <ptr to new allocated object>;
 277             return SWIG_NEWOBJ;
 278           } else {
 279             *ptr = <ptr to old object>;
 280             return SWIG_OLDOBJ;
 281           }
 282         } else {
 283           return SWIG_BADOBJ;
 284         }
 285       }
 286
 287    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 288    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 289    SWIG errors code.
 290
 291    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 292    allows to return the 'cast rank', for example, if you have this
 293
 294        int food(double)
 295        int fooi(int);
 296
 297    and you call
 298
 299       food(1)   // cast rank '1'  (1 -> 1.0)
 300       fooi(1)   // cast rank '0'
 301
 302    just use the SWIG_AddCast()/SWIG_CheckState()
 303 */
 304
 305 #define SWIG_OK                    (0)
 306 #define SWIG_ERROR                 (-1)
 307 #define SWIG_IsOK(r)               (r >= 0)
 308 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 309
 310 /* The CastRankLimit says how many bits are used for the cast rank */
 311 #define SWIG_CASTRANKLIMIT         (1 << 8)
 312 /* The NewMask denotes the object was created (using new/malloc) */
 313 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 314 /* The TmpMask is for in/out typemaps that use temporal objects */
 315 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 316 /* Simple returning values */
 317 #define SWIG_BADOBJ                (SWIG_ERROR)
 318 #define SWIG_OLDOBJ                (SWIG_OK)
 319 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 320 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 321 /* Check, add and del mask methods */
 322 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 323 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 324 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 325 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 326 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 327 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 328
 329 /* Cast-Rank Mode */
 330 #if defined(SWIG_CASTRANK_MODE)
 331 #  ifndef SWIG_TypeRank
 332 #    define SWIG_TypeRank             unsigned long
 333 #  endif
 334 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 335 #    define SWIG_MAXCASTRANK          (2)
 336 #  endif
 337 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 338 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 339 SWIGINTERNINLINE int SWIG_AddCast(int r) {
 340   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 341 }
 342 SWIGINTERNINLINE int SWIG_CheckState(int r) {
 343   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
 344 }
 345 #else /* no cast-rank mode */
 346 #  define SWIG_AddCast(r) (r)
 347 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 348 #endif
 349
 350
 351 #include <string.h>
 352
 353 #ifdef __cplusplus
 354 extern "C" {
 355 #endif
 356
 357 typedef void *(*swig_converter_func)(void *, int *);
 358 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 359
 360 /* Structure to store information on one type */
 361 typedef struct swig_type_info {
 362   const char             *name;                 /* mangled name of this type */
 363   const char             *str;                  /* human readable name of this type */
 364   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 365   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 366   void                   *clientdata;           /* language specific type data */
 367   int                    owndata;               /* flag if the structure owns the clientdata */
 368 } swig_type_info;
 369
 370 /* Structure to store a type and conversion function used for casting */
 371 typedef struct swig_cast_info {
 372   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 373   swig_converter_func     converter;            /* function to cast the void pointers */
 374   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 375   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 376 } swig_cast_info;
 377
 378 /* Structure used to store module information
 379  * Each module generates one structure like this, and the runtime collects
 380  * all of these structures and stores them in a circularly linked list.*/
 381 typedef struct swig_module_info {
 382   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 383   size_t                 size;                  /* Number of types in this module */
 384   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 385   swig_type_info         **type_initial;        /* Array of initially generated type structures */
 386   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 387   void                    *clientdata;          /* Language specific module data */
 388 } swig_module_info;
 389
 390 /*
 391   Compare two type names skipping the space characters, therefore
 392   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 393
 394   Return 0 when the two name types are equivalent, as in
 395   strncmp, but skipping ' '.
 396 */
 397 SWIGRUNTIME int
 398 SWIG_TypeNameComp(const char *f1, const char *l1,
 399                   const char *f2, const char *l2) {
 400   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 401     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 402     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 403     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 404   }
 405   return (int)((l1 - f1) - (l2 - f2));
 406 }
 407
 408 /*
 409   Check type equivalence in a name list like <name1>|<name2>|...
 410   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 411 */
 412 SWIGRUNTIME int
 413 SWIG_TypeCmp(const char *nb, const char *tb) {
 414   int equiv = 1;
 415   const char* te = tb + strlen(tb);
 416   const char* ne = nb;
 417   while (equiv != 0 && *ne) {
 418     for (nb = ne; *ne; ++ne) {
 419       if (*ne == '|') break;
 420     }
 421     equiv = SWIG_TypeNameComp(nb, ne, tb, te);
 422     if (*ne) ++ne;
 423   }
 424   return equiv;
 425 }
 426
 427 /*
 428   Check type equivalence in a name list like <name1>|<name2>|...
 429   Return 0 if not equal, 1 if equal
 430 */
 431 SWIGRUNTIME int
 432 SWIG_TypeEquiv(const char *nb, const char *tb) {
 433   return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
 434 }
 435
 436 /*
 437   Check the typename
 438 */
 439 SWIGRUNTIME swig_cast_info *
 440 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 441   if (ty) {
 442     swig_cast_info *iter = ty->cast;
 443     while (iter) {
 444       if (strcmp(iter->type->name, c) == 0) {
 445         if (iter == ty->cast)
 446           return iter;
 447         /* Move iter to the top of the linked list */
 448         iter->prev->next = iter->next;
 449         if (iter->next)
 450           iter->next->prev = iter->prev;
 451         iter->next = ty->cast;
 452         iter->prev = 0;
 453         if (ty->cast) ty->cast->prev = iter;
 454         ty->cast = iter;
 455         return iter;
 456       }
 457       iter = iter->next;
 458     }
 459   }
 460   return 0;
 461 }
 462
 463 /*
 464   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
 465 */
 466 SWIGRUNTIME swig_cast_info *
 467 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
 468   if (ty) {
 469     swig_cast_info *iter = ty->cast;
 470     while (iter) {
 471       if (iter->type == from) {
 472         if (iter == ty->cast)
 473           return iter;
 474         /* Move iter to the top of the linked list */
 475         iter->prev->next = iter->next;
 476         if (iter->next)
 477           iter->next->prev = iter->prev;
 478         iter->next = ty->cast;
 479         iter->prev = 0;
 480         if (ty->cast) ty->cast->prev = iter;
 481         ty->cast = iter;
 482         return iter;
 483       }
 484       iter = iter->next;
 485     }
 486   }
 487   return 0;
 488 }
 489
 490 /*
 491   Cast a pointer up an inheritance hierarchy
 492 */
 493 SWIGRUNTIMEINLINE void *
 494 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
 495   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 496 }
 497
 498 /*
 499    Dynamic pointer casting. Down an inheritance hierarchy
 500 */
 501 SWIGRUNTIME swig_type_info *
 502 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 503   swig_type_info *lastty = ty;
 504   if (!ty || !ty->dcast) return ty;
 505   while (ty && (ty->dcast)) {
 506     ty = (*ty->dcast)(ptr);
 507     if (ty) lastty = ty;
 508   }
 509   return lastty;
 510 }
 511
 512 /*
 513   Return the name associated with this type
 514 */
 515 SWIGRUNTIMEINLINE const char *
 516 SWIG_TypeName(const swig_type_info *ty) {
 517   return ty->name;
 518 }
 519
 520 /*
 521   Return the pretty name associated with this type,
 522   that is an unmangled type name in a form presentable to the user.
 523 */
 524 SWIGRUNTIME const char *
 525 SWIG_TypePrettyName(const swig_type_info *type) {
 526   /* The "str" field contains the equivalent pretty names of the
 527      type, separated by vertical-bar characters.  We choose
 528      to print the last name, as it is often (?) the most
 529      specific. */
 530   if (!type) return NULL;
 531   if (type->str != NULL) {
 532     const char *last_name = type->str;
 533     const char *s;
 534     for (s = type->str; *s; s++)
 535       if (*s == '|') last_name = s+1;
 536     return last_name;
 537   }
 538   else
 539     return type->name;
 540 }
 541
 542 /*
 543    Set the clientdata field for a type
 544 */
 545 SWIGRUNTIME void
 546 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 547   swig_cast_info *cast = ti->cast;
 548   /* if (ti->clientdata == clientdata) return; */
 549   ti->clientdata = clientdata;
 550
 551   while (cast) {
 552     if (!cast->converter) {
 553       swig_type_info *tc = cast->type;
 554       if (!tc->clientdata) {
 555         SWIG_TypeClientData(tc, clientdata);
 556       }
 557     }
 558     cast = cast->next;
 559   }
 560 }
 561 SWIGRUNTIME void
 562 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 563   SWIG_TypeClientData(ti, clientdata);
 564   ti->owndata = 1;
 565 }
 566
 567 /*
 568   Search for a swig_type_info structure only by mangled name
 569   Search is a O(log #types)
 570
 571   We start searching at module start, and finish searching when start == end.
 572   Note: if start == end at the beginning of the function, we go all the way around
 573   the circular list.
 574 */
 575 SWIGRUNTIME swig_type_info *
 576 SWIG_MangledTypeQueryModule(swig_module_info *start,
 577                             swig_module_info *end,
 578                             const char *name) {
 579   swig_module_info *iter = start;
 580   do {
 581     if (iter->size) {
 582       size_t l = 0;
 583       size_t r = iter->size - 1;
 584       do {
 585         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 586         size_t i = (l + r) >> 1;
 587         const char *iname = iter->types[i]->name;
 588         if (iname) {
 589           int compare = strcmp(name, iname);
 590           if (compare == 0) {
 591             return iter->types[i];
 592           } else if (compare < 0) {
 593             if (i) {
 594               r = i - 1;
 595             } else {
 596               break;
 597             }
 598           } else if (compare > 0) {
 599             l = i + 1;
 600           }
 601         } else {
 602           break; /* should never happen */
 603         }
 604       } while (l <= r);
 605     }
 606     iter = iter->next;
 607   } while (iter != end);
 608   return 0;
 609 }
 610
 611 /*
 612   Search for a swig_type_info structure for either a mangled name or a human readable name.
 613   It first searches the mangled names of the types, which is a O(log #types)
 614   If a type is not found it then searches the human readable names, which is O(#types).
 615
 616   We start searching at module start, and finish searching when start == end.
 617   Note: if start == end at the beginning of the function, we go all the way around
 618   the circular list.
 619 */
 620 SWIGRUNTIME swig_type_info *
 621 SWIG_TypeQueryModule(swig_module_info *start,
 622                      swig_module_info *end,
 623                      const char *name) {
 624   /* STEP 1: Search the name field using binary search */
 625   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 626   if (ret) {
 627     return ret;
 628   } else {
 629     /* STEP 2: If the type hasn't been found, do a complete search
 630        of the str field (the human readable name) */
 631     swig_module_info *iter = start;
 632     do {
 633       size_t i = 0;
 634       for (; i < iter->size; ++i) {
 635         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 636           return iter->types[i];
 637       }
 638       iter = iter->next;
 639     } while (iter != end);
 640   }
 641
 642   /* neither found a match */
 643   return 0;
 644 }
 645
 646 /*
 647    Pack binary data into a string
 648 */
 649 SWIGRUNTIME char *
 650 SWIG_PackData(char *c, void *ptr, size_t sz) {
 651   static const char hex[17] = "0123456789abcdef";
 652   const unsigned char *u = (unsigned char *) ptr;
 653   const unsigned char *eu =  u + sz;
 654   for (; u != eu; ++u) {
 655     unsigned char uu = *u;
 656     *(c++) = hex[(uu & 0xf0) >> 4];
 657     *(c++) = hex[uu & 0xf];
 658   }
 659   return c;
 660 }
 661
 662 /*
 663    Unpack binary data from a string
 664 */
 665 SWIGRUNTIME const char *
 666 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 667   unsigned char *u = (unsigned char *) ptr;
 668   const unsigned char *eu = u + sz;
 669   for (; u != eu; ++u) {
 670     char d = *(c++);
 671     unsigned char uu;
 672     if ((d >= '0') && (d <= '9'))
 673       uu = (unsigned char)((d - '0') << 4);
 674     else if ((d >= 'a') && (d <= 'f'))
 675       uu = (unsigned char)((d - ('a'-10)) << 4);
 676     else
 677       return (char *) 0;
 678     d = *(c++);
 679     if ((d >= '0') && (d <= '9'))
 680       uu |= (unsigned char)(d - '0');
 681     else if ((d >= 'a') && (d <= 'f'))
 682       uu |= (unsigned char)(d - ('a'-10));
 683     else
 684       return (char *) 0;
 685     *u = uu;
 686   }
 687   return c;
 688 }
 689
 690 /*
 691    Pack 'void *' into a string buffer.
 692 */
 693 SWIGRUNTIME char *
 694 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 695   char *r = buff;
 696   if ((2*sizeof(void *) + 2) > bsz) return 0;
 697   *(r++) = '_';
 698   r = SWIG_PackData(r,&ptr,sizeof(void *));
 699   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 700   strcpy(r,name);
 701   return buff;
 702 }
 703
 704 SWIGRUNTIME const char *
 705 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 706   if (*c != '_') {
 707     if (strcmp(c,"NULL") == 0) {
 708       *ptr = (void *) 0;
 709       return name;
 710     } else {
 711       return 0;
 712     }
 713   }
 714   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 715 }
 716
 717 SWIGRUNTIME char *
 718 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 719   char *r = buff;
 720   size_t lname = (name ? strlen(name) : 0);
 721   if ((2*sz + 2 + lname) > bsz) return 0;
 722   *(r++) = '_';
 723   r = SWIG_PackData(r,ptr,sz);
 724   if (lname) {
 725     strncpy(r,name,lname+1);
 726   } else {
 727     *r = 0;
 728   }
 729   return buff;
 730 }
 731
 732 SWIGRUNTIME const char *
 733 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 734   if (*c != '_') {
 735     if (strcmp(c,"NULL") == 0) {
 736       memset(ptr,0,sz);
 737       return name;
 738     } else {
 739       return 0;
 740     }
 741   }
 742   return SWIG_UnpackData(++c,ptr,sz);
 743 }
 744
 745 #ifdef __cplusplus
 746 }
 747 #endif
 748
 749 /*  Errors in SWIG */
 750 #define  SWIG_UnknownError         -1
 751 #define  SWIG_IOError              -2
 752 #define  SWIG_RuntimeError         -3
 753 #define  SWIG_IndexError           -4
 754 #define  SWIG_TypeError            -5
 755 #define  SWIG_DivisionByZero       -6
 756 #define  SWIG_OverflowError        -7
 757 #define  SWIG_SyntaxError          -8
 758 #define  SWIG_ValueError           -9
 759 #define  SWIG_SystemError          -10
 760 #define  SWIG_AttributeError       -11
 761 #define  SWIG_MemoryError          -12
 762 #define  SWIG_NullReferenceError   -13
 763
 764
 765
 766 /* Compatibility macros for Python 3 */
 767 #if PY_VERSION_HEX >= 0x03000000
 768
 769 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
 770 #define PyInt_Check(x) PyLong_Check(x)
 771 #define PyInt_AsLong(x) PyLong_AsLong(x)
 772 #define PyInt_FromLong(x) PyLong_FromLong(x)
 773 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
 774 #define PyString_Check(name) PyBytes_Check(name)
 775 #define PyString_FromString(x) PyUnicode_FromString(x)
 776 #define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
 777 #define PyString_AsString(str) PyBytes_AsString(str)
 778 #define PyString_Size(str) PyBytes_Size(str)
 779 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
 780 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
 781 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
 782 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
 783
 784 #endif
 785
 786 #ifndef Py_TYPE
 787 #  define Py_TYPE(op) ((op)->ob_type)
 788 #endif
 789
 790 /* SWIG APIs for compatibility of both Python 2 & 3 */
 791
 792 #if PY_VERSION_HEX >= 0x03000000
 793 #  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
 794 #else
 795 #  define SWIG_Python_str_FromFormat PyString_FromFormat
 796 #endif
 797
 798
 799 /* Warning: This function will allocate a new string in Python 3,
 800  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
 801  */
 802 SWIGINTERN char*
 803 SWIG_Python_str_AsChar(PyObject *str)
 804 {
 805 #if PY_VERSION_HEX >= 0x03000000
 806   char *cstr;
 807   char *newstr;
 808   Py_ssize_t len;
 809   str = PyUnicode_AsUTF8String(str);
 810   PyBytes_AsStringAndSize(str, &cstr, &len);
 811   newstr = (char *) malloc(len+1);
 812   memcpy(newstr, cstr, len+1);
 813   Py_XDECREF(str);
 814   return newstr;
 815 #else
 816   return PyString_AsString(str);
 817 #endif
 818 }
 819
 820 #if PY_VERSION_HEX >= 0x03000000
 821 #  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
 822 #else
 823 #  define SWIG_Python_str_DelForPy3(x)
 824 #endif
 825
 826
 827 SWIGINTERN PyObject*
 828 SWIG_Python_str_FromChar(const char *c)
 829 {
 830 #if PY_VERSION_HEX >= 0x03000000
 831   return PyUnicode_FromString(c);
 832 #else
 833   return PyString_FromString(c);
 834 #endif
 835 }
 836
 837 /* Add PyOS_snprintf for old Pythons */
 838 #if PY_VERSION_HEX < 0x02020000
 839 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
 840 #  define PyOS_snprintf _snprintf
 841 # else
 842 #  define PyOS_snprintf snprintf
 843 # endif
 844 #endif
 845
 846 /* A crude PyString_FromFormat implementation for old Pythons */
 847 #if PY_VERSION_HEX < 0x02020000
 848
 849 #ifndef SWIG_PYBUFFER_SIZE
 850 # define SWIG_PYBUFFER_SIZE 1024
 851 #endif
 852
 853 static PyObject *
 854 PyString_FromFormat(const char *fmt, ...) {
 855   va_list ap;
 856   char buf[SWIG_PYBUFFER_SIZE * 2];
 857   int res;
 858   va_start(ap, fmt);
 859   res = vsnprintf(buf, sizeof(buf), fmt, ap);
 860   va_end(ap);
 861   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
 862 }
 863 #endif
 864
 865 #ifndef PyObject_DEL
 866 # define PyObject_DEL PyObject_Del
 867 #endif
 868
 869 /* A crude PyExc_StopIteration exception for old Pythons */
 870 #if PY_VERSION_HEX < 0x02020000
 871 # ifndef PyExc_StopIteration
 872 #  define PyExc_StopIteration PyExc_RuntimeError
 873 # endif
 874 # ifndef PyObject_GenericGetAttr
 875 #  define PyObject_GenericGetAttr 0
 876 # endif
 877 #endif
 878
 879 /* Py_NotImplemented is defined in 2.1 and up. */
 880 #if PY_VERSION_HEX < 0x02010000
 881 # ifndef Py_NotImplemented
 882 #  define Py_NotImplemented PyExc_RuntimeError
 883 # endif
 884 #endif
 885
 886 /* A crude PyString_AsStringAndSize implementation for old Pythons */
 887 #if PY_VERSION_HEX < 0x02010000
 888 # ifndef PyString_AsStringAndSize
 889 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
 890 # endif
 891 #endif
 892
 893 /* PySequence_Size for old Pythons */
 894 #if PY_VERSION_HEX < 0x02000000
 895 # ifndef PySequence_Size
 896 #  define PySequence_Size PySequence_Length
 897 # endif
 898 #endif
 899
 900 /* PyBool_FromLong for old Pythons */
 901 #if PY_VERSION_HEX < 0x02030000
 902 static
 903 PyObject *PyBool_FromLong(long ok)
 904 {
 905   PyObject *result = ok ? Py_True : Py_False;
 906   Py_INCREF(result);
 907   return result;
 908 }
 909 #endif
 910
 911 /* Py_ssize_t for old Pythons */
 912 /* This code is as recommended by: */
 913 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
 914 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
 915 typedef int Py_ssize_t;
 916 # define PY_SSIZE_T_MAX INT_MAX
 917 # define PY_SSIZE_T_MIN INT_MIN
 918 typedef inquiry lenfunc;
 919 typedef intargfunc ssizeargfunc;
 920 typedef intintargfunc ssizessizeargfunc;
 921 typedef intobjargproc ssizeobjargproc;
 922 typedef intintobjargproc ssizessizeobjargproc;
 923 typedef getreadbufferproc readbufferproc;
 924 typedef getwritebufferproc writebufferproc;
 925 typedef getsegcountproc segcountproc;
 926 typedef getcharbufferproc charbufferproc;
 927 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
 928 {
 929   long result = 0;
 930   PyObject *i = PyNumber_Int(x);
 931   if (i) {
 932     result = PyInt_AsLong(i);
 933     Py_DECREF(i);
 934   }
 935   return result;
 936 }
 937 #endif
 938
 939 #if PY_VERSION_HEX < 0x02050000
 940 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
 941 #endif
 942
 943 #if PY_VERSION_HEX < 0x02040000
 944 #define Py_VISIT(op)                            \
 945   do {                                          \
 946     if (op) {                                   \
 947       int vret = visit((op), arg);              \
 948       if (vret)                                 \
 949         return vret;                            \
 950     }                                           \
 951   } while (0)
 952 #endif
 953
 954 #if PY_VERSION_HEX < 0x02030000
 955 typedef struct {
 956   PyTypeObject type;
 957   PyNumberMethods as_number;
 958   PyMappingMethods as_mapping;
 959   PySequenceMethods as_sequence;
 960   PyBufferProcs as_buffer;
 961   PyObject *name, *slots;
 962 } PyHeapTypeObject;
 963 #endif
 964
 965 #if PY_VERSION_HEX < 0x02030000
 966 typedef destructor freefunc;
 967 #endif
 968
 969 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
 970      (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
 971      (PY_MAJOR_VERSION > 3))
 972 # define SWIGPY_USE_CAPSULE
 973 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
 974 #endif
 975
 976 #if PY_VERSION_HEX < 0x03020000
 977 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
 978 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
 979 #define Py_hash_t long
 980 #endif
 981
 982 /* -----------------------------------------------------------------------------
 983  * error manipulation
 984  * ----------------------------------------------------------------------------- */
 985
 986 SWIGRUNTIME PyObject*
 987 SWIG_Python_ErrorType(int code) {
 988   PyObject* type = 0;
 989   switch(code) {
 990   case SWIG_MemoryError:
 991     type = PyExc_MemoryError;
 992     break;
 993   case SWIG_IOError:
 994     type = PyExc_IOError;
 995     break;
 996   case SWIG_RuntimeError:
 997     type = PyExc_RuntimeError;
 998     break;
 999   case SWIG_IndexError:
1000     type = PyExc_IndexError;
1001     break;
1002   case SWIG_TypeError:
1003     type = PyExc_TypeError;
1004     break;
1005   case SWIG_DivisionByZero:
1006     type = PyExc_ZeroDivisionError;
1007     break;
1008   case SWIG_OverflowError:
1009     type = PyExc_OverflowError;
1010     break;
1011   case SWIG_SyntaxError:
1012     type = PyExc_SyntaxError;
1013     break;
1014   case SWIG_ValueError:
1015     type = PyExc_ValueError;
1016     break;
1017   case SWIG_SystemError:
1018     type = PyExc_SystemError;
1019     break;
1020   case SWIG_AttributeError:
1021     type = PyExc_AttributeError;
1022     break;
1023   default:
1024     type = PyExc_RuntimeError;
1025   }
1026   return type;
1027 }
1028
1029
1030 SWIGRUNTIME void
1031 SWIG_Python_AddErrorMsg(const char* mesg)
1032 {
1033   PyObject *type = 0;
1034   PyObject *value = 0;
1035   PyObject *traceback = 0;
1036
1037   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1038   if (value) {
1039     char *tmp;
1040     PyObject *old_str = PyObject_Str(value);
1041     PyErr_Clear();
1042     Py_XINCREF(type);
1043
1044     PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1045     SWIG_Python_str_DelForPy3(tmp);
1046     Py_DECREF(old_str);
1047     Py_DECREF(value);
1048   } else {
1049     PyErr_SetString(PyExc_RuntimeError, mesg);
1050   }
1051 }
1052
1053 #if defined(SWIG_PYTHON_NO_THREADS)
1054 #  if defined(SWIG_PYTHON_THREADS)
1055 #    undef SWIG_PYTHON_THREADS
1056 #  endif
1057 #endif
1058 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1059 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1060 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1061 #      define SWIG_PYTHON_USE_GIL
1062 #    endif
1063 #  endif
1064 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1065 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
1066 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads()
1067 #    endif
1068 #    ifdef __cplusplus /* C++ code */
1069        class SWIG_Python_Thread_Block {
1070          bool status;
1071          PyGILState_STATE state;
1072        public:
1073          void end() { if (status) { PyGILState_Release(state); status = false;} }
1074          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1075          ~SWIG_Python_Thread_Block() { end(); }
1076        };
1077        class SWIG_Python_Thread_Allow {
1078          bool status;
1079          PyThreadState *save;
1080        public:
1081          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1082          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1083          ~SWIG_Python_Thread_Allow() { end(); }
1084        };
1085 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
1086 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
1087 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
1088 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
1089 #    else /* C code */
1090 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1091 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
1092 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1093 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
1094 #    endif
1095 #  else /* Old thread way, not implemented, user must provide it */
1096 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1097 #      define SWIG_PYTHON_INITIALIZE_THREADS
1098 #    endif
1099 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1100 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1101 #    endif
1102 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1103 #      define SWIG_PYTHON_THREAD_END_BLOCK
1104 #    endif
1105 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1106 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1107 #    endif
1108 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1109 #      define SWIG_PYTHON_THREAD_END_ALLOW
1110 #    endif
1111 #  endif
1112 #else /* No thread support */
1113 #  define SWIG_PYTHON_INITIALIZE_THREADS
1114 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1115 #  define SWIG_PYTHON_THREAD_END_BLOCK
1116 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1117 #  define SWIG_PYTHON_THREAD_END_ALLOW
1118 #endif
1119
1120 /* -----------------------------------------------------------------------------
1121  * Python API portion that goes into the runtime
1122  * ----------------------------------------------------------------------------- */
1123
1124 #ifdef __cplusplus
1125 extern "C" {
1126 #endif
1127
1128 /* -----------------------------------------------------------------------------
1129  * Constant declarations
1130  * ----------------------------------------------------------------------------- */
1131
1132 /* Constant Types */
1133 #define SWIG_PY_POINTER 4
1134 #define SWIG_PY_BINARY  5
1135
1136 /* Constant information structure */
1137 typedef struct swig_const_info {
1138   int type;
1139   char *name;
1140   long lvalue;
1141   double dvalue;
1142   void   *pvalue;
1143   swig_type_info **ptype;
1144 } swig_const_info;
1145
1146
1147 /* -----------------------------------------------------------------------------
1148  * Wrapper of PyInstanceMethod_New() used in Python 3
1149  * It is exported to the generated module, used for -fastproxy
1150  * ----------------------------------------------------------------------------- */
1151 #if PY_VERSION_HEX >= 0x03000000
1152 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1153 {
1154   return PyInstanceMethod_New(func);
1155 }
1156 #else
1157 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1158 {
1159   return NULL;
1160 }
1161 #endif
1162
1163 #ifdef __cplusplus
1164 }
1165 #endif
1166
1167
1168 /* -----------------------------------------------------------------------------
1169  * pyrun.swg
1170  *
1171  * This file contains the runtime support for Python modules
1172  * and includes code for managing global variables and pointer
1173  * type checking.
1174  *
1175  * ----------------------------------------------------------------------------- */
1176
1177 /* Common SWIG API */
1178
1179 /* for raw pointers */
1180 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1181 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1182 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1183
1184 #ifdef SWIGPYTHON_BUILTIN
1185 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
1186 #else
1187 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1188 #endif
1189
1190 #define SWIG_InternalNewPointerObj(ptr, type, flags)    SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1191
1192 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty)
1193 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
1194 #define swig_owntype                                    int
1195
1196 /* for raw packed data */
1197 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1198 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1199
1200 /* for class or struct pointers */
1201 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
1202 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
1203
1204 /* for C or C++ function pointers */
1205 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1206 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1207
1208 /* for C++ member pointers, ie, member methods */
1209 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1210 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1211
1212
1213 /* Runtime API */
1214
1215 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
1216 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1217 #define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
1218
1219 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
1220 #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg
1221 #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)
1222 #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1223 #define SWIG_fail                                       goto fail
1224
1225
1226 /* Runtime API implementation */
1227
1228 /* Error manipulation */
1229
1230 SWIGINTERN void
1231 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1232   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1233   PyErr_SetObject(errtype, obj);
1234   Py_DECREF(obj);
1235   SWIG_PYTHON_THREAD_END_BLOCK;
1236 }
1237
1238 SWIGINTERN void
1239 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1240   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1241   PyErr_SetString(errtype, msg);
1242   SWIG_PYTHON_THREAD_END_BLOCK;
1243 }
1244
1245 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1246
1247 /* Set a constant value */
1248
1249 #if defined(SWIGPYTHON_BUILTIN)
1250
1251 SWIGINTERN void
1252 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1253   PyObject *s = PyString_InternFromString(key);
1254   PyList_Append(seq, s);
1255   Py_DECREF(s);
1256 }
1257
1258 SWIGINTERN void
1259 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1260 #if PY_VERSION_HEX < 0x02030000
1261   PyDict_SetItemString(d, (char *)name, obj);
1262 #else
1263   PyDict_SetItemString(d, name, obj);
1264 #endif
1265   Py_DECREF(obj);
1266   if (public_interface)
1267     SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1268 }
1269
1270 #else
1271
1272 SWIGINTERN void
1273 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1274 #if PY_VERSION_HEX < 0x02030000
1275   PyDict_SetItemString(d, (char *)name, obj);
1276 #else
1277   PyDict_SetItemString(d, name, obj);
1278 #endif
1279   Py_DECREF(obj);
1280 }
1281
1282 #endif
1283
1284 /* Append a value to the result obj */
1285
1286 SWIGINTERN PyObject*
1287 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1288 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1289   if (!result) {
1290     result = obj;
1291   } else if (result == Py_None) {
1292     Py_DECREF(result);
1293     result = obj;
1294   } else {
1295     if (!PyList_Check(result)) {
1296       PyObject *o2 = result;
1297       result = PyList_New(1);
1298       PyList_SetItem(result, 0, o2);
1299     }
1300     PyList_Append(result,obj);
1301     Py_DECREF(obj);
1302   }
1303   return result;
1304 #else
1305   PyObject*   o2;
1306   PyObject*   o3;
1307   if (!result) {
1308     result = obj;
1309   } else if (result == Py_None) {
1310     Py_DECREF(result);
1311     result = obj;
1312   } else {
1313     if (!PyTuple_Check(result)) {
1314       o2 = result;
1315       result = PyTuple_New(1);
1316       PyTuple_SET_ITEM(result, 0, o2);
1317     }
1318     o3 = PyTuple_New(1);
1319     PyTuple_SET_ITEM(o3, 0, obj);
1320     o2 = result;
1321     result = PySequence_Concat(o2, o3);
1322     Py_DECREF(o2);
1323     Py_DECREF(o3);
1324   }
1325   return result;
1326 #endif
1327 }
1328
1329 /* Unpack the argument tuple */
1330
1331 SWIGINTERN Py_ssize_t
1332 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1333 {
1334   if (!args) {
1335     if (!min && !max) {
1336       return 1;
1337     } else {
1338       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1339                    name, (min == max ? "" : "at least "), (int)min);
1340       return 0;
1341     }
1342   }
1343   if (!PyTuple_Check(args)) {
1344     if (min <= 1 && max >= 1) {
1345       Py_ssize_t i;
1346       objs[0] = args;
1347       for (i = 1; i < max; ++i) {
1348         objs[i] = 0;
1349       }
1350       return 2;
1351     }
1352     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1353     return 0;
1354   } else {
1355     Py_ssize_t l = PyTuple_GET_SIZE(args);
1356     if (l < min) {
1357       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1358                    name, (min == max ? "" : "at least "), (int)min, (int)l);
1359       return 0;
1360     } else if (l > max) {
1361       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1362                    name, (min == max ? "" : "at most "), (int)max, (int)l);
1363       return 0;
1364     } else {
1365       Py_ssize_t i;
1366       for (i = 0; i < l; ++i) {
1367         objs[i] = PyTuple_GET_ITEM(args, i);
1368       }
1369       for (; l < max; ++l) {
1370         objs[l] = 0;
1371       }
1372       return i + 1;
1373     }
1374   }
1375 }
1376
1377 /* A functor is a function object with one single object argument */
1378 #if PY_VERSION_HEX >= 0x02020000
1379 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
1380 #else
1381 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
1382 #endif
1383
1384 /*
1385   Helper for static pointer initialization for both C and C++ code, for example
1386   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1387 */
1388 #ifdef __cplusplus
1389 #define SWIG_STATIC_POINTER(var)  var
1390 #else
1391 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1392 #endif
1393
1394 /* -----------------------------------------------------------------------------
1395  * Pointer declarations
1396  * ----------------------------------------------------------------------------- */
1397
1398 /* Flags for new pointer objects */
1399 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
1400 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1401
1402 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1403
1404 #define SWIG_BUILTIN_TP_INIT        (SWIG_POINTER_OWN << 2)
1405 #define SWIG_BUILTIN_INIT           (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1406
1407 #ifdef __cplusplus
1408 extern "C" {
1409 #endif
1410
1411 /*  How to access Py_None */
1412 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1413 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
1414 #    ifndef SWIG_PYTHON_BUILD_NONE
1415 #      define SWIG_PYTHON_BUILD_NONE
1416 #    endif
1417 #  endif
1418 #endif
1419
1420 #ifdef SWIG_PYTHON_BUILD_NONE
1421 #  ifdef Py_None
1422 #   undef Py_None
1423 #   define Py_None SWIG_Py_None()
1424 #  endif
1425 SWIGRUNTIMEINLINE PyObject *
1426 _SWIG_Py_None(void)
1427 {
1428   PyObject *none = Py_BuildValue((char*)"");
1429   Py_DECREF(none);
1430   return none;
1431 }
1432 SWIGRUNTIME PyObject *
1433 SWIG_Py_None(void)
1434 {
1435   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1436   return none;
1437 }
1438 #endif
1439
1440 /* The python void return value */
1441
1442 SWIGRUNTIMEINLINE PyObject *
1443 SWIG_Py_Void(void)
1444 {
1445   PyObject *none = Py_None;
1446   Py_INCREF(none);
1447   return none;
1448 }
1449
1450 /* SwigPyClientData */
1451
1452 typedef struct {
1453   PyObject *klass;
1454   PyObject *newraw;
1455   PyObject *newargs;
1456   PyObject *destroy;
1457   int delargs;
1458   int implicitconv;
1459   PyTypeObject *pytype;
1460 } SwigPyClientData;
1461
1462 SWIGRUNTIMEINLINE int
1463 SWIG_Python_CheckImplicit(swig_type_info *ty)
1464 {
1465   SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1466   return data ? data->implicitconv : 0;
1467 }
1468
1469 SWIGRUNTIMEINLINE PyObject *
1470 SWIG_Python_ExceptionType(swig_type_info *desc) {
1471   SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1472   PyObject *klass = data ? data->klass : 0;
1473   return (klass ? klass : PyExc_RuntimeError);
1474 }
1475
1476
1477 SWIGRUNTIME SwigPyClientData *
1478 SwigPyClientData_New(PyObject* obj)
1479 {
1480   if (!obj) {
1481     return 0;
1482   } else {
1483     SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1484     /* the klass element */
1485     data->klass = obj;
1486     Py_INCREF(data->klass);
1487     /* the newraw method and newargs arguments used to create a new raw instance */
1488     if (PyClass_Check(obj)) {
1489       data->newraw = 0;
1490       data->newargs = obj;
1491       Py_INCREF(obj);
1492     } else {
1493 #if (PY_VERSION_HEX < 0x02020000)
1494       data->newraw = 0;
1495 #else
1496       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1497 #endif
1498       if (data->newraw) {
1499         Py_INCREF(data->newraw);
1500         data->newargs = PyTuple_New(1);
1501         PyTuple_SetItem(data->newargs, 0, obj);
1502       } else {
1503         data->newargs = obj;
1504       }
1505       Py_INCREF(data->newargs);
1506     }
1507     /* the destroy method, aka as the C++ delete method */
1508     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1509     if (PyErr_Occurred()) {
1510       PyErr_Clear();
1511       data->destroy = 0;
1512     }
1513     if (data->destroy) {
1514       int flags;
1515       Py_INCREF(data->destroy);
1516       flags = PyCFunction_GET_FLAGS(data->destroy);
1517 #ifdef METH_O
1518       data->delargs = !(flags & (METH_O));
1519 #else
1520       data->delargs = 0;
1521 #endif
1522     } else {
1523       data->delargs = 0;
1524     }
1525     data->implicitconv = 0;
1526     data->pytype = 0;
1527     return data;
1528   }
1529 }
1530
1531 SWIGRUNTIME void
1532 SwigPyClientData_Del(SwigPyClientData *data) {
1533   Py_XDECREF(data->newraw);
1534   Py_XDECREF(data->newargs);
1535   Py_XDECREF(data->destroy);
1536 }
1537
1538 /* =============== SwigPyObject =====================*/
1539
1540 typedef struct {
1541   PyObject_HEAD
1542   void *ptr;
1543   swig_type_info *ty;
1544   int own;
1545   PyObject *next;
1546 #ifdef SWIGPYTHON_BUILTIN
1547   PyObject *dict;
1548 #endif
1549 } SwigPyObject;
1550
1551
1552 #ifdef SWIGPYTHON_BUILTIN
1553
1554 SWIGRUNTIME PyObject *
1555 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1556 {
1557   SwigPyObject *sobj = (SwigPyObject *)v;
1558
1559   if (!sobj->dict)
1560     sobj->dict = PyDict_New();
1561
1562   Py_INCREF(sobj->dict);
1563   return sobj->dict;
1564 }
1565
1566 #endif
1567
1568 SWIGRUNTIME PyObject *
1569 SwigPyObject_long(SwigPyObject *v)
1570 {
1571   return PyLong_FromVoidPtr(v->ptr);
1572 }
1573
1574 SWIGRUNTIME PyObject *
1575 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1576 {
1577   PyObject *res = NULL;
1578   PyObject *args = PyTuple_New(1);
1579   if (args) {
1580     if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1581       PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1582       if (ofmt) {
1583 #if PY_VERSION_HEX >= 0x03000000
1584         res = PyUnicode_Format(ofmt,args);
1585 #else
1586         res = PyString_Format(ofmt,args);
1587 #endif
1588         Py_DECREF(ofmt);
1589       }
1590       Py_DECREF(args);
1591     }
1592   }
1593   return res;
1594 }
1595
1596 SWIGRUNTIME PyObject *
1597 SwigPyObject_oct(SwigPyObject *v)
1598 {
1599   return SwigPyObject_format("%o",v);
1600 }
1601
1602 SWIGRUNTIME PyObject *
1603 SwigPyObject_hex(SwigPyObject *v)
1604 {
1605   return SwigPyObject_format("%x",v);
1606 }
1607
1608 SWIGRUNTIME PyObject *
1609 #ifdef METH_NOARGS
1610 SwigPyObject_repr(SwigPyObject *v)
1611 #else
1612 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1613 #endif
1614 {
1615   const char *name = SWIG_TypePrettyName(v->ty);
1616   PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1617   if (v->next) {
1618 # ifdef METH_NOARGS
1619     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1620 # else
1621     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1622 # endif
1623 # if PY_VERSION_HEX >= 0x03000000
1624     PyObject *joined = PyUnicode_Concat(repr, nrep);
1625     Py_DecRef(repr);
1626     Py_DecRef(nrep);
1627     repr = joined;
1628 # else
1629     PyString_ConcatAndDel(&repr,nrep);
1630 # endif
1631   }
1632   return repr;
1633 }
1634
1635 SWIGRUNTIME int
1636 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1637 {
1638   void *i = v->ptr;
1639   void *j = w->ptr;
1640   return (i < j) ? -1 : ((i > j) ? 1 : 0);
1641 }
1642
1643 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1644 SWIGRUNTIME PyObject*
1645 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1646 {
1647   PyObject* res;
1648   if( op != Py_EQ && op != Py_NE ) {
1649     Py_INCREF(Py_NotImplemented);
1650     return Py_NotImplemented;
1651   }
1652   res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1653   return res;
1654 }
1655
1656
1657 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1658
1659 #ifdef SWIGPYTHON_BUILTIN
1660 static swig_type_info *SwigPyObject_stype = 0;
1661 SWIGRUNTIME PyTypeObject*
1662 SwigPyObject_type(void) {
1663     SwigPyClientData *cd;
1664     assert(SwigPyObject_stype);
1665     cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1666     assert(cd);
1667     assert(cd->pytype);
1668     return cd->pytype;
1669 }
1670 #else
1671 SWIGRUNTIME PyTypeObject*
1672 SwigPyObject_type(void) {
1673   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1674   return type;
1675 }
1676 #endif
1677
1678 SWIGRUNTIMEINLINE int
1679 SwigPyObject_Check(PyObject *op) {
1680 #ifdef SWIGPYTHON_BUILTIN
1681   PyTypeObject *target_tp = SwigPyObject_type();
1682   if (PyType_IsSubtype(op->ob_type, target_tp))
1683     return 1;
1684   return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1685 #else
1686   return (Py_TYPE(op) == SwigPyObject_type())
1687     || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1688 #endif
1689 }
1690
1691 SWIGRUNTIME PyObject *
1692 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1693
1694 SWIGRUNTIME void
1695 SwigPyObject_dealloc(PyObject *v)
1696 {
1697   SwigPyObject *sobj = (SwigPyObject *) v;
1698   PyObject *next = sobj->next;
1699   if (sobj->own == SWIG_POINTER_OWN) {
1700     swig_type_info *ty = sobj->ty;
1701     SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1702     PyObject *destroy = data ? data->destroy : 0;
1703     if (destroy) {
1704       /* destroy is always a VARARGS method */
1705       PyObject *res;
1706
1707       /* PyObject_CallFunction() has the potential to silently drop
1708          the active active exception.  In cases of unnamed temporary
1709          variable or where we just finished iterating over a generator
1710          StopIteration will be active right now, and this needs to
1711          remain true upon return from SwigPyObject_dealloc.  So save
1712          and restore. */
1713
1714       PyObject *val = NULL, *type = NULL, *tb = NULL;
1715       PyErr_Fetch(&val, &type, &tb);
1716
1717       if (data->delargs) {
1718         /* we need to create a temporary object to carry the destroy operation */
1719         PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1720         res = SWIG_Python_CallFunctor(destroy, tmp);
1721         Py_DECREF(tmp);
1722       } else {
1723         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1724         PyObject *mself = PyCFunction_GET_SELF(destroy);
1725         res = ((*meth)(mself, v));
1726       }
1727       if (!res)
1728         PyErr_WriteUnraisable(destroy);
1729
1730       PyErr_Restore(val, type, tb);
1731
1732       Py_XDECREF(res);
1733     }
1734 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1735     else {
1736       const char *name = SWIG_TypePrettyName(ty);
1737       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1738     }
1739 #endif
1740   }
1741   Py_XDECREF(next);
1742   PyObject_DEL(v);
1743 }
1744
1745 SWIGRUNTIME PyObject*
1746 SwigPyObject_append(PyObject* v, PyObject* next)
1747 {
1748   SwigPyObject *sobj = (SwigPyObject *) v;
1749 #ifndef METH_O
1750   PyObject *tmp = 0;
1751   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1752   next = tmp;
1753 #endif
1754   if (!SwigPyObject_Check(next)) {
1755     PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1756     return NULL;
1757   }
1758   sobj->next = next;
1759   Py_INCREF(next);
1760   return SWIG_Py_Void();
1761 }
1762
1763 SWIGRUNTIME PyObject*
1764 #ifdef METH_NOARGS
1765 SwigPyObject_next(PyObject* v)
1766 #else
1767 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1768 #endif
1769 {
1770   SwigPyObject *sobj = (SwigPyObject *) v;
1771   if (sobj->next) {
1772     Py_INCREF(sobj->next);
1773     return sobj->next;
1774   } else {
1775     return SWIG_Py_Void();
1776   }
1777 }
1778
1779 SWIGINTERN PyObject*
1780 #ifdef METH_NOARGS
1781 SwigPyObject_disown(PyObject *v)
1782 #else
1783 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1784 #endif
1785 {
1786   SwigPyObject *sobj = (SwigPyObject *)v;
1787   sobj->own = 0;
1788   return SWIG_Py_Void();
1789 }
1790
1791 SWIGINTERN PyObject*
1792 #ifdef METH_NOARGS
1793 SwigPyObject_acquire(PyObject *v)
1794 #else
1795 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1796 #endif
1797 {
1798   SwigPyObject *sobj = (SwigPyObject *)v;
1799   sobj->own = SWIG_POINTER_OWN;
1800   return SWIG_Py_Void();
1801 }
1802
1803 SWIGINTERN PyObject*
1804 SwigPyObject_own(PyObject *v, PyObject *args)
1805 {
1806   PyObject *val = 0;
1807 #if (PY_VERSION_HEX < 0x02020000)
1808   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1809 #elif (PY_VERSION_HEX < 0x02050000)
1810   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1811 #else
1812   if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1813 #endif
1814     {
1815       return NULL;
1816     }
1817   else
1818     {
1819       SwigPyObject *sobj = (SwigPyObject *)v;
1820       PyObject *obj = PyBool_FromLong(sobj->own);
1821       if (val) {
1822 #ifdef METH_NOARGS
1823         if (PyObject_IsTrue(val)) {
1824           SwigPyObject_acquire(v);
1825         } else {
1826           SwigPyObject_disown(v);
1827         }
1828 #else
1829         if (PyObject_IsTrue(val)) {
1830           SwigPyObject_acquire(v,args);
1831         } else {
1832           SwigPyObject_disown(v,args);
1833         }
1834 #endif
1835       }
1836       return obj;
1837     }
1838 }
1839
1840 #ifdef METH_O
1841 static PyMethodDef
1842 swigobject_methods[] = {
1843   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1844   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
1845   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1846   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
1847   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1848   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1849   {0, 0, 0, 0}
1850 };
1851 #else
1852 static PyMethodDef
1853 swigobject_methods[] = {
1854   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1855   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"acquires ownership of the pointer"},
1856   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1857   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1858   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1859   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1860   {0, 0, 0, 0}
1861 };
1862 #endif
1863
1864 #if PY_VERSION_HEX < 0x02020000
1865 SWIGINTERN PyObject *
1866 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1867 {
1868   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1869 }
1870 #endif
1871
1872 SWIGRUNTIME PyTypeObject*
1873 SwigPyObject_TypeOnce(void) {
1874   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1875
1876   static PyNumberMethods SwigPyObject_as_number = {
1877     (binaryfunc)0, /*nb_add*/
1878     (binaryfunc)0, /*nb_subtract*/
1879     (binaryfunc)0, /*nb_multiply*/
1880     /* nb_divide removed in Python 3 */
1881 #if PY_VERSION_HEX < 0x03000000
1882     (binaryfunc)0, /*nb_divide*/
1883 #endif
1884     (binaryfunc)0, /*nb_remainder*/
1885     (binaryfunc)0, /*nb_divmod*/
1886     (ternaryfunc)0,/*nb_power*/
1887     (unaryfunc)0,  /*nb_negative*/
1888     (unaryfunc)0,  /*nb_positive*/
1889     (unaryfunc)0,  /*nb_absolute*/
1890     (inquiry)0,    /*nb_nonzero*/
1891     0,             /*nb_invert*/
1892     0,             /*nb_lshift*/
1893     0,             /*nb_rshift*/
1894     0,             /*nb_and*/
1895     0,             /*nb_xor*/
1896     0,             /*nb_or*/
1897 #if PY_VERSION_HEX < 0x03000000
1898     0,   /*nb_coerce*/
1899 #endif
1900     (unaryfunc)SwigPyObject_long, /*nb_int*/
1901 #if PY_VERSION_HEX < 0x03000000
1902     (unaryfunc)SwigPyObject_long, /*nb_long*/
1903 #else
1904     0, /*nb_reserved*/
1905 #endif
1906     (unaryfunc)0,                 /*nb_float*/
1907 #if PY_VERSION_HEX < 0x03000000
1908     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
1909     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
1910 #endif
1911 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1912     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1913 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1914     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1915 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1916     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1917 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1918     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1919 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1920     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1921 #endif
1922   };
1923
1924   static PyTypeObject swigpyobject_type;
1925   static int type_init = 0;
1926   if (!type_init) {
1927     const PyTypeObject tmp = {
1928 #if PY_VERSION_HEX >= 0x03000000
1929       PyVarObject_HEAD_INIT(NULL, 0)
1930 #else
1931       PyObject_HEAD_INIT(NULL)
1932       0,                                    /* ob_size */
1933 #endif
1934       (char *)"SwigPyObject",               /* tp_name */
1935       sizeof(SwigPyObject),                 /* tp_basicsize */
1936       0,                                    /* tp_itemsize */
1937       (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
1938       0,                                    /* tp_print */
1939 #if PY_VERSION_HEX < 0x02020000
1940       (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
1941 #else
1942       (getattrfunc)0,                       /* tp_getattr */
1943 #endif
1944       (setattrfunc)0,                       /* tp_setattr */
1945 #if PY_VERSION_HEX >= 0x03000000
1946       0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1947 #else
1948       (cmpfunc)SwigPyObject_compare,        /* tp_compare */
1949 #endif
1950       (reprfunc)SwigPyObject_repr,          /* tp_repr */
1951       &SwigPyObject_as_number,              /* tp_as_number */
1952       0,                                    /* tp_as_sequence */
1953       0,                                    /* tp_as_mapping */
1954       (hashfunc)0,                          /* tp_hash */
1955       (ternaryfunc)0,                       /* tp_call */
1956       0,                                    /* tp_str */
1957       PyObject_GenericGetAttr,              /* tp_getattro */
1958       0,                                    /* tp_setattro */
1959       0,                                    /* tp_as_buffer */
1960       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
1961       swigobject_doc,                       /* tp_doc */
1962       0,                                    /* tp_traverse */
1963       0,                                    /* tp_clear */
1964       (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1965       0,                                    /* tp_weaklistoffset */
1966 #if PY_VERSION_HEX >= 0x02020000
1967       0,                                    /* tp_iter */
1968       0,                                    /* tp_iternext */
1969       swigobject_methods,                   /* tp_methods */
1970       0,                                    /* tp_members */
1971       0,                                    /* tp_getset */
1972       0,                                    /* tp_base */
1973       0,                                    /* tp_dict */
1974       0,                                    /* tp_descr_get */
1975       0,                                    /* tp_descr_set */
1976       0,                                    /* tp_dictoffset */
1977       0,                                    /* tp_init */
1978       0,                                    /* tp_alloc */
1979       0,                                    /* tp_new */
1980       0,                                    /* tp_free */
1981       0,                                    /* tp_is_gc */
1982       0,                                    /* tp_bases */
1983       0,                                    /* tp_mro */
1984       0,                                    /* tp_cache */
1985       0,                                    /* tp_subclasses */
1986       0,                                    /* tp_weaklist */
1987 #endif
1988 #if PY_VERSION_HEX >= 0x02030000
1989       0,                                    /* tp_del */
1990 #endif
1991 #if PY_VERSION_HEX >= 0x02060000
1992       0,                                    /* tp_version_tag */
1993 #endif
1994 #if PY_VERSION_HEX >= 0x03040000
1995       0,                                    /* tp_finalize */
1996 #endif
1997 #ifdef COUNT_ALLOCS
1998       0,                                    /* tp_allocs */
1999       0,                                    /* tp_frees */
2000       0,                                    /* tp_maxalloc */
2001 #if PY_VERSION_HEX >= 0x02050000
2002       0,                                    /* tp_prev */
2003 #endif
2004       0                                     /* tp_next */
2005 #endif
2006     };
2007     swigpyobject_type = tmp;
2008     type_init = 1;
2009 #if PY_VERSION_HEX < 0x02020000
2010     swigpyobject_type.ob_type = &PyType_Type;
2011 #else
2012     if (PyType_Ready(&swigpyobject_type) < 0)
2013       return NULL;
2014 #endif
2015   }
2016   return &swigpyobject_type;
2017 }
2018
2019 SWIGRUNTIME PyObject *
2020 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2021 {
2022   SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2023   if (sobj) {
2024     sobj->ptr  = ptr;
2025     sobj->ty   = ty;
2026     sobj->own  = own;
2027     sobj->next = 0;
2028   }
2029   return (PyObject *)sobj;
2030 }
2031
2032 /* -----------------------------------------------------------------------------
2033  * Implements a simple Swig Packed type, and use it instead of string
2034  * ----------------------------------------------------------------------------- */
2035
2036 typedef struct {
2037   PyObject_HEAD
2038   void *pack;
2039   swig_type_info *ty;
2040   size_t size;
2041 } SwigPyPacked;
2042
2043 SWIGRUNTIME int
2044 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2045 {
2046   char result[SWIG_BUFFER_SIZE];
2047   fputs("<Swig Packed ", fp);
2048   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2049     fputs("at ", fp);
2050     fputs(result, fp);
2051   }
2052   fputs(v->ty->name,fp);
2053   fputs(">", fp);
2054   return 0;
2055 }
2056
2057 SWIGRUNTIME PyObject *
2058 SwigPyPacked_repr(SwigPyPacked *v)
2059 {
2060   char result[SWIG_BUFFER_SIZE];
2061   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2062     return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2063   } else {
2064     return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2065   }
2066 }
2067
2068 SWIGRUNTIME PyObject *
2069 SwigPyPacked_str(SwigPyPacked *v)
2070 {
2071   char result[SWIG_BUFFER_SIZE];
2072   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2073     return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2074   } else {
2075     return SWIG_Python_str_FromChar(v->ty->name);
2076   }
2077 }
2078
2079 SWIGRUNTIME int
2080 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2081 {
2082   size_t i = v->size;
2083   size_t j = w->size;
2084   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2085   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2086 }
2087
2088 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2089
2090 SWIGRUNTIME PyTypeObject*
2091 SwigPyPacked_type(void) {
2092   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2093   return type;
2094 }
2095
2096 SWIGRUNTIMEINLINE int
2097 SwigPyPacked_Check(PyObject *op) {
2098   return ((op)->ob_type == SwigPyPacked_TypeOnce())
2099     || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2100 }
2101
2102 SWIGRUNTIME void
2103 SwigPyPacked_dealloc(PyObject *v)
2104 {
2105   if (SwigPyPacked_Check(v)) {
2106     SwigPyPacked *sobj = (SwigPyPacked *) v;
2107     free(sobj->pack);
2108   }
2109   PyObject_DEL(v);
2110 }
2111
2112 SWIGRUNTIME PyTypeObject*
2113 SwigPyPacked_TypeOnce(void) {
2114   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2115   static PyTypeObject swigpypacked_type;
2116   static int type_init = 0;
2117   if (!type_init) {
2118     const PyTypeObject tmp = {
2119 #if PY_VERSION_HEX>=0x03000000
2120       PyVarObject_HEAD_INIT(NULL, 0)
2121 #else
2122       PyObject_HEAD_INIT(NULL)
2123       0,                                    /* ob_size */
2124 #endif
2125       (char *)"SwigPyPacked",               /* tp_name */
2126       sizeof(SwigPyPacked),                 /* tp_basicsize */
2127       0,                                    /* tp_itemsize */
2128       (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
2129       (printfunc)SwigPyPacked_print,        /* tp_print */
2130       (getattrfunc)0,                       /* tp_getattr */
2131       (setattrfunc)0,                       /* tp_setattr */
2132 #if PY_VERSION_HEX>=0x03000000
2133       0, /* tp_reserved in 3.0.1 */
2134 #else
2135       (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
2136 #endif
2137       (reprfunc)SwigPyPacked_repr,          /* tp_repr */
2138       0,                                    /* tp_as_number */
2139       0,                                    /* tp_as_sequence */
2140       0,                                    /* tp_as_mapping */
2141       (hashfunc)0,                          /* tp_hash */
2142       (ternaryfunc)0,                       /* tp_call */
2143       (reprfunc)SwigPyPacked_str,           /* tp_str */
2144       PyObject_GenericGetAttr,              /* tp_getattro */
2145       0,                                    /* tp_setattro */
2146       0,                                    /* tp_as_buffer */
2147       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
2148       swigpacked_doc,                       /* tp_doc */
2149       0,                                    /* tp_traverse */
2150       0,                                    /* tp_clear */
2151       0,                                    /* tp_richcompare */
2152       0,                                    /* tp_weaklistoffset */
2153 #if PY_VERSION_HEX >= 0x02020000
2154       0,                                    /* tp_iter */
2155       0,                                    /* tp_iternext */
2156       0,                                    /* tp_methods */
2157       0,                                    /* tp_members */
2158       0,                                    /* tp_getset */
2159       0,                                    /* tp_base */
2160       0,                                    /* tp_dict */
2161       0,                                    /* tp_descr_get */
2162       0,                                    /* tp_descr_set */
2163       0,                                    /* tp_dictoffset */
2164       0,                                    /* tp_init */
2165       0,                                    /* tp_alloc */
2166       0,                                    /* tp_new */
2167       0,                                    /* tp_free */
2168       0,                                    /* tp_is_gc */
2169       0,                                    /* tp_bases */
2170       0,                                    /* tp_mro */
2171       0,                                    /* tp_cache */
2172       0,                                    /* tp_subclasses */
2173       0,                                    /* tp_weaklist */
2174 #endif
2175 #if PY_VERSION_HEX >= 0x02030000
2176       0,                                    /* tp_del */
2177 #endif
2178 #if PY_VERSION_HEX >= 0x02060000
2179       0,                                    /* tp_version_tag */
2180 #endif
2181 #if PY_VERSION_HEX >= 0x03040000
2182       0,                                    /* tp_finalize */
2183 #endif
2184 #ifdef COUNT_ALLOCS
2185       0,                                    /* tp_allocs */
2186       0,                                    /* tp_frees */
2187       0,                                    /* tp_maxalloc */
2188 #if PY_VERSION_HEX >= 0x02050000
2189       0,                                    /* tp_prev */
2190 #endif
2191       0                                     /* tp_next */
2192 #endif
2193     };
2194     swigpypacked_type = tmp;
2195     type_init = 1;
2196 #if PY_VERSION_HEX < 0x02020000
2197     swigpypacked_type.ob_type = &PyType_Type;
2198 #else
2199     if (PyType_Ready(&swigpypacked_type) < 0)
2200       return NULL;
2201 #endif
2202   }
2203   return &swigpypacked_type;
2204 }
2205
2206 SWIGRUNTIME PyObject *
2207 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2208 {
2209   SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2210   if (sobj) {
2211     void *pack = malloc(size);
2212     if (pack) {
2213       memcpy(pack, ptr, size);
2214       sobj->pack = pack;
2215       sobj->ty   = ty;
2216       sobj->size = size;
2217     } else {
2218       PyObject_DEL((PyObject *) sobj);
2219       sobj = 0;
2220     }
2221   }
2222   return (PyObject *) sobj;
2223 }
2224
2225 SWIGRUNTIME swig_type_info *
2226 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2227 {
2228   if (SwigPyPacked_Check(obj)) {
2229     SwigPyPacked *sobj = (SwigPyPacked *)obj;
2230     if (sobj->size != size) return 0;
2231     memcpy(ptr, sobj->pack, size);
2232     return sobj->ty;
2233   } else {
2234     return 0;
2235   }
2236 }
2237
2238 /* -----------------------------------------------------------------------------
2239  * pointers/data manipulation
2240  * ----------------------------------------------------------------------------- */
2241
2242 SWIGRUNTIMEINLINE PyObject *
2243 _SWIG_This(void)
2244 {
2245     return SWIG_Python_str_FromChar("this");
2246 }
2247
2248 static PyObject *swig_this = NULL;
2249
2250 SWIGRUNTIME PyObject *
2251 SWIG_This(void)
2252 {
2253   if (swig_this == NULL)
2254     swig_this = _SWIG_This();
2255   return swig_this;
2256 }
2257
2258 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2259
2260 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2261 #if PY_VERSION_HEX>=0x03000000
2262 #define SWIG_PYTHON_SLOW_GETSET_THIS
2263 #endif
2264
2265 SWIGRUNTIME SwigPyObject *
2266 SWIG_Python_GetSwigThis(PyObject *pyobj)
2267 {
2268   PyObject *obj;
2269
2270   if (SwigPyObject_Check(pyobj))
2271     return (SwigPyObject *) pyobj;
2272
2273 #ifdef SWIGPYTHON_BUILTIN
2274   (void)obj;
2275 # ifdef PyWeakref_CheckProxy
2276   if (PyWeakref_CheckProxy(pyobj)) {
2277     pyobj = PyWeakref_GET_OBJECT(pyobj);
2278     if (pyobj && SwigPyObject_Check(pyobj))
2279       return (SwigPyObject*) pyobj;
2280   }
2281 # endif
2282   return NULL;
2283 #else
2284
2285   obj = 0;
2286
2287 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2288   if (PyInstance_Check(pyobj)) {
2289     obj = _PyInstance_Lookup(pyobj, SWIG_This());
2290   } else {
2291     PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2292     if (dictptr != NULL) {
2293       PyObject *dict = *dictptr;
2294       obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2295     } else {
2296 #ifdef PyWeakref_CheckProxy
2297       if (PyWeakref_CheckProxy(pyobj)) {
2298         PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2299         return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2300       }
2301 #endif
2302       obj = PyObject_GetAttr(pyobj,SWIG_This());
2303       if (obj) {
2304         Py_DECREF(obj);
2305       } else {
2306         if (PyErr_Occurred()) PyErr_Clear();
2307         return 0;
2308       }
2309     }
2310   }
2311 #else
2312   obj = PyObject_GetAttr(pyobj,SWIG_This());
2313   if (obj) {
2314     Py_DECREF(obj);
2315   } else {
2316     if (PyErr_Occurred()) PyErr_Clear();
2317     return 0;
2318   }
2319 #endif
2320   if (obj && !SwigPyObject_Check(obj)) {
2321     /* a PyObject is called 'this', try to get the 'real this'
2322        SwigPyObject from it */
2323     return SWIG_Python_GetSwigThis(obj);
2324   }
2325   return (SwigPyObject *)obj;
2326 #endif
2327 }
2328
2329 /* Acquire a pointer value */
2330
2331 SWIGRUNTIME int
2332 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2333   if (own == SWIG_POINTER_OWN) {
2334     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2335     if (sobj) {
2336       int oldown = sobj->own;
2337       sobj->own = own;
2338       return oldown;
2339     }
2340   }
2341   return 0;
2342 }
2343
2344 /* Convert a pointer value */
2345
2346 SWIGRUNTIME int
2347 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2348   int res;
2349   SwigPyObject *sobj;
2350   int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2351
2352   if (!obj)
2353     return SWIG_ERROR;
2354   if (obj == Py_None && !implicit_conv) {
2355     if (ptr)
2356       *ptr = 0;
2357     return SWIG_OK;
2358   }
2359
2360   res = SWIG_ERROR;
2361
2362   sobj = SWIG_Python_GetSwigThis(obj);
2363   if (own)
2364     *own = 0;
2365   while (sobj) {
2366     void *vptr = sobj->ptr;
2367     if (ty) {
2368       swig_type_info *to = sobj->ty;
2369       if (to == ty) {
2370         /* no type cast needed */
2371         if (ptr) *ptr = vptr;
2372         break;
2373       } else {
2374         swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2375         if (!tc) {
2376           sobj = (SwigPyObject *)sobj->next;
2377         } else {
2378           if (ptr) {
2379             int newmemory = 0;
2380             *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2381             if (newmemory == SWIG_CAST_NEW_MEMORY) {
2382               assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2383               if (own)
2384                 *own = *own | SWIG_CAST_NEW_MEMORY;
2385             }
2386           }
2387           break;
2388         }
2389       }
2390     } else {
2391       if (ptr) *ptr = vptr;
2392       break;
2393     }
2394   }
2395   if (sobj) {
2396     if (own)
2397       *own = *own | sobj->own;
2398     if (flags & SWIG_POINTER_DISOWN) {
2399       sobj->own = 0;
2400     }
2401     res = SWIG_OK;
2402   } else {
2403     if (implicit_conv) {
2404       SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2405       if (data && !data->implicitconv) {
2406         PyObject *klass = data->klass;
2407         if (klass) {
2408           PyObject *impconv;
2409           data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2410           impconv = SWIG_Python_CallFunctor(klass, obj);
2411           data->implicitconv = 0;
2412           if (PyErr_Occurred()) {
2413             PyErr_Clear();
2414             impconv = 0;
2415           }
2416           if (impconv) {
2417             SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2418             if (iobj) {
2419               void *vptr;
2420               res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2421               if (SWIG_IsOK(res)) {
2422                 if (ptr) {
2423                   *ptr = vptr;
2424                   /* transfer the ownership to 'ptr' */
2425                   iobj->own = 0;
2426                   res = SWIG_AddCast(res);
2427                   res = SWIG_AddNewMask(res);
2428                 } else {
2429                   res = SWIG_AddCast(res);
2430                 }
2431               }
2432             }
2433             Py_DECREF(impconv);
2434           }
2435         }
2436       }
2437     }
2438     if (!SWIG_IsOK(res) && obj == Py_None) {
2439       if (ptr)
2440         *ptr = 0;
2441       if (PyErr_Occurred())
2442         PyErr_Clear();
2443       res = SWIG_OK;
2444     }
2445   }
2446   return res;
2447 }
2448
2449 /* Convert a function ptr value */
2450
2451 SWIGRUNTIME int
2452 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2453   if (!PyCFunction_Check(obj)) {
2454     return SWIG_ConvertPtr(obj, ptr, ty, 0);
2455   } else {
2456     void *vptr = 0;
2457
2458     /* here we get the method pointer for callbacks */
2459     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2460     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2461     if (desc)
2462       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2463     if (!desc)
2464       return SWIG_ERROR;
2465     if (ty) {
2466       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2467       if (tc) {
2468         int newmemory = 0;
2469         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2470         assert(!newmemory); /* newmemory handling not yet implemented */
2471       } else {
2472         return SWIG_ERROR;
2473       }
2474     } else {
2475       *ptr = vptr;
2476     }
2477     return SWIG_OK;
2478   }
2479 }
2480
2481 /* Convert a packed value value */
2482
2483 SWIGRUNTIME int
2484 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2485   swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2486   if (!to) return SWIG_ERROR;
2487   if (ty) {
2488     if (to != ty) {
2489       /* check type cast? */
2490       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2491       if (!tc) return SWIG_ERROR;
2492     }
2493   }
2494   return SWIG_OK;
2495 }
2496
2497 /* -----------------------------------------------------------------------------
2498  * Create a new pointer object
2499  * ----------------------------------------------------------------------------- */
2500
2501 /*
2502   Create a new instance object, without calling __init__, and set the
2503   'this' attribute.
2504 */
2505
2506 SWIGRUNTIME PyObject*
2507 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2508 {
2509 #if (PY_VERSION_HEX >= 0x02020000)
2510   PyObject *inst = 0;
2511   PyObject *newraw = data->newraw;
2512   if (newraw) {
2513     inst = PyObject_Call(newraw, data->newargs, NULL);
2514     if (inst) {
2515 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2516       PyObject **dictptr = _PyObject_GetDictPtr(inst);
2517       if (dictptr != NULL) {
2518         PyObject *dict = *dictptr;
2519         if (dict == NULL) {
2520           dict = PyDict_New();
2521           *dictptr = dict;
2522           PyDict_SetItem(dict, SWIG_This(), swig_this);
2523         }
2524       }
2525 #else
2526       PyObject *key = SWIG_This();
2527       PyObject_SetAttr(inst, key, swig_this);
2528 #endif
2529     }
2530   } else {
2531 #if PY_VERSION_HEX >= 0x03000000
2532     inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2533     if (inst) {
2534       PyObject_SetAttr(inst, SWIG_This(), swig_this);
2535       Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2536     }
2537 #else
2538     PyObject *dict = PyDict_New();
2539     if (dict) {
2540       PyDict_SetItem(dict, SWIG_This(), swig_this);
2541       inst = PyInstance_NewRaw(data->newargs, dict);
2542       Py_DECREF(dict);
2543     }
2544 #endif
2545   }
2546   return inst;
2547 #else
2548 #if (PY_VERSION_HEX >= 0x02010000)
2549   PyObject *inst = 0;
2550   PyObject *dict = PyDict_New();
2551   if (dict) {
2552     PyDict_SetItem(dict, SWIG_This(), swig_this);
2553     inst = PyInstance_NewRaw(data->newargs, dict);
2554     Py_DECREF(dict);
2555   }
2556   return (PyObject *) inst;
2557 #else
2558   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2559   if (inst == NULL) {
2560     return NULL;
2561   }
2562   inst->in_class = (PyClassObject *)data->newargs;
2563   Py_INCREF(inst->in_class);
2564   inst->in_dict = PyDict_New();
2565   if (inst->in_dict == NULL) {
2566     Py_DECREF(inst);
2567     return NULL;
2568   }
2569 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2570   inst->in_weakreflist = NULL;
2571 #endif
2572 #ifdef Py_TPFLAGS_GC
2573   PyObject_GC_Init(inst);
2574 #endif
2575   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2576   return (PyObject *) inst;
2577 #endif
2578 #endif
2579 }
2580
2581 SWIGRUNTIME void
2582 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2583 {
2584  PyObject *dict;
2585 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2586  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2587  if (dictptr != NULL) {
2588    dict = *dictptr;
2589    if (dict == NULL) {
2590      dict = PyDict_New();
2591      *dictptr = dict;
2592    }
2593    PyDict_SetItem(dict, SWIG_This(), swig_this);
2594    return;
2595  }
2596 #endif
2597  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2598  PyDict_SetItem(dict, SWIG_This(), swig_this);
2599  Py_DECREF(dict);
2600 }
2601
2602
2603 SWIGINTERN PyObject *
2604 SWIG_Python_InitShadowInstance(PyObject *args) {
2605   PyObject *obj[2];
2606   if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2607     return NULL;
2608   } else {
2609     SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2610     if (sthis) {
2611       SwigPyObject_append((PyObject*) sthis, obj[1]);
2612     } else {
2613       SWIG_Python_SetSwigThis(obj[0], obj[1]);
2614     }
2615     return SWIG_Py_Void();
2616   }
2617 }
2618
2619 /* Create a new pointer object */
2620
2621 SWIGRUNTIME PyObject *
2622 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2623   SwigPyClientData *clientdata;
2624   PyObject * robj;
2625   int own;
2626
2627   if (!ptr)
2628     return SWIG_Py_Void();
2629
2630   clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2631   own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2632   if (clientdata && clientdata->pytype) {
2633     SwigPyObject *newobj;
2634     if (flags & SWIG_BUILTIN_TP_INIT) {
2635       newobj = (SwigPyObject*) self;
2636       if (newobj->ptr) {
2637         PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2638         while (newobj->next)
2639           newobj = (SwigPyObject *) newobj->next;
2640         newobj->next = next_self;
2641         newobj = (SwigPyObject *)next_self;
2642 #ifdef SWIGPYTHON_BUILTIN
2643         newobj->dict = 0;
2644 #endif
2645       }
2646     } else {
2647       newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2648 #ifdef SWIGPYTHON_BUILTIN
2649       newobj->dict = 0;
2650 #endif
2651     }
2652     if (newobj) {
2653       newobj->ptr = ptr;
2654       newobj->ty = type;
2655       newobj->own = own;
2656       newobj->next = 0;
2657       return (PyObject*) newobj;
2658     }
2659     return SWIG_Py_Void();
2660   }
2661
2662   assert(!(flags & SWIG_BUILTIN_TP_INIT));
2663
2664   robj = SwigPyObject_New(ptr, type, own);
2665   if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2666     PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2667     Py_DECREF(robj);
2668     robj = inst;
2669   }
2670   return robj;
2671 }
2672
2673 /* Create a new packed object */
2674
2675 SWIGRUNTIMEINLINE PyObject *
2676 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2677   return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2678 }
2679
2680 /* -----------------------------------------------------------------------------*
2681  *  Get type list
2682  * -----------------------------------------------------------------------------*/
2683
2684 #ifdef SWIG_LINK_RUNTIME
2685 void *SWIG_ReturnGlobalTypeList(void *);
2686 #endif
2687
2688 SWIGRUNTIME swig_module_info *
2689 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2690   static void *type_pointer = (void *)0;
2691   /* first check if module already created */
2692   if (!type_pointer) {
2693 #ifdef SWIG_LINK_RUNTIME
2694     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2695 #else
2696 # ifdef SWIGPY_USE_CAPSULE
2697     type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2698 # else
2699     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2700                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2701 # endif
2702     if (PyErr_Occurred()) {
2703       PyErr_Clear();
2704       type_pointer = (void *)0;
2705     }
2706 #endif
2707   }
2708   return (swig_module_info *) type_pointer;
2709 }
2710
2711 #if PY_MAJOR_VERSION < 2
2712 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
2713    is copied out of Python/modsupport.c in python version 2.3.4 */
2714 SWIGINTERN int
2715 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2716 {
2717   PyObject *dict;
2718   if (!PyModule_Check(m)) {
2719     PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2720     return SWIG_ERROR;
2721   }
2722   if (!o) {
2723     PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2724     return SWIG_ERROR;
2725   }
2726
2727   dict = PyModule_GetDict(m);
2728   if (dict == NULL) {
2729     /* Internal error -- modules must have a dict! */
2730     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2731                  PyModule_GetName(m));
2732     return SWIG_ERROR;
2733   }
2734   if (PyDict_SetItemString(dict, name, o))
2735     return SWIG_ERROR;
2736   Py_DECREF(o);
2737   return SWIG_OK;
2738 }
2739 #endif
2740
2741 SWIGRUNTIME void
2742 #ifdef SWIGPY_USE_CAPSULE
2743 SWIG_Python_DestroyModule(PyObject *obj)
2744 #else
2745 SWIG_Python_DestroyModule(void *vptr)
2746 #endif
2747 {
2748 #ifdef SWIGPY_USE_CAPSULE
2749   swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2750 #else
2751   swig_module_info *swig_module = (swig_module_info *) vptr;
2752 #endif
2753   swig_type_info **types = swig_module->types;
2754   size_t i;
2755   for (i =0; i < swig_module->size; ++i) {
2756     swig_type_info *ty = types[i];
2757     if (ty->owndata) {
2758       SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2759       if (data) SwigPyClientData_Del(data);
2760     }
2761   }
2762   Py_DECREF(SWIG_This());
2763   swig_this = NULL;
2764 }
2765
2766 SWIGRUNTIME void
2767 SWIG_Python_SetModule(swig_module_info *swig_module) {
2768 #if PY_VERSION_HEX >= 0x03000000
2769  /* Add a dummy module object into sys.modules */
2770   PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2771 #else
2772   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2773   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2774 #endif
2775 #ifdef SWIGPY_USE_CAPSULE
2776   PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2777   if (pointer && module) {
2778     PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2779   } else {
2780     Py_XDECREF(pointer);
2781   }
2782 #else
2783   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2784   if (pointer && module) {
2785     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2786   } else {
2787     Py_XDECREF(pointer);
2788   }
2789 #endif
2790 }
2791
2792 /* The python cached type query */
2793 SWIGRUNTIME PyObject *
2794 SWIG_Python_TypeCache(void) {
2795   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2796   return cache;
2797 }
2798
2799 SWIGRUNTIME swig_type_info *
2800 SWIG_Python_TypeQuery(const char *type)
2801 {
2802   PyObject *cache = SWIG_Python_TypeCache();
2803   PyObject *key = SWIG_Python_str_FromChar(type);
2804   PyObject *obj = PyDict_GetItem(cache, key);
2805   swig_type_info *descriptor;
2806   if (obj) {
2807 #ifdef SWIGPY_USE_CAPSULE
2808     descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2809 #else
2810     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2811 #endif
2812   } else {
2813     swig_module_info *swig_module = SWIG_GetModule(0);
2814     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2815     if (descriptor) {
2816 #ifdef SWIGPY_USE_CAPSULE
2817       obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2818 #else
2819       obj = PyCObject_FromVoidPtr(descriptor, NULL);
2820 #endif
2821       PyDict_SetItem(cache, key, obj);
2822       Py_DECREF(obj);
2823     }
2824   }
2825   Py_DECREF(key);
2826   return descriptor;
2827 }
2828
2829 /*
2830    For backward compatibility only
2831 */
2832 #define SWIG_POINTER_EXCEPTION  0
2833 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2834 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2835
2836 SWIGRUNTIME int
2837 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2838 {
2839   if (PyErr_Occurred()) {
2840     PyObject *type = 0;
2841     PyObject *value = 0;
2842     PyObject *traceback = 0;
2843     PyErr_Fetch(&type, &value, &traceback);
2844     if (value) {
2845       char *tmp;
2846       PyObject *old_str = PyObject_Str(value);
2847       Py_XINCREF(type);
2848       PyErr_Clear();
2849       if (infront) {
2850         PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2851       } else {
2852         PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2853       }
2854       SWIG_Python_str_DelForPy3(tmp);
2855       Py_DECREF(old_str);
2856     }
2857     return 1;
2858   } else {
2859     return 0;
2860   }
2861 }
2862
2863 SWIGRUNTIME int
2864 SWIG_Python_ArgFail(int argnum)
2865 {
2866   if (PyErr_Occurred()) {
2867     /* add information about failing argument */
2868     char mesg[256];
2869     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2870     return SWIG_Python_AddErrMesg(mesg, 1);
2871   } else {
2872     return 0;
2873   }
2874 }
2875
2876 SWIGRUNTIMEINLINE const char *
2877 SwigPyObject_GetDesc(PyObject *self)
2878 {
2879   SwigPyObject *v = (SwigPyObject *)self;
2880   swig_type_info *ty = v ? v->ty : 0;
2881   return ty ? ty->str : "";
2882 }
2883
2884 SWIGRUNTIME void
2885 SWIG_Python_TypeError(const char *type, PyObject *obj)
2886 {
2887   if (type) {
2888 #if defined(SWIG_COBJECT_TYPES)
2889     if (obj && SwigPyObject_Check(obj)) {
2890       const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2891       if (otype) {
2892         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2893                      type, otype);
2894         return;
2895       }
2896     } else
2897 #endif
2898     {
2899       const char *otype = (obj ? obj->ob_type->tp_name : 0);
2900       if (otype) {
2901         PyObject *str = PyObject_Str(obj);
2902         const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2903         if (cstr) {
2904           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2905                        type, otype, cstr);
2906           SWIG_Python_str_DelForPy3(cstr);
2907         } else {
2908           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2909                        type, otype);
2910         }
2911         Py_XDECREF(str);
2912         return;
2913       }
2914     }
2915     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2916   } else {
2917     PyErr_Format(PyExc_TypeError, "unexpected type is received");
2918   }
2919 }
2920
2921
2922 /* Convert a pointer value, signal an exception on a type mismatch */
2923 SWIGRUNTIME void *
2924 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2925   void *result;
2926   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2927     PyErr_Clear();
2928 #if SWIG_POINTER_EXCEPTION
2929     if (flags) {
2930       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2931       SWIG_Python_ArgFail(argnum);
2932     }
2933 #endif
2934   }
2935   return result;
2936 }
2937
2938 #ifdef SWIGPYTHON_BUILTIN
2939 SWIGRUNTIME int
2940 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2941   PyTypeObject *tp = obj->ob_type;
2942   PyObject *descr;
2943   PyObject *encoded_name;
2944   descrsetfunc f;
2945   int res = -1;
2946
2947 # ifdef Py_USING_UNICODE
2948   if (PyString_Check(name)) {
2949     name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2950     if (!name)
2951       return -1;
2952   } else if (!PyUnicode_Check(name))
2953 # else
2954   if (!PyString_Check(name))
2955 # endif
2956   {
2957     PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2958     return -1;
2959   } else {
2960     Py_INCREF(name);
2961   }
2962
2963   if (!tp->tp_dict) {
2964     if (PyType_Ready(tp) < 0)
2965       goto done;
2966   }
2967
2968   descr = _PyType_Lookup(tp, name);
2969   f = NULL;
2970   if (descr != NULL)
2971     f = descr->ob_type->tp_descr_set;
2972   if (!f) {
2973     if (PyString_Check(name)) {
2974       encoded_name = name;
2975       Py_INCREF(name);
2976     } else {
2977       encoded_name = PyUnicode_AsUTF8String(name);
2978     }
2979     PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2980     Py_DECREF(encoded_name);
2981   } else {
2982     res = f(descr, obj, value);
2983   }
2984
2985   done:
2986   Py_DECREF(name);
2987   return res;
2988 }
2989 #endif
2990
2991
2992 #ifdef __cplusplus
2993 }
2994 #endif
2995
2996
2997
2998 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2999
3000 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
3001
3002
3003
3004   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
3005
3006
3007 /* -------- TYPES TABLE (BEGIN) -------- */
3008
3009 #define SWIGTYPE_p_FILE swig_types[0]
3010 #define SWIGTYPE_p_Hex__BiCylinder swig_types[1]
3011 #define SWIGTYPE_p_Hex__Document swig_types[2]
3012 #define SWIGTYPE_p_Hex__Edge swig_types[3]
3013 #define SWIGTYPE_p_Hex__Elements swig_types[4]
3014 #define SWIGTYPE_p_Hex__EltBase swig_types[5]
3015 #define SWIGTYPE_p_Hex__Group swig_types[6]
3016 #define SWIGTYPE_p_Hex__Hex swig_types[7]
3017 #define SWIGTYPE_p_Hex__Hex__Elements swig_types[8]
3018 #define SWIGTYPE_p_Hex__Hex__EltBase swig_types[9]
3019 #define SWIGTYPE_p_Hex__Hexa swig_types[10]
3020 #define SWIGTYPE_p_Hex__Law swig_types[11]
3021 #define SWIGTYPE_p_Hex__NewShape swig_types[12]
3022 #define SWIGTYPE_p_Hex__Propagation swig_types[13]
3023 #define SWIGTYPE_p_Hex__Quad swig_types[14]
3024 #define SWIGTYPE_p_Hex__Shape swig_types[15]
3025 #define SWIGTYPE_p_Hex__Vector swig_types[16]
3026 #define SWIGTYPE_p_Hex__Vertex swig_types[17]
3027 #define SWIGTYPE_p_Hex__XmlWriter swig_types[18]
3028 #define SWIGTYPE_p_a_Hex__DIM3__double swig_types[19]
3029 #define SWIGTYPE_p_allocator_type swig_types[20]
3030 #define SWIGTYPE_p_char swig_types[21]
3031 #define SWIGTYPE_p_const_reference swig_types[22]
3032 #define SWIGTYPE_p_difference_type swig_types[23]
3033 #define SWIGTYPE_p_double swig_types[24]
3034 #define SWIGTYPE_p_int swig_types[25]
3035 #define SWIGTYPE_p_p_PyObject swig_types[26]
3036 #define SWIGTYPE_p_reference swig_types[27]
3037 #define SWIGTYPE_p_size_type swig_types[28]
3038 #define SWIGTYPE_p_std__allocatorT_Hex__Edge_p_t swig_types[29]
3039 #define SWIGTYPE_p_std__allocatorT_Hex__Hexa_p_t swig_types[30]
3040 #define SWIGTYPE_p_std__allocatorT_Hex__NewShape_p_t swig_types[31]
3041 #define SWIGTYPE_p_std__allocatorT_Hex__Quad_p_t swig_types[32]
3042 #define SWIGTYPE_p_std__allocatorT_Hex__Vertex_p_t swig_types[33]
3043 #define SWIGTYPE_p_std__allocatorT_double_t swig_types[34]
3044 #define SWIGTYPE_p_std__allocatorT_int_t swig_types[35]
3045 #define SWIGTYPE_p_std__invalid_argument swig_types[36]
3046 #define SWIGTYPE_p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t swig_types[37]
3047 #define SWIGTYPE_p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t swig_types[38]
3048 #define SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t swig_types[39]
3049 #define SWIGTYPE_p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t swig_types[40]
3050 #define SWIGTYPE_p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t swig_types[41]
3051 #define SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t swig_types[42]
3052 #define SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t swig_types[43]
3053 #define SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t swig_types[44]
3054 #define SWIGTYPE_p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t swig_types[45]
3055 #define SWIGTYPE_p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t swig_types[46]
3056 #define SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t swig_types[47]
3057 #define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[48]
3058 #define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[49]
3059 #define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[50]
3060 #define SWIGTYPE_p_string swig_types[51]
3061 #define SWIGTYPE_p_swig__SwigPyIterator swig_types[52]
3062 #define SWIGTYPE_p_value_type swig_types[53]
3063 static swig_type_info *swig_types[55];
3064 static swig_module_info swig_module = {swig_types, 54, 0, 0, 0, 0};
3065 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3066 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3067
3068 /* -------- TYPES TABLE (END) -------- */
3069
3070 #if (PY_VERSION_HEX <= 0x02000000)
3071 # if !defined(SWIG_PYTHON_CLASSIC)
3072 #  error "This python version requires swig to be run with the '-classic' option"
3073 # endif
3074 #endif
3075
3076 /*-----------------------------------------------
3077               @(target):= _hexablock_swig.so
3078   ------------------------------------------------*/
3079 #if PY_VERSION_HEX >= 0x03000000
3080 #  define SWIG_init    PyInit__hexablock_swig
3081
3082 #else
3083 #  define SWIG_init    init_hexablock_swig
3084
3085 #endif
3086 #define SWIG_name    "_hexablock_swig"
3087
3088 #define SWIGVERSION 0x030012
3089 #define SWIG_VERSION SWIGVERSION
3090
3091
3092 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
3093 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
3094
3095
3096 #include <stdexcept>
3097
3098
3099 namespace swig {
3100   class SwigPtr_PyObject {
3101   protected:
3102     PyObject *_obj;
3103
3104   public:
3105     SwigPtr_PyObject() :_obj(0)
3106     {
3107     }
3108
3109     SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
3110     {
3111       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3112       Py_XINCREF(_obj);
3113       SWIG_PYTHON_THREAD_END_BLOCK;
3114     }
3115
3116     SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
3117     {
3118       if (initial_ref) {
3119         SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3120         Py_XINCREF(_obj);
3121         SWIG_PYTHON_THREAD_END_BLOCK;
3122       }
3123     }
3124
3125     SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
3126     {
3127       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3128       Py_XINCREF(item._obj);
3129       Py_XDECREF(_obj);
3130       _obj = item._obj;
3131       SWIG_PYTHON_THREAD_END_BLOCK;
3132       return *this;
3133     }
3134
3135     ~SwigPtr_PyObject()
3136     {
3137       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3138       Py_XDECREF(_obj);
3139       SWIG_PYTHON_THREAD_END_BLOCK;
3140     }
3141
3142     operator PyObject *() const
3143     {
3144       return _obj;
3145     }
3146
3147     PyObject *operator->() const
3148     {
3149       return _obj;
3150     }
3151   };
3152 }
3153
3154
3155 namespace swig {
3156   struct SwigVar_PyObject : SwigPtr_PyObject {
3157     SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
3158
3159     SwigVar_PyObject & operator = (PyObject* obj)
3160     {
3161       Py_XDECREF(_obj);
3162       _obj = obj;
3163       return *this;
3164     }
3165   };
3166 }
3167
3168
3169 #include "Hex.hxx"
3170 #include "HexDocument.hxx"
3171 #include "HexPropagation.hxx"
3172 #include "HexElements.hxx"
3173 #include "HexQuad.hxx"
3174 #include "HexVertex.hxx"
3175 #include "HexHexa.hxx"
3176 #include "HexEdge.hxx"
3177 #include "HexVector.hxx"
3178 #include "HexBiCylinder.hxx"
3179 #include "HexNewShape.hxx"
3180 #include "HexGroup.hxx"
3181
3182
3183 #include <iostream>
3184
3185 #if PY_VERSION_HEX >= 0x03020000
3186 # define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
3187 #else
3188 # define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
3189 #endif
3190
3191
3192 #include <typeinfo>
3193 #include <stdexcept>
3194
3195
3196 #if defined(__GNUC__)
3197 #  if __GNUC__ == 2 && __GNUC_MINOR <= 96
3198 #     define SWIG_STD_NOMODERN_STL
3199 #  endif
3200 #endif
3201
3202
3203 #include <string>
3204
3205
3206 #include <stddef.h>
3207
3208
3209 namespace swig {
3210   struct stop_iteration {
3211   };
3212
3213   struct SwigPyIterator {
3214   private:
3215     SwigPtr_PyObject _seq;
3216
3217   protected:
3218     SwigPyIterator(PyObject *seq) : _seq(seq)
3219     {
3220     }
3221
3222   public:
3223     virtual ~SwigPyIterator() {}
3224
3225     // Access iterator method, required by Python
3226     virtual PyObject *value() const = 0;
3227
3228     // Forward iterator method, required by Python
3229     virtual SwigPyIterator *incr(size_t n = 1) = 0;
3230
3231     // Backward iterator method, very common in C++, but not required in Python
3232     virtual SwigPyIterator *decr(size_t /*n*/ = 1)
3233     {
3234       throw stop_iteration();
3235     }
3236
3237     // Random access iterator methods, but not required in Python
3238     virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
3239     {
3240       throw std::invalid_argument("operation not supported");
3241     }
3242
3243     virtual bool equal (const SwigPyIterator &/*x*/) const
3244     {
3245       throw std::invalid_argument("operation not supported");
3246     }
3247
3248     // C++ common/needed methods
3249     virtual SwigPyIterator *copy() const = 0;
3250
3251     PyObject *next()
3252     {
3253       SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3254       PyObject *obj = value();
3255       incr();
3256       SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3257       return obj;
3258     }
3259
3260     /* Make an alias for Python 3.x */
3261     PyObject *__next__()
3262     {
3263       return next();
3264     }
3265
3266     PyObject *previous()
3267     {
3268       SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3269       decr();
3270       PyObject *obj = value();
3271       SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3272       return obj;
3273     }
3274
3275     SwigPyIterator *advance(ptrdiff_t n)
3276     {
3277       return  (n > 0) ?  incr(n) : decr(-n);
3278     }
3279
3280     bool operator == (const SwigPyIterator& x)  const
3281     {
3282       return equal(x);
3283     }
3284
3285     bool operator != (const SwigPyIterator& x) const
3286     {
3287       return ! operator==(x);
3288     }
3289
3290     SwigPyIterator& operator += (ptrdiff_t n)
3291     {
3292       return *advance(n);
3293     }
3294
3295     SwigPyIterator& operator -= (ptrdiff_t n)
3296     {
3297       return *advance(-n);
3298     }
3299
3300     SwigPyIterator* operator + (ptrdiff_t n) const
3301     {
3302       return copy()->advance(n);
3303     }
3304
3305     SwigPyIterator* operator - (ptrdiff_t n) const
3306     {
3307       return copy()->advance(-n);
3308     }
3309
3310     ptrdiff_t operator - (const SwigPyIterator& x) const
3311     {
3312       return x.distance(*this);
3313     }
3314
3315     static swig_type_info* descriptor() {
3316       static int init = 0;
3317       static swig_type_info* desc = 0;
3318       if (!init) {
3319         desc = SWIG_TypeQuery("swig::SwigPyIterator *");
3320         init = 1;
3321       }
3322       return desc;
3323     }
3324   };
3325
3326 #if defined(SWIGPYTHON_BUILTIN)
3327   inline PyObject* make_output_iterator_builtin (PyObject *pyself)
3328   {
3329     Py_INCREF(pyself);
3330     return pyself;
3331   }
3332 #endif
3333 }
3334
3335
3336 SWIGINTERN int
3337 SWIG_AsVal_double (PyObject *obj, double *val)
3338 {
3339   int res = SWIG_TypeError;
3340   if (PyFloat_Check(obj)) {
3341     if (val) *val = PyFloat_AsDouble(obj);
3342     return SWIG_OK;
3343 #if PY_VERSION_HEX < 0x03000000
3344   } else if (PyInt_Check(obj)) {
3345     if (val) *val = (double) PyInt_AsLong(obj);
3346     return SWIG_OK;
3347 #endif
3348   } else if (PyLong_Check(obj)) {
3349     double v = PyLong_AsDouble(obj);
3350     if (!PyErr_Occurred()) {
3351       if (val) *val = v;
3352       return SWIG_OK;
3353     } else {
3354       PyErr_Clear();
3355     }
3356   }
3357 #ifdef SWIG_PYTHON_CAST_MODE
3358   {
3359     int dispatch = 0;
3360     double d = PyFloat_AsDouble(obj);
3361     if (!PyErr_Occurred()) {
3362       if (val) *val = d;
3363       return SWIG_AddCast(SWIG_OK);
3364     } else {
3365       PyErr_Clear();
3366     }
3367     if (!dispatch) {
3368       long v = PyLong_AsLong(obj);
3369       if (!PyErr_Occurred()) {
3370         if (val) *val = v;
3371         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3372       } else {
3373         PyErr_Clear();
3374       }
3375     }
3376   }
3377 #endif
3378   return res;
3379 }
3380
3381
3382 #include <float.h>
3383
3384
3385 #include <math.h>
3386
3387
3388 SWIGINTERNINLINE int
3389 SWIG_CanCastAsInteger(double *d, double min, double max) {
3390   double x = *d;
3391   if ((min <= x && x <= max)) {
3392    double fx = floor(x);
3393    double cx = ceil(x);
3394    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3395    if ((errno == EDOM) || (errno == ERANGE)) {
3396      errno = 0;
3397    } else {
3398      double summ, reps, diff;
3399      if (rd < x) {
3400        diff = x - rd;
3401      } else if (rd > x) {
3402        diff = rd - x;
3403      } else {
3404        return 1;
3405      }
3406      summ = rd + x;
3407      reps = diff/summ;
3408      if (reps < 8*DBL_EPSILON) {
3409        *d = rd;
3410        return 1;
3411      }
3412    }
3413   }
3414   return 0;
3415 }
3416
3417
3418 SWIGINTERN int
3419 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3420 {
3421 #if PY_VERSION_HEX < 0x03000000
3422   if (PyInt_Check(obj)) {
3423     long v = PyInt_AsLong(obj);
3424     if (v >= 0) {
3425       if (val) *val = v;
3426       return SWIG_OK;
3427     } else {
3428       return SWIG_OverflowError;
3429     }
3430   } else
3431 #endif
3432   if (PyLong_Check(obj)) {
3433     unsigned long v = PyLong_AsUnsignedLong(obj);
3434     if (!PyErr_Occurred()) {
3435       if (val) *val = v;
3436       return SWIG_OK;
3437     } else {
3438       PyErr_Clear();
3439       return SWIG_OverflowError;
3440     }
3441   }
3442 #ifdef SWIG_PYTHON_CAST_MODE
3443   {
3444     int dispatch = 0;
3445     unsigned long v = PyLong_AsUnsignedLong(obj);
3446     if (!PyErr_Occurred()) {
3447       if (val) *val = v;
3448       return SWIG_AddCast(SWIG_OK);
3449     } else {
3450       PyErr_Clear();
3451     }
3452     if (!dispatch) {
3453       double d;
3454       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3455       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3456         if (val) *val = (unsigned long)(d);
3457         return res;
3458       }
3459     }
3460   }
3461 #endif
3462   return SWIG_TypeError;
3463 }
3464
3465
3466 #include <limits.h>
3467 #if !defined(SWIG_NO_LLONG_MAX)
3468 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3469 #   define LLONG_MAX __LONG_LONG_MAX__
3470 #   define LLONG_MIN (-LLONG_MAX - 1LL)
3471 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3472 # endif
3473 #endif
3474
3475
3476 #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
3477 #  define SWIG_LONG_LONG_AVAILABLE
3478 #endif
3479
3480
3481 #ifdef SWIG_LONG_LONG_AVAILABLE
3482 SWIGINTERN int
3483 SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
3484 {
3485   int res = SWIG_TypeError;
3486   if (PyLong_Check(obj)) {
3487     unsigned long long v = PyLong_AsUnsignedLongLong(obj);
3488     if (!PyErr_Occurred()) {
3489       if (val) *val = v;
3490       return SWIG_OK;
3491     } else {
3492       PyErr_Clear();
3493       res = SWIG_OverflowError;
3494     }
3495   } else {
3496     unsigned long v;
3497     res = SWIG_AsVal_unsigned_SS_long (obj,&v);
3498     if (SWIG_IsOK(res)) {
3499       if (val) *val = v;
3500       return res;
3501     }
3502   }
3503 #ifdef SWIG_PYTHON_CAST_MODE
3504   {
3505     const double mant_max = 1LL << DBL_MANT_DIG;
3506     double d;
3507     res = SWIG_AsVal_double (obj,&d);
3508     if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
3509       return SWIG_OverflowError;
3510     if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
3511       if (val) *val = (unsigned long long)(d);
3512       return SWIG_AddCast(res);
3513     }
3514     res = SWIG_TypeError;
3515   }
3516 #endif
3517   return res;
3518 }
3519 #endif
3520
3521
3522 SWIGINTERNINLINE int
3523 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3524 {
3525   int res = SWIG_TypeError;
3526 #ifdef SWIG_LONG_LONG_AVAILABLE
3527   if (sizeof(size_t) <= sizeof(unsigned long)) {
3528 #endif
3529     unsigned long v;
3530     res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3531     if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3532 #ifdef SWIG_LONG_LONG_AVAILABLE
3533   } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
3534     unsigned long long v;
3535     res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
3536     if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3537   }
3538 #endif
3539   return res;
3540 }
3541
3542
3543   #define SWIG_From_long   PyInt_FromLong
3544
3545
3546 #ifdef SWIG_LONG_LONG_AVAILABLE
3547 SWIGINTERNINLINE PyObject*
3548 SWIG_From_long_SS_long  (long long value)
3549 {
3550   return ((value < LONG_MIN) || (value > LONG_MAX)) ?
3551     PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
3552 }
3553 #endif
3554
3555
3556 SWIGINTERNINLINE PyObject *
3557 SWIG_From_ptrdiff_t  (ptrdiff_t value)
3558 {
3559 #ifdef SWIG_LONG_LONG_AVAILABLE
3560   if (sizeof(ptrdiff_t) <= sizeof(long)) {
3561 #endif
3562     return SWIG_From_long  (static_cast< long >(value));
3563 #ifdef SWIG_LONG_LONG_AVAILABLE
3564   } else {
3565     /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
3566     return SWIG_From_long_SS_long  (static_cast< long long >(value));
3567   }
3568 #endif
3569 }
3570
3571
3572 SWIGINTERNINLINE PyObject*
3573   SWIG_From_bool  (bool value)
3574 {
3575   return PyBool_FromLong(value ? 1 : 0);
3576 }
3577
3578
3579 SWIGINTERN int
3580 SWIG_AsVal_long (PyObject *obj, long* val)
3581 {
3582 #if PY_VERSION_HEX < 0x03000000
3583   if (PyInt_Check(obj)) {
3584     if (val) *val = PyInt_AsLong(obj);
3585     return SWIG_OK;
3586   } else
3587 #endif
3588   if (PyLong_Check(obj)) {
3589     long v = PyLong_AsLong(obj);
3590     if (!PyErr_Occurred()) {
3591       if (val) *val = v;
3592       return SWIG_OK;
3593     } else {
3594       PyErr_Clear();
3595       return SWIG_OverflowError;
3596     }
3597   }
3598 #ifdef SWIG_PYTHON_CAST_MODE
3599   {
3600     int dispatch = 0;
3601     long v = PyInt_AsLong(obj);
3602     if (!PyErr_Occurred()) {
3603       if (val) *val = v;
3604       return SWIG_AddCast(SWIG_OK);
3605     } else {
3606       PyErr_Clear();
3607     }
3608     if (!dispatch) {
3609       double d;
3610       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3611       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3612         if (val) *val = (long)(d);
3613         return res;
3614       }
3615     }
3616   }
3617 #endif
3618   return SWIG_TypeError;
3619 }
3620
3621
3622 #ifdef SWIG_LONG_LONG_AVAILABLE
3623 SWIGINTERN int
3624 SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
3625 {
3626   int res = SWIG_TypeError;
3627   if (PyLong_Check(obj)) {
3628     long long v = PyLong_AsLongLong(obj);
3629     if (!PyErr_Occurred()) {
3630       if (val) *val = v;
3631       return SWIG_OK;
3632     } else {
3633       PyErr_Clear();
3634       res = SWIG_OverflowError;
3635     }
3636   } else {
3637     long v;
3638     res = SWIG_AsVal_long (obj,&v);
3639     if (SWIG_IsOK(res)) {
3640       if (val) *val = v;
3641       return res;
3642     }
3643   }
3644 #ifdef SWIG_PYTHON_CAST_MODE
3645   {
3646     const double mant_max = 1LL << DBL_MANT_DIG;
3647     const double mant_min = -mant_max;
3648     double d;
3649     res = SWIG_AsVal_double (obj,&d);
3650     if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
3651       return SWIG_OverflowError;
3652     if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
3653       if (val) *val = (long long)(d);
3654       return SWIG_AddCast(res);
3655     }
3656     res = SWIG_TypeError;
3657   }
3658 #endif
3659   return res;
3660 }
3661 #endif
3662
3663
3664 SWIGINTERNINLINE int
3665 SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
3666 {
3667   int res = SWIG_TypeError;
3668 #ifdef SWIG_LONG_LONG_AVAILABLE
3669   if (sizeof(ptrdiff_t) <= sizeof(long)) {
3670 #endif
3671     long v;
3672     res = SWIG_AsVal_long (obj, val ? &v : 0);
3673     if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
3674 #ifdef SWIG_LONG_LONG_AVAILABLE
3675   } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
3676     long long v;
3677     res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
3678     if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
3679   }
3680 #endif
3681   return res;
3682 }
3683
3684
3685 #include <algorithm>
3686
3687
3688 #include <vector>
3689
3690
3691 namespace swig {
3692   template <class Type>
3693   struct noconst_traits {
3694     typedef Type noconst_type;
3695   };
3696
3697   template <class Type>
3698   struct noconst_traits<const Type> {
3699     typedef Type noconst_type;
3700   };
3701
3702   /*
3703     type categories
3704   */
3705   struct pointer_category { };
3706   struct value_category { };
3707
3708   /*
3709     General traits that provides type_name and type_info
3710   */
3711   template <class Type> struct traits { };
3712
3713   template <class Type>
3714   inline const char* type_name() {
3715     return traits<typename noconst_traits<Type >::noconst_type >::type_name();
3716   }
3717
3718   template <class Type> struct traits_info {
3719     static swig_type_info *type_query(std::string name) {
3720       name += " *";
3721       return SWIG_TypeQuery(name.c_str());
3722     }
3723     static swig_type_info *type_info() {
3724       static swig_type_info *info = type_query(type_name<Type>());
3725       return info;
3726     }
3727   };
3728
3729   /*
3730     Partial specialization for pointers (traits_info)
3731   */
3732   template <class Type> struct traits_info<Type *> {
3733     static swig_type_info *type_query(std::string name) {
3734       name += " *";
3735       return SWIG_TypeQuery(name.c_str());
3736     }
3737     static swig_type_info *type_info() {
3738       static swig_type_info *info = type_query(type_name<Type>());
3739       return info;
3740     }
3741   };
3742
3743   template <class Type>
3744   inline swig_type_info *type_info() {
3745     return traits_info<Type>::type_info();
3746   }
3747
3748   /*
3749     Partial specialization for pointers (traits)
3750   */
3751   template <class Type> struct traits <Type *> {
3752     typedef pointer_category category;
3753     static std::string make_ptr_name(const char* name) {
3754       std::string ptrname = name;
3755       ptrname += " *";
3756       return ptrname;
3757     }
3758     static const char* type_name() {
3759       static std::string name = make_ptr_name(swig::type_name<Type>());
3760       return name.c_str();
3761     }
3762   };
3763
3764   template <class Type, class Category>
3765   struct traits_as { };
3766
3767   template <class Type, class Category>
3768   struct traits_check { };
3769
3770 }
3771
3772
3773 namespace swig {
3774   /*
3775     Traits that provides the from method
3776   */
3777   template <class Type> struct traits_from_ptr {
3778     static PyObject *from(Type *val, int owner = 0) {
3779       return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
3780     }
3781   };
3782
3783   template <class Type> struct traits_from {
3784     static PyObject *from(const Type& val) {
3785       return traits_from_ptr<Type>::from(new Type(val), 1);
3786     }
3787   };
3788
3789   template <class Type> struct traits_from<Type *> {
3790     static PyObject *from(Type* val) {
3791       return traits_from_ptr<Type>::from(val, 0);
3792     }
3793   };
3794
3795   template <class Type> struct traits_from<const Type *> {
3796     static PyObject *from(const Type* val) {
3797       return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
3798     }
3799   };
3800
3801
3802   template <class Type>
3803   inline PyObject *from(const Type& val) {
3804     return traits_from<Type>::from(val);
3805   }
3806
3807   template <class Type>
3808   inline PyObject *from_ptr(Type* val, int owner) {
3809     return traits_from_ptr<Type>::from(val, owner);
3810   }
3811
3812   /*
3813     Traits that provides the asval/as/check method
3814   */
3815   template <class Type>
3816   struct traits_asptr {
3817     static int asptr(PyObject *obj, Type **val) {
3818       Type *p;
3819       swig_type_info *descriptor = type_info<Type>();
3820       int res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
3821       if (SWIG_IsOK(res)) {
3822         if (val) *val = p;
3823       }
3824       return res;
3825     }
3826   };
3827
3828   template <class Type>
3829   inline int asptr(PyObject *obj, Type **vptr) {
3830     return traits_asptr<Type>::asptr(obj, vptr);
3831   }
3832
3833   template <class Type>
3834   struct traits_asval {
3835     static int asval(PyObject *obj, Type *val) {
3836       if (val) {
3837         Type *p = 0;
3838         int res = traits_asptr<Type>::asptr(obj, &p);
3839         if (!SWIG_IsOK(res)) return res;
3840         if (p) {
3841           typedef typename noconst_traits<Type>::noconst_type noconst_type;
3842           *(const_cast<noconst_type*>(val)) = *p;
3843           if (SWIG_IsNewObj(res)){
3844             delete p;
3845             res = SWIG_DelNewMask(res);
3846           }
3847           return res;
3848         } else {
3849           return SWIG_ERROR;
3850         }
3851       } else {
3852         return traits_asptr<Type>::asptr(obj, (Type **)(0));
3853       }
3854     }
3855   };
3856
3857   template <class Type> struct traits_asval<Type*> {
3858     static int asval(PyObject *obj, Type **val) {
3859       if (val) {
3860         typedef typename noconst_traits<Type>::noconst_type noconst_type;
3861         noconst_type *p = 0;
3862         int res = traits_asptr<noconst_type>::asptr(obj,  &p);
3863         if (SWIG_IsOK(res)) {
3864           *(const_cast<noconst_type**>(val)) = p;
3865         }
3866         return res;
3867       } else {
3868         return traits_asptr<Type>::asptr(obj, (Type **)(0));
3869       }
3870     }
3871   };
3872
3873   template <class Type>
3874   inline int asval(PyObject *obj, Type *val) {
3875     return traits_asval<Type>::asval(obj, val);
3876   }
3877
3878   template <class Type>
3879   struct traits_as<Type, value_category> {
3880     static Type as(PyObject *obj, bool throw_error) {
3881       Type v;
3882       int res = asval(obj, &v);
3883       if (!obj || !SWIG_IsOK(res)) {
3884         if (!PyErr_Occurred()) {
3885           ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3886         }
3887         if (throw_error) throw std::invalid_argument("bad type");
3888       }
3889       return v;
3890     }
3891   };
3892
3893   template <class Type>
3894   struct traits_as<Type, pointer_category> {
3895     static Type as(PyObject *obj, bool throw_error) {
3896       Type *v = 0;
3897       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3898       if (SWIG_IsOK(res) && v) {
3899         if (SWIG_IsNewObj(res)) {
3900           Type r(*v);
3901           delete v;
3902           return r;
3903         } else {
3904           return *v;
3905         }
3906       } else {
3907         // Uninitialized return value, no Type() constructor required.
3908         static Type *v_def = (Type*) malloc(sizeof(Type));
3909         if (!PyErr_Occurred()) {
3910           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3911         }
3912         if (throw_error) throw std::invalid_argument("bad type");
3913         memset(v_def,0,sizeof(Type));
3914         return *v_def;
3915       }
3916     }
3917   };
3918
3919   template <class Type>
3920   struct traits_as<Type*, pointer_category> {
3921     static Type* as(PyObject *obj, bool throw_error) {
3922       Type *v = 0;
3923       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3924       if (SWIG_IsOK(res)) {
3925         return v;
3926       } else {
3927         if (!PyErr_Occurred()) {
3928           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3929         }
3930         if (throw_error) throw std::invalid_argument("bad type");
3931         return 0;
3932       }
3933     }
3934   };
3935
3936   template <class Type>
3937   inline Type as(PyObject *obj, bool te = false) {
3938     return traits_as<Type, typename traits<Type>::category>::as(obj, te);
3939   }
3940
3941   template <class Type>
3942   struct traits_check<Type, value_category> {
3943     static bool check(PyObject *obj) {
3944       int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
3945       return SWIG_IsOK(res) ? true : false;
3946     }
3947   };
3948
3949   template <class Type>
3950   struct traits_check<Type, pointer_category> {
3951     static bool check(PyObject *obj) {
3952       int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
3953       return SWIG_IsOK(res) ? true : false;
3954     }
3955   };
3956
3957   template <class Type>
3958   inline bool check(PyObject *obj) {
3959     return traits_check<Type, typename traits<Type>::category>::check(obj);
3960   }
3961 }
3962
3963
3964 #include <functional>
3965
3966 namespace std {
3967   template <>
3968   struct less <PyObject *>
3969   {
3970     bool
3971     operator()(PyObject * v, PyObject *w) const
3972     {
3973       bool res;
3974       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3975       res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
3976       /* This may fall into a case of inconsistent
3977                eg. ObjA > ObjX > ObjB
3978                but ObjA < ObjB
3979       */
3980       if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
3981       {
3982         /* Objects can't be compared, this mostly occurred in Python 3.0 */
3983         /* Compare their ptr directly for a workaround */
3984         res = (v < w);
3985         PyErr_Clear();
3986       }
3987       SWIG_PYTHON_THREAD_END_BLOCK;
3988       return res;
3989     }
3990   };
3991
3992   template <>
3993   struct less <swig::SwigPtr_PyObject>
3994   {
3995     bool
3996     operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
3997     {
3998       return std::less<PyObject *>()(v, w);
3999     }
4000   };
4001
4002   template <>
4003   struct less <swig::SwigVar_PyObject>
4004   {
4005     bool
4006     operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
4007     {
4008       return std::less<PyObject *>()(v, w);
4009     }
4010   };
4011
4012 }
4013
4014 namespace swig {
4015   template <> struct traits<PyObject *> {
4016     typedef value_category category;
4017     static const char* type_name() { return "PyObject *"; }
4018   };
4019
4020   template <>  struct traits_asval<PyObject * > {
4021     typedef PyObject * value_type;
4022     static int asval(PyObject *obj, value_type *val) {
4023       if (val) *val = obj;
4024       return SWIG_OK;
4025     }
4026   };
4027
4028   template <>
4029   struct traits_check<PyObject *, value_category> {
4030     static bool check(PyObject *) {
4031       return true;
4032     }
4033   };
4034
4035   template <>  struct traits_from<PyObject *> {
4036     typedef PyObject * value_type;
4037     static PyObject *from(const value_type& val) {
4038       Py_XINCREF(val);
4039       return val;
4040     }
4041   };
4042
4043 }
4044
4045 namespace swig {
4046   template <class Difference>
4047   inline size_t
4048   check_index(Difference i, size_t size, bool insert = false) {
4049     if ( i < 0 ) {
4050       if ((size_t) (-i) <= size)
4051         return (size_t) (i + size);
4052     } else if ( (size_t) i < size ) {
4053       return (size_t) i;
4054     } else if (insert && ((size_t) i == size)) {
4055       return size;
4056     }
4057     throw std::out_of_range("index out of range");
4058   }
4059
4060   template <class Difference>
4061   void
4062   slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
4063     if (step == 0) {
4064       throw std::invalid_argument("slice step cannot be zero");
4065     } else if (step > 0) {
4066       // Required range: 0 <= i < size, 0 <= j < size, i <= j
4067       if (i < 0) {
4068         ii = 0;
4069       } else if (i < (Difference)size) {
4070         ii = i;
4071       } else if (insert && (i >= (Difference)size)) {
4072         ii = (Difference)size;
4073       }
4074       if (j < 0) {
4075         jj = 0;
4076       } else {
4077         jj = (j < (Difference)size) ? j : (Difference)size;
4078       }
4079       if (jj < ii)
4080         jj = ii;
4081     } else {
4082       // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j
4083       if (i < -1) {
4084         ii = -1;
4085       } else if (i < (Difference) size) {
4086         ii = i;
4087       } else if (i >= (Difference)(size-1)) {
4088         ii = (Difference)(size-1);
4089       }
4090       if (j < -1) {
4091         jj = -1;
4092       } else {
4093         jj = (j < (Difference)size ) ? j : (Difference)(size-1);
4094       }
4095       if (ii < jj)
4096         ii = jj;
4097     }
4098   }
4099
4100   template <class Sequence, class Difference>
4101   inline typename Sequence::iterator
4102   getpos(Sequence* self, Difference i)  {
4103     typename Sequence::iterator pos = self->begin();
4104     std::advance(pos, check_index(i,self->size()));
4105     return pos;
4106   }
4107
4108   template <class Sequence, class Difference>
4109   inline typename Sequence::const_iterator
4110   cgetpos(const Sequence* self, Difference i)  {
4111     typename Sequence::const_iterator pos = self->begin();
4112     std::advance(pos, check_index(i,self->size()));
4113     return pos;
4114   }
4115
4116   template <class Sequence>
4117   inline void
4118   erase(Sequence* seq, const typename Sequence::iterator& position) {
4119     seq->erase(position);
4120   }
4121
4122   template <class Sequence>
4123   struct traits_reserve {
4124     static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) {
4125       // This should be specialized for types that support reserve
4126     }
4127   };
4128
4129   template <class Sequence, class Difference>
4130   inline Sequence*
4131   getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
4132     typename Sequence::size_type size = self->size();
4133     Difference ii = 0;
4134     Difference jj = 0;
4135     swig::slice_adjust(i, j, step, size, ii, jj);
4136
4137     if (step > 0) {
4138       typename Sequence::const_iterator sb = self->begin();
4139       typename Sequence::const_iterator se = self->begin();
4140       std::advance(sb,ii);
4141       std::advance(se,jj);
4142       if (step == 1) {
4143         return new Sequence(sb, se);
4144       } else {
4145         Sequence *sequence = new Sequence();
4146         swig::traits_reserve<Sequence>::reserve(*sequence, (jj - ii + step - 1) / step);
4147         typename Sequence::const_iterator it = sb;
4148         while (it!=se) {
4149           sequence->push_back(*it);
4150           for (Py_ssize_t c=0; c<step && it!=se; ++c)
4151             it++;
4152         }
4153         return sequence;
4154       }
4155     } else {
4156       Sequence *sequence = new Sequence();
4157       swig::traits_reserve<Sequence>::reserve(*sequence, (ii - jj - step - 1) / -step);
4158       typename Sequence::const_reverse_iterator sb = self->rbegin();
4159       typename Sequence::const_reverse_iterator se = self->rbegin();
4160       std::advance(sb,size-ii-1);
4161       std::advance(se,size-jj-1);
4162       typename Sequence::const_reverse_iterator it = sb;
4163       while (it!=se) {
4164         sequence->push_back(*it);
4165         for (Py_ssize_t c=0; c<-step && it!=se; ++c)
4166           it++;
4167       }
4168       return sequence;
4169     }
4170   }
4171
4172   template <class Sequence, class Difference, class InputSeq>
4173   inline void
4174   setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
4175     typename Sequence::size_type size = self->size();
4176     Difference ii = 0;
4177     Difference jj = 0;
4178     swig::slice_adjust(i, j, step, size, ii, jj, true);
4179     if (step > 0) {
4180       if (step == 1) {
4181         size_t ssize = jj - ii;
4182         if (ssize <= is.size()) {
4183           // expanding/staying the same size
4184           swig::traits_reserve<Sequence>::reserve(*self, self->size() - ssize + is.size());
4185           typename Sequence::iterator sb = self->begin();
4186           typename InputSeq::const_iterator isit = is.begin();
4187           std::advance(sb,ii);
4188           std::advance(isit, jj - ii);
4189           self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
4190         } else {
4191           // shrinking
4192           typename Sequence::iterator sb = self->begin();
4193           typename Sequence::iterator se = self->begin();
4194           std::advance(sb,ii);
4195           std::advance(se,jj);
4196           self->erase(sb,se);
4197           sb = self->begin();
4198           std::advance(sb,ii);
4199           self->insert(sb, is.begin(), is.end());
4200         }
4201       } else {
4202         size_t replacecount = (jj - ii + step - 1) / step;
4203         if (is.size() != replacecount) {
4204           char msg[1024];
4205           sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
4206           throw std::invalid_argument(msg);
4207         }
4208         typename Sequence::const_iterator isit = is.begin();
4209         typename Sequence::iterator it = self->begin();
4210         std::advance(it,ii);
4211         for (size_t rc=0; rc<replacecount; ++rc) {
4212           *it++ = *isit++;
4213           for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
4214             it++;
4215         }
4216       }
4217     } else {
4218       size_t replacecount = (ii - jj - step - 1) / -step;
4219       if (is.size() != replacecount) {
4220         char msg[1024];
4221         sprintf(msg, "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
4222         throw std::invalid_argument(msg);
4223       }
4224       typename Sequence::const_iterator isit = is.begin();
4225       typename Sequence::reverse_iterator it = self->rbegin();
4226       std::advance(it,size-ii-1);
4227       for (size_t rc=0; rc<replacecount; ++rc) {
4228         *it++ = *isit++;
4229         for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
4230           it++;
4231       }
4232     }
4233   }
4234
4235   template <class Sequence, class Difference>
4236   inline void
4237   delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
4238     typename Sequence::size_type size = self->size();
4239     Difference ii = 0;
4240     Difference jj = 0;
4241     swig::slice_adjust(i, j, step, size, ii, jj, true);
4242     if (step > 0) {
4243       typename Sequence::iterator sb = self->begin();
4244       std::advance(sb,ii);
4245       if (step == 1) {
4246         typename Sequence::iterator se = self->begin();
4247         std::advance(se,jj);
4248         self->erase(sb,se);
4249       } else {
4250         typename Sequence::iterator it = sb;
4251         size_t delcount = (jj - ii + step - 1) / step;
4252         while (delcount) {
4253           it = self->erase(it);
4254           for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
4255             it++;
4256           delcount--;
4257         }
4258       }
4259     } else {
4260       typename Sequence::reverse_iterator sb = self->rbegin();
4261       std::advance(sb,size-ii-1);
4262       typename Sequence::reverse_iterator it = sb;
4263       size_t delcount = (ii - jj - step - 1) / -step;
4264       while (delcount) {
4265         it = typename Sequence::reverse_iterator(self->erase((++it).base()));
4266         for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
4267           it++;
4268         delcount--;
4269       }
4270     }
4271   }
4272 }
4273
4274
4275 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
4276 #  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
4277 #    define SWIG_STD_NOITERATOR_TRAITS_STL
4278 #  endif
4279 #endif
4280
4281 #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
4282 #include <iterator>
4283 #else
4284 namespace std {
4285   template <class Iterator>
4286   struct iterator_traits {
4287     typedef ptrdiff_t difference_type;
4288     typedef typename Iterator::value_type value_type;
4289   };
4290
4291   template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
4292   struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
4293     typedef Distance difference_type;
4294     typedef T value_type;
4295   };
4296
4297   template <class T>
4298   struct iterator_traits<T*> {
4299     typedef T value_type;
4300     typedef ptrdiff_t difference_type;
4301   };
4302
4303   template<typename _InputIterator>
4304   inline typename iterator_traits<_InputIterator>::difference_type
4305   distance(_InputIterator __first, _InputIterator __last)
4306   {
4307     typename iterator_traits<_InputIterator>::difference_type __n = 0;
4308     while (__first != __last) {
4309       ++__first; ++__n;
4310     }
4311     return __n;
4312   }
4313 }
4314 #endif
4315
4316
4317 namespace swig {
4318   template<typename OutIterator>
4319   class SwigPyIterator_T :  public SwigPyIterator
4320   {
4321   public:
4322     typedef OutIterator out_iterator;
4323     typedef typename std::iterator_traits<out_iterator>::value_type value_type;
4324     typedef SwigPyIterator_T<out_iterator> self_type;
4325
4326     SwigPyIterator_T(out_iterator curr, PyObject *seq)
4327       : SwigPyIterator(seq), current(curr)
4328     {
4329     }
4330
4331     const out_iterator& get_current() const
4332     {
4333       return current;
4334     }
4335
4336
4337     bool equal (const SwigPyIterator &iter) const
4338     {
4339       const self_type *iters = dynamic_cast<const self_type *>(&iter);
4340       if (iters) {
4341         return (current == iters->get_current());
4342       } else {
4343         throw std::invalid_argument("bad iterator type");
4344       }
4345     }
4346
4347     ptrdiff_t distance(const SwigPyIterator &iter) const
4348     {
4349       const self_type *iters = dynamic_cast<const self_type *>(&iter);
4350       if (iters) {
4351         return std::distance(current, iters->get_current());
4352       } else {
4353         throw std::invalid_argument("bad iterator type");
4354       }
4355     }
4356
4357   protected:
4358     out_iterator current;
4359   };
4360
4361   template <class ValueType>
4362   struct from_oper
4363   {
4364     typedef const ValueType& argument_type;
4365     typedef PyObject *result_type;
4366     result_type operator()(argument_type v) const
4367     {
4368       return swig::from(v);
4369     }
4370   };
4371
4372   template<typename OutIterator,
4373            typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4374            typename FromOper = from_oper<ValueType> >
4375   class SwigPyIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
4376   {
4377   public:
4378     FromOper from;
4379     typedef OutIterator out_iterator;
4380     typedef ValueType value_type;
4381     typedef SwigPyIterator_T<out_iterator>  base;
4382     typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
4383
4384     SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
4385       : SwigPyIterator_T<OutIterator>(curr, seq)
4386     {
4387     }
4388
4389     PyObject *value() const {
4390       return from(static_cast<const value_type&>(*(base::current)));
4391     }
4392
4393     SwigPyIterator *copy() const
4394     {
4395       return new self_type(*this);
4396     }
4397
4398     SwigPyIterator *incr(size_t n = 1)
4399     {
4400       while (n--) {
4401         ++base::current;
4402       }
4403       return this;
4404     }
4405
4406     SwigPyIterator *decr(size_t n = 1)
4407     {
4408       while (n--) {
4409         --base::current;
4410       }
4411       return this;
4412     }
4413   };
4414
4415   template<typename OutIterator,
4416            typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4417            typename FromOper = from_oper<ValueType> >
4418   class SwigPyIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
4419   {
4420   public:
4421     FromOper from;
4422     typedef OutIterator out_iterator;
4423     typedef ValueType value_type;
4424     typedef SwigPyIterator_T<out_iterator>  base;
4425     typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
4426
4427     SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
4428       : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
4429     {
4430     }
4431
4432     PyObject *value() const {
4433       if (base::current == end) {
4434         throw stop_iteration();
4435       } else {
4436         return from(static_cast<const value_type&>(*(base::current)));
4437       }
4438     }
4439
4440     SwigPyIterator *copy() const
4441     {
4442       return new self_type(*this);
4443     }
4444
4445     SwigPyIterator *incr(size_t n = 1)
4446     {
4447       while (n--) {
4448         if (base::current == end) {
4449           throw stop_iteration();
4450         } else {
4451           ++base::current;
4452         }
4453       }
4454       return this;
4455     }
4456
4457     SwigPyIterator *decr(size_t n = 1)
4458     {
4459       while (n--) {
4460         if (base::current == begin) {
4461           throw stop_iteration();
4462         } else {
4463           --base::current;
4464         }
4465       }
4466       return this;
4467     }
4468
4469   private:
4470     out_iterator begin;
4471     out_iterator end;
4472   };
4473
4474   template<typename OutIter>
4475   inline SwigPyIterator*
4476   make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
4477   {
4478     return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
4479   }
4480
4481   template<typename OutIter>
4482   inline SwigPyIterator*
4483   make_output_iterator(const OutIter& current, PyObject *seq = 0)
4484   {
4485     return new SwigPyIteratorOpen_T<OutIter>(current, seq);
4486   }
4487
4488 }
4489
4490
4491 namespace swig
4492 {
4493   template <class T>
4494   struct SwigPySequence_Ref
4495   {
4496     SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
4497       : _seq(seq), _index(index)
4498     {
4499     }
4500
4501     operator T () const
4502     {
4503       swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
4504       try {
4505         return swig::as<T>(item, true);
4506       } catch (std::exception& e) {
4507         char msg[1024];
4508         sprintf(msg, "in sequence element %d ", (int)_index);
4509         if (!PyErr_Occurred()) {
4510           ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
4511         }
4512         SWIG_Python_AddErrorMsg(msg);
4513         SWIG_Python_AddErrorMsg(e.what());
4514         throw;
4515       }
4516     }
4517
4518     SwigPySequence_Ref& operator=(const T& v)
4519     {
4520       PySequence_SetItem(_seq, _index, swig::from<T>(v));
4521       return *this;
4522     }
4523
4524   private:
4525     PyObject* _seq;
4526     Py_ssize_t _index;
4527   };
4528
4529   template <class T>
4530   struct SwigPySequence_ArrowProxy
4531   {
4532     SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
4533     const T* operator->() const { return &m_value; }
4534     operator const T*() const { return &m_value; }
4535     T m_value;
4536   };
4537
4538   template <class T, class Reference >
4539   struct SwigPySequence_InputIterator
4540   {
4541     typedef SwigPySequence_InputIterator<T, Reference > self;
4542
4543     typedef std::random_access_iterator_tag iterator_category;
4544     typedef Reference reference;
4545     typedef T value_type;
4546     typedef T* pointer;
4547     typedef Py_ssize_t difference_type;
4548
4549     SwigPySequence_InputIterator()
4550     {
4551     }
4552
4553     SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
4554       : _seq(seq), _index(index)
4555     {
4556     }
4557
4558     reference operator*() const
4559     {
4560       return reference(_seq, _index);
4561     }
4562
4563     SwigPySequence_ArrowProxy<T>
4564     operator->() const {
4565       return SwigPySequence_ArrowProxy<T>(operator*());
4566     }
4567
4568     bool operator==(const self& ri) const
4569     {
4570       return (_index == ri._index) && (_seq == ri._seq);
4571     }
4572
4573     bool operator!=(const self& ri) const
4574     {
4575       return !(operator==(ri));
4576     }
4577
4578     self& operator ++ ()
4579     {
4580       ++_index;
4581       return *this;
4582     }
4583
4584     self& operator -- ()
4585     {
4586       --_index;
4587       return *this;
4588     }
4589
4590     self& operator += (difference_type n)
4591     {
4592       _index += n;
4593       return *this;
4594     }
4595
4596     self operator +(difference_type n) const
4597     {
4598       return self(_seq, _index + n);
4599     }
4600
4601     self& operator -= (difference_type n)
4602     {
4603       _index -= n;
4604       return *this;
4605     }
4606
4607     self operator -(difference_type n) const
4608     {
4609       return self(_seq, _index - n);
4610     }
4611
4612     difference_type operator - (const self& ri) const
4613     {
4614       return _index - ri._index;
4615     }
4616
4617     bool operator < (const self& ri) const
4618     {
4619       return _index < ri._index;
4620     }
4621
4622     reference
4623     operator[](difference_type n) const
4624     {
4625       return reference(_seq, _index + n);
4626     }
4627
4628   private:
4629     PyObject* _seq;
4630     difference_type _index;
4631   };
4632
4633   // STL container wrapper around a Python sequence
4634   template <class T>
4635   struct SwigPySequence_Cont
4636   {
4637     typedef SwigPySequence_Ref<T> reference;
4638     typedef const SwigPySequence_Ref<T> const_reference;
4639     typedef T value_type;
4640     typedef T* pointer;
4641     typedef Py_ssize_t difference_type;
4642     typedef size_t size_type;
4643     typedef const pointer const_pointer;
4644     typedef SwigPySequence_InputIterator<T, reference> iterator;
4645     typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
4646
4647     SwigPySequence_Cont(PyObject* seq) : _seq(0)
4648     {
4649       if (!PySequence_Check(seq)) {
4650         throw std::invalid_argument("a sequence is expected");
4651       }
4652       _seq = seq;
4653       Py_INCREF(_seq);
4654     }
4655
4656     ~SwigPySequence_Cont()
4657     {
4658       Py_XDECREF(_seq);
4659     }
4660
4661     size_type size() const
4662     {
4663       return static_cast<size_type>(PySequence_Size(_seq));
4664     }
4665
4666     bool empty() const
4667     {
4668       return size() == 0;
4669     }
4670
4671     iterator begin()
4672     {
4673       return iterator(_seq, 0);
4674     }
4675
4676     const_iterator begin() const
4677     {
4678       return const_iterator(_seq, 0);
4679     }
4680
4681     iterator end()
4682     {
4683       return iterator(_seq, size());
4684     }
4685
4686     const_iterator end() const
4687     {
4688       return const_iterator(_seq, size());
4689     }
4690
4691     reference operator[](difference_type n)
4692     {
4693       return reference(_seq, n);
4694     }
4695
4696     const_reference operator[](difference_type n)  const
4697     {
4698       return const_reference(_seq, n);
4699     }
4700
4701     bool check(bool set_err = true) const
4702     {
4703       Py_ssize_t s = size();
4704       for (Py_ssize_t i = 0; i < s; ++i) {
4705         swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
4706         if (!swig::check<value_type>(item)) {
4707           if (set_err) {
4708             char msg[1024];
4709             sprintf(msg, "in sequence element %d", (int)i);
4710             SWIG_Error(SWIG_RuntimeError, msg);
4711           }
4712           return false;
4713         }
4714       }
4715       return true;
4716     }
4717
4718   private:
4719     PyObject* _seq;
4720   };
4721
4722 }
4723
4724
4725   namespace swig {
4726     template <>  struct traits< Hex::Hexa > {
4727       typedef pointer_category category;
4728       static const char* type_name() { return"Hex::Hexa"; }
4729     };
4730   }
4731
4732
4733 namespace swig {
4734   template <class SwigPySeq, class Seq>
4735   inline void
4736   assign(const SwigPySeq& swigpyseq, Seq* seq) {
4737     // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
4738     typedef typename SwigPySeq::value_type value_type;
4739     typename SwigPySeq::const_iterator it = swigpyseq.begin();
4740     for (;it != swigpyseq.end(); ++it) {
4741       seq->insert(seq->end(),(value_type)(*it));
4742     }
4743   }
4744
4745   template <class Seq, class T = typename Seq::value_type >
4746   struct traits_asptr_stdseq {
4747     typedef Seq sequence;
4748     typedef T value_type;
4749
4750     static int asptr(PyObject *obj, sequence **seq) {
4751       if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
4752         sequence *p;
4753         swig_type_info *descriptor = swig::type_info<sequence>();
4754         if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
4755           if (seq) *seq = p;
4756           return SWIG_OLDOBJ;
4757         }
4758       } else if (PySequence_Check(obj)) {
4759         try {
4760           SwigPySequence_Cont<value_type> swigpyseq(obj);
4761           if (seq) {
4762             sequence *pseq = new sequence();
4763             assign(swigpyseq, pseq);
4764             *seq = pseq;
4765             return SWIG_NEWOBJ;
4766           } else {
4767             return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
4768           }
4769         } catch (std::exception& e) {
4770           if (seq) {
4771             if (!PyErr_Occurred()) {
4772               PyErr_SetString(PyExc_TypeError, e.what());
4773             }
4774           }
4775           return SWIG_ERROR;
4776         }
4777       }
4778       return SWIG_ERROR;
4779     }
4780   };
4781
4782   template <class Seq, class T = typename Seq::value_type >
4783   struct traits_from_stdseq {
4784     typedef Seq sequence;
4785     typedef T value_type;
4786     typedef typename Seq::size_type size_type;
4787     typedef typename sequence::const_iterator const_iterator;
4788
4789     static PyObject *from(const sequence& seq) {
4790 #ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
4791       swig_type_info *desc = swig::type_info<sequence>();
4792       if (desc && desc->clientdata) {
4793         return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
4794       }
4795 #endif
4796       size_type size = seq.size();
4797       if (size <= (size_type)INT_MAX) {
4798         PyObject *obj = PyTuple_New((Py_ssize_t)size);
4799         Py_ssize_t i = 0;
4800         for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
4801           PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
4802         }
4803         return obj;
4804       } else {
4805         PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
4806         return NULL;
4807       }
4808     }
4809   };
4810 }
4811
4812
4813   namespace swig {
4814     template <class T>
4815     struct traits_reserve<std::vector<T> > {
4816       static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
4817         seq.reserve(n);
4818       }
4819     };
4820
4821     template <class T>
4822     struct traits_asptr<std::vector<T> >  {
4823       static int asptr(PyObject *obj, std::vector<T> **vec) {
4824         return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
4825       }
4826     };
4827
4828     template <class T>
4829     struct traits_from<std::vector<T> > {
4830       static PyObject *from(const std::vector<T>& vec) {
4831         return traits_from_stdseq<std::vector<T> >::from(vec);
4832       }
4833     };
4834   }
4835
4836
4837       namespace swig {
4838         template <>  struct traits<std::vector< Hex::Hexa*, std::allocator< Hex::Hexa * > > > {
4839           typedef value_category category;
4840           static const char* type_name() {
4841             return "std::vector<" "Hex::Hexa" " *," "std::allocator< Hex::Hexa * >" " >";
4842           }
4843         };
4844       }
4845
4846 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(std::vector< Hex::Hexa * > *self,PyObject **PYTHON_SELF){
4847       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4848     }
4849 SWIGINTERN bool std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__(std::vector< Hex::Hexa * > const *self){
4850       return !(self->empty());
4851     }
4852 SWIGINTERN bool std_vector_Sl_Hex_Hexa_Sm__Sg____bool__(std::vector< Hex::Hexa * > const *self){
4853       return !(self->empty());
4854     }
4855 SWIGINTERN std::vector< Hex::Hexa * >::size_type std_vector_Sl_Hex_Hexa_Sm__Sg____len__(std::vector< Hex::Hexa * > const *self){
4856       return self->size();
4857     }
4858
4859 SWIGINTERNINLINE PyObject*
4860 SWIG_From_unsigned_SS_long  (unsigned long value)
4861 {
4862   return (value > LONG_MAX) ?
4863     PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
4864 }
4865
4866
4867 #ifdef SWIG_LONG_LONG_AVAILABLE
4868 SWIGINTERNINLINE PyObject*
4869 SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
4870 {
4871   return (value > LONG_MAX) ?
4872     PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
4873 }
4874 #endif
4875
4876
4877 SWIGINTERNINLINE PyObject *
4878 SWIG_From_size_t  (size_t value)
4879 {
4880 #ifdef SWIG_LONG_LONG_AVAILABLE
4881   if (sizeof(size_t) <= sizeof(unsigned long)) {
4882 #endif
4883     return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
4884 #ifdef SWIG_LONG_LONG_AVAILABLE
4885   } else {
4886     /* assume sizeof(size_t) <= sizeof(unsigned long long) */
4887     return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
4888   }
4889 #endif
4890 }
4891
4892 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){
4893       return swig::getslice(self, i, j, 1);
4894     }
4895 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setslice____SWIG_0(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i,std::vector< Hex::Hexa * >::difference_type j){
4896       swig::setslice(self, i, j, 1, std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >());
4897     }
4898 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setslice____SWIG_1(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){
4899       swig::setslice(self, i, j, 1, v);
4900     }
4901 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){
4902       swig::delslice(self, i, j, 1);
4903     }
4904 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i){
4905       swig::erase(self, swig::getpos(self, i));
4906     }
4907 SWIGINTERN std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Hexa * > *self,PySliceObject *slice){
4908       Py_ssize_t i, j, step;
4909       if( !PySlice_Check(slice) ) {
4910         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4911         return NULL;
4912       }
4913       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
4914       std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type id = i;
4915       std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type jd = j;
4916       return swig::getslice(self, id, jd, step);
4917     }
4918 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Hexa * > *self,PySliceObject *slice,std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &v){
4919       Py_ssize_t i, j, step;
4920       if( !PySlice_Check(slice) ) {
4921         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4922         return;
4923       }
4924       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
4925       std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type id = i;
4926       std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type jd = j;
4927       swig::setslice(self, id, jd, step, v);
4928     }
4929 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Hexa * > *self,PySliceObject *slice){
4930       Py_ssize_t i, j, step;
4931       if( !PySlice_Check(slice) ) {
4932         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4933         return;
4934       }
4935       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
4936       std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type id = i;
4937       std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type jd = j;
4938       swig::delslice(self, id, jd, step);
4939     }
4940 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Hexa * > *self,PySliceObject *slice){
4941       Py_ssize_t i, j, step;
4942       if( !PySlice_Check(slice) ) {
4943         SWIG_Error(SWIG_TypeError, "Slice object expected.");
4944         return;
4945       }
4946       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
4947       std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type id = i;
4948       std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::difference_type jd = j;
4949       swig::delslice(self, id, jd, step);
4950     }
4951 SWIGINTERN std::vector< Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i){
4952       return *(swig::cgetpos(self, i));
4953     }
4954 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_2(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::difference_type i,std::vector< Hex::Hexa * >::value_type x){
4955       *(swig::getpos(self,i)) = x;
4956     }
4957 SWIGINTERN std::vector< Hex::Hexa * >::value_type std_vector_Sl_Hex_Hexa_Sm__Sg__pop(std::vector< Hex::Hexa * > *self){
4958       if (self->size() == 0)
4959         throw std::out_of_range("pop from empty container");
4960       std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >::value_type x = self->back();
4961       self->pop_back();
4962       return x;
4963     }
4964 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg__append(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::value_type x){
4965       self->push_back(x);
4966     }
4967 SWIGINTERN std::vector< Hex::Hexa * >::iterator std_vector_Sl_Hex_Hexa_Sm__Sg__erase__SWIG_0(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::iterator pos){ return self->erase(pos); }
4968 SWIGINTERN std::vector< Hex::Hexa * >::iterator std_vector_Sl_Hex_Hexa_Sm__Sg__erase__SWIG_1(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::iterator first,std::vector< Hex::Hexa * >::iterator last){ return self->erase(first, last); }
4969 SWIGINTERN std::vector< Hex::Hexa * >::iterator std_vector_Sl_Hex_Hexa_Sm__Sg__insert__SWIG_0(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::iterator pos,std::vector< Hex::Hexa * >::value_type x){ return self->insert(pos, x); }
4970 SWIGINTERN void std_vector_Sl_Hex_Hexa_Sm__Sg__insert__SWIG_1(std::vector< Hex::Hexa * > *self,std::vector< Hex::Hexa * >::iterator pos,std::vector< Hex::Hexa * >::size_type n,std::vector< Hex::Hexa * >::value_type x){ self->insert(pos, n, x); }
4971
4972   namespace swig {
4973     template <>  struct traits< Hex::Quad > {
4974       typedef pointer_category category;
4975       static const char* type_name() { return"Hex::Quad"; }
4976     };
4977   }
4978
4979
4980       namespace swig {
4981         template <>  struct traits<std::vector< Hex::Quad*, std::allocator< Hex::Quad * > > > {
4982           typedef value_category category;
4983           static const char* type_name() {
4984             return "std::vector<" "Hex::Quad" " *," "std::allocator< Hex::Quad * >" " >";
4985           }
4986         };
4987       }
4988
4989 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Quad_Sm__Sg__iterator(std::vector< Hex::Quad * > *self,PyObject **PYTHON_SELF){
4990       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
4991     }
4992 SWIGINTERN bool std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__(std::vector< Hex::Quad * > const *self){
4993       return !(self->empty());
4994     }
4995 SWIGINTERN bool std_vector_Sl_Hex_Quad_Sm__Sg____bool__(std::vector< Hex::Quad * > const *self){
4996       return !(self->empty());
4997     }
4998 SWIGINTERN std::vector< Hex::Quad * >::size_type std_vector_Sl_Hex_Quad_Sm__Sg____len__(std::vector< Hex::Quad * > const *self){
4999       return self->size();
5000     }
5001 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){
5002       return swig::getslice(self, i, j, 1);
5003     }
5004 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setslice____SWIG_0(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i,std::vector< Hex::Quad * >::difference_type j){
5005       swig::setslice(self, i, j, 1, std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >());
5006     }
5007 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setslice____SWIG_1(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){
5008       swig::setslice(self, i, j, 1, v);
5009     }
5010 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){
5011       swig::delslice(self, i, j, 1);
5012     }
5013 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i){
5014       swig::erase(self, swig::getpos(self, i));
5015     }
5016 SWIGINTERN std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Quad * > *self,PySliceObject *slice){
5017       Py_ssize_t i, j, step;
5018       if( !PySlice_Check(slice) ) {
5019         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5020         return NULL;
5021       }
5022       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5023       std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type id = i;
5024       std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type jd = j;
5025       return swig::getslice(self, id, jd, step);
5026     }
5027 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Quad * > *self,PySliceObject *slice,std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &v){
5028       Py_ssize_t i, j, step;
5029       if( !PySlice_Check(slice) ) {
5030         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5031         return;
5032       }
5033       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5034       std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type id = i;
5035       std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type jd = j;
5036       swig::setslice(self, id, jd, step, v);
5037     }
5038 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Quad * > *self,PySliceObject *slice){
5039       Py_ssize_t i, j, step;
5040       if( !PySlice_Check(slice) ) {
5041         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5042         return;
5043       }
5044       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5045       std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type id = i;
5046       std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type jd = j;
5047       swig::delslice(self, id, jd, step);
5048     }
5049 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Quad * > *self,PySliceObject *slice){
5050       Py_ssize_t i, j, step;
5051       if( !PySlice_Check(slice) ) {
5052         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5053         return;
5054       }
5055       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5056       std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type id = i;
5057       std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::difference_type jd = j;
5058       swig::delslice(self, id, jd, step);
5059     }
5060 SWIGINTERN std::vector< Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i){
5061       return *(swig::cgetpos(self, i));
5062     }
5063 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_2(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::difference_type i,std::vector< Hex::Quad * >::value_type x){
5064       *(swig::getpos(self,i)) = x;
5065     }
5066 SWIGINTERN std::vector< Hex::Quad * >::value_type std_vector_Sl_Hex_Quad_Sm__Sg__pop(std::vector< Hex::Quad * > *self){
5067       if (self->size() == 0)
5068         throw std::out_of_range("pop from empty container");
5069       std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >::value_type x = self->back();
5070       self->pop_back();
5071       return x;
5072     }
5073 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg__append(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::value_type x){
5074       self->push_back(x);
5075     }
5076 SWIGINTERN std::vector< Hex::Quad * >::iterator std_vector_Sl_Hex_Quad_Sm__Sg__erase__SWIG_0(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::iterator pos){ return self->erase(pos); }
5077 SWIGINTERN std::vector< Hex::Quad * >::iterator std_vector_Sl_Hex_Quad_Sm__Sg__erase__SWIG_1(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::iterator first,std::vector< Hex::Quad * >::iterator last){ return self->erase(first, last); }
5078 SWIGINTERN std::vector< Hex::Quad * >::iterator std_vector_Sl_Hex_Quad_Sm__Sg__insert__SWIG_0(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::iterator pos,std::vector< Hex::Quad * >::value_type x){ return self->insert(pos, x); }
5079 SWIGINTERN void std_vector_Sl_Hex_Quad_Sm__Sg__insert__SWIG_1(std::vector< Hex::Quad * > *self,std::vector< Hex::Quad * >::iterator pos,std::vector< Hex::Quad * >::size_type n,std::vector< Hex::Quad * >::value_type x){ self->insert(pos, n, x); }
5080
5081   namespace swig {
5082     template <>  struct traits< Hex::Edge > {
5083       typedef pointer_category category;
5084       static const char* type_name() { return"Hex::Edge"; }
5085     };
5086   }
5087
5088
5089       namespace swig {
5090         template <>  struct traits<std::vector< Hex::Edge*, std::allocator< Hex::Edge * > > > {
5091           typedef value_category category;
5092           static const char* type_name() {
5093             return "std::vector<" "Hex::Edge" " *," "std::allocator< Hex::Edge * >" " >";
5094           }
5095         };
5096       }
5097
5098 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Edge_Sm__Sg__iterator(std::vector< Hex::Edge * > *self,PyObject **PYTHON_SELF){
5099       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5100     }
5101 SWIGINTERN bool std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__(std::vector< Hex::Edge * > const *self){
5102       return !(self->empty());
5103     }
5104 SWIGINTERN bool std_vector_Sl_Hex_Edge_Sm__Sg____bool__(std::vector< Hex::Edge * > const *self){
5105       return !(self->empty());
5106     }
5107 SWIGINTERN std::vector< Hex::Edge * >::size_type std_vector_Sl_Hex_Edge_Sm__Sg____len__(std::vector< Hex::Edge * > const *self){
5108       return self->size();
5109     }
5110 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){
5111       return swig::getslice(self, i, j, 1);
5112     }
5113 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setslice____SWIG_0(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i,std::vector< Hex::Edge * >::difference_type j){
5114       swig::setslice(self, i, j, 1, std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >());
5115     }
5116 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setslice____SWIG_1(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){
5117       swig::setslice(self, i, j, 1, v);
5118     }
5119 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){
5120       swig::delslice(self, i, j, 1);
5121     }
5122 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i){
5123       swig::erase(self, swig::getpos(self, i));
5124     }
5125 SWIGINTERN std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Edge * > *self,PySliceObject *slice){
5126       Py_ssize_t i, j, step;
5127       if( !PySlice_Check(slice) ) {
5128         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5129         return NULL;
5130       }
5131       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5132       std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type id = i;
5133       std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type jd = j;
5134       return swig::getslice(self, id, jd, step);
5135     }
5136 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Edge * > *self,PySliceObject *slice,std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &v){
5137       Py_ssize_t i, j, step;
5138       if( !PySlice_Check(slice) ) {
5139         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5140         return;
5141       }
5142       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5143       std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type id = i;
5144       std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type jd = j;
5145       swig::setslice(self, id, jd, step, v);
5146     }
5147 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Edge * > *self,PySliceObject *slice){
5148       Py_ssize_t i, j, step;
5149       if( !PySlice_Check(slice) ) {
5150         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5151         return;
5152       }
5153       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5154       std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type id = i;
5155       std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type jd = j;
5156       swig::delslice(self, id, jd, step);
5157     }
5158 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Edge * > *self,PySliceObject *slice){
5159       Py_ssize_t i, j, step;
5160       if( !PySlice_Check(slice) ) {
5161         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5162         return;
5163       }
5164       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5165       std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type id = i;
5166       std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::difference_type jd = j;
5167       swig::delslice(self, id, jd, step);
5168     }
5169 SWIGINTERN std::vector< Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i){
5170       return *(swig::cgetpos(self, i));
5171     }
5172 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_2(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::difference_type i,std::vector< Hex::Edge * >::value_type x){
5173       *(swig::getpos(self,i)) = x;
5174     }
5175 SWIGINTERN std::vector< Hex::Edge * >::value_type std_vector_Sl_Hex_Edge_Sm__Sg__pop(std::vector< Hex::Edge * > *self){
5176       if (self->size() == 0)
5177         throw std::out_of_range("pop from empty container");
5178       std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >::value_type x = self->back();
5179       self->pop_back();
5180       return x;
5181     }
5182 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg__append(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::value_type x){
5183       self->push_back(x);
5184     }
5185 SWIGINTERN std::vector< Hex::Edge * >::iterator std_vector_Sl_Hex_Edge_Sm__Sg__erase__SWIG_0(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::iterator pos){ return self->erase(pos); }
5186 SWIGINTERN std::vector< Hex::Edge * >::iterator std_vector_Sl_Hex_Edge_Sm__Sg__erase__SWIG_1(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::iterator first,std::vector< Hex::Edge * >::iterator last){ return self->erase(first, last); }
5187 SWIGINTERN std::vector< Hex::Edge * >::iterator std_vector_Sl_Hex_Edge_Sm__Sg__insert__SWIG_0(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::iterator pos,std::vector< Hex::Edge * >::value_type x){ return self->insert(pos, x); }
5188 SWIGINTERN void std_vector_Sl_Hex_Edge_Sm__Sg__insert__SWIG_1(std::vector< Hex::Edge * > *self,std::vector< Hex::Edge * >::iterator pos,std::vector< Hex::Edge * >::size_type n,std::vector< Hex::Edge * >::value_type x){ self->insert(pos, n, x); }
5189
5190   namespace swig {
5191     template <>  struct traits< Hex::Vertex > {
5192       typedef pointer_category category;
5193       static const char* type_name() { return"Hex::Vertex"; }
5194     };
5195   }
5196
5197
5198       namespace swig {
5199         template <>  struct traits<std::vector< Hex::Vertex*, std::allocator< Hex::Vertex * > > > {
5200           typedef value_category category;
5201           static const char* type_name() {
5202             return "std::vector<" "Hex::Vertex" " *," "std::allocator< Hex::Vertex * >" " >";
5203           }
5204         };
5205       }
5206
5207 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(std::vector< Hex::Vertex * > *self,PyObject **PYTHON_SELF){
5208       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5209     }
5210 SWIGINTERN bool std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__(std::vector< Hex::Vertex * > const *self){
5211       return !(self->empty());
5212     }
5213 SWIGINTERN bool std_vector_Sl_Hex_Vertex_Sm__Sg____bool__(std::vector< Hex::Vertex * > const *self){
5214       return !(self->empty());
5215     }
5216 SWIGINTERN std::vector< Hex::Vertex * >::size_type std_vector_Sl_Hex_Vertex_Sm__Sg____len__(std::vector< Hex::Vertex * > const *self){
5217       return self->size();
5218     }
5219 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){
5220       return swig::getslice(self, i, j, 1);
5221     }
5222 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setslice____SWIG_0(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i,std::vector< Hex::Vertex * >::difference_type j){
5223       swig::setslice(self, i, j, 1, std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >());
5224     }
5225 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setslice____SWIG_1(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){
5226       swig::setslice(self, i, j, 1, v);
5227     }
5228 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){
5229       swig::delslice(self, i, j, 1);
5230     }
5231 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_0(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i){
5232       swig::erase(self, swig::getpos(self, i));
5233     }
5234 SWIGINTERN std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_0(std::vector< Hex::Vertex * > *self,PySliceObject *slice){
5235       Py_ssize_t i, j, step;
5236       if( !PySlice_Check(slice) ) {
5237         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5238         return NULL;
5239       }
5240       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5241       std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type id = i;
5242       std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type jd = j;
5243       return swig::getslice(self, id, jd, step);
5244     }
5245 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_0(std::vector< Hex::Vertex * > *self,PySliceObject *slice,std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &v){
5246       Py_ssize_t i, j, step;
5247       if( !PySlice_Check(slice) ) {
5248         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5249         return;
5250       }
5251       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5252       std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type id = i;
5253       std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type jd = j;
5254       swig::setslice(self, id, jd, step, v);
5255     }
5256 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_1(std::vector< Hex::Vertex * > *self,PySliceObject *slice){
5257       Py_ssize_t i, j, step;
5258       if( !PySlice_Check(slice) ) {
5259         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5260         return;
5261       }
5262       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5263       std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type id = i;
5264       std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type jd = j;
5265       swig::delslice(self, id, jd, step);
5266     }
5267 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_1(std::vector< Hex::Vertex * > *self,PySliceObject *slice){
5268       Py_ssize_t i, j, step;
5269       if( !PySlice_Check(slice) ) {
5270         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5271         return;
5272       }
5273       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5274       std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type id = i;
5275       std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::difference_type jd = j;
5276       swig::delslice(self, id, jd, step);
5277     }
5278 SWIGINTERN std::vector< Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_1(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i){
5279       return *(swig::cgetpos(self, i));
5280     }
5281 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_2(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::difference_type i,std::vector< Hex::Vertex * >::value_type x){
5282       *(swig::getpos(self,i)) = x;
5283     }
5284 SWIGINTERN std::vector< Hex::Vertex * >::value_type std_vector_Sl_Hex_Vertex_Sm__Sg__pop(std::vector< Hex::Vertex * > *self){
5285       if (self->size() == 0)
5286         throw std::out_of_range("pop from empty container");
5287       std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >::value_type x = self->back();
5288       self->pop_back();
5289       return x;
5290     }
5291 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg__append(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::value_type x){
5292       self->push_back(x);
5293     }
5294 SWIGINTERN std::vector< Hex::Vertex * >::iterator std_vector_Sl_Hex_Vertex_Sm__Sg__erase__SWIG_0(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::iterator pos){ return self->erase(pos); }
5295 SWIGINTERN std::vector< Hex::Vertex * >::iterator std_vector_Sl_Hex_Vertex_Sm__Sg__erase__SWIG_1(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::iterator first,std::vector< Hex::Vertex * >::iterator last){ return self->erase(first, last); }
5296 SWIGINTERN std::vector< Hex::Vertex * >::iterator std_vector_Sl_Hex_Vertex_Sm__Sg__insert__SWIG_0(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::iterator pos,std::vector< Hex::Vertex * >::value_type x){ return self->insert(pos, x); }
5297 SWIGINTERN void std_vector_Sl_Hex_Vertex_Sm__Sg__insert__SWIG_1(std::vector< Hex::Vertex * > *self,std::vector< Hex::Vertex * >::iterator pos,std::vector< Hex::Vertex * >::size_type n,std::vector< Hex::Vertex * >::value_type x){ self->insert(pos, n, x); }
5298
5299   namespace swig {
5300     template <>  struct traits< Hex::NewShape > {
5301       typedef pointer_category category;
5302       static const char* type_name() { return"Hex::NewShape"; }
5303     };
5304   }
5305
5306
5307       namespace swig {
5308         template <>  struct traits<std::vector< Hex::NewShape*, std::allocator< Hex::NewShape * > > > {
5309           typedef value_category category;
5310           static const char* type_name() {
5311             return "std::vector<" "Hex::NewShape" " *," "std::allocator< Hex::NewShape * >" " >";
5312           }
5313         };
5314       }
5315
5316 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(std::vector< Hex::NewShape * > *self,PyObject **PYTHON_SELF){
5317       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5318     }
5319 SWIGINTERN bool std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__(std::vector< Hex::NewShape * > const *self){
5320       return !(self->empty());
5321     }
5322 SWIGINTERN bool std_vector_Sl_Hex_NewShape_Sm__Sg____bool__(std::vector< Hex::NewShape * > const *self){
5323       return !(self->empty());
5324     }
5325 SWIGINTERN std::vector< Hex::NewShape * >::size_type std_vector_Sl_Hex_NewShape_Sm__Sg____len__(std::vector< Hex::NewShape * > const *self){
5326       return self->size();
5327     }
5328 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){
5329       return swig::getslice(self, i, j, 1);
5330     }
5331 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setslice____SWIG_0(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i,std::vector< Hex::NewShape * >::difference_type j){
5332       swig::setslice(self, i, j, 1, std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >());
5333     }
5334 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setslice____SWIG_1(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){
5335       swig::setslice(self, i, j, 1, v);
5336     }
5337 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){
5338       swig::delslice(self, i, j, 1);
5339     }
5340 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_0(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i){
5341       swig::erase(self, swig::getpos(self, i));
5342     }
5343 SWIGINTERN std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_0(std::vector< Hex::NewShape * > *self,PySliceObject *slice){
5344       Py_ssize_t i, j, step;
5345       if( !PySlice_Check(slice) ) {
5346         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5347         return NULL;
5348       }
5349       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5350       std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type id = i;
5351       std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type jd = j;
5352       return swig::getslice(self, id, jd, step);
5353     }
5354 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_0(std::vector< Hex::NewShape * > *self,PySliceObject *slice,std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &v){
5355       Py_ssize_t i, j, step;
5356       if( !PySlice_Check(slice) ) {
5357         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5358         return;
5359       }
5360       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5361       std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type id = i;
5362       std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type jd = j;
5363       swig::setslice(self, id, jd, step, v);
5364     }
5365 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_1(std::vector< Hex::NewShape * > *self,PySliceObject *slice){
5366       Py_ssize_t i, j, step;
5367       if( !PySlice_Check(slice) ) {
5368         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5369         return;
5370       }
5371       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5372       std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type id = i;
5373       std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type jd = j;
5374       swig::delslice(self, id, jd, step);
5375     }
5376 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_1(std::vector< Hex::NewShape * > *self,PySliceObject *slice){
5377       Py_ssize_t i, j, step;
5378       if( !PySlice_Check(slice) ) {
5379         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5380         return;
5381       }
5382       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5383       std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type id = i;
5384       std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::difference_type jd = j;
5385       swig::delslice(self, id, jd, step);
5386     }
5387 SWIGINTERN std::vector< Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_1(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i){
5388       return *(swig::cgetpos(self, i));
5389     }
5390 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_2(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::difference_type i,std::vector< Hex::NewShape * >::value_type x){
5391       *(swig::getpos(self,i)) = x;
5392     }
5393 SWIGINTERN std::vector< Hex::NewShape * >::value_type std_vector_Sl_Hex_NewShape_Sm__Sg__pop(std::vector< Hex::NewShape * > *self){
5394       if (self->size() == 0)
5395         throw std::out_of_range("pop from empty container");
5396       std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >::value_type x = self->back();
5397       self->pop_back();
5398       return x;
5399     }
5400 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg__append(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::value_type x){
5401       self->push_back(x);
5402     }
5403 SWIGINTERN std::vector< Hex::NewShape * >::iterator std_vector_Sl_Hex_NewShape_Sm__Sg__erase__SWIG_0(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::iterator pos){ return self->erase(pos); }
5404 SWIGINTERN std::vector< Hex::NewShape * >::iterator std_vector_Sl_Hex_NewShape_Sm__Sg__erase__SWIG_1(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::iterator first,std::vector< Hex::NewShape * >::iterator last){ return self->erase(first, last); }
5405 SWIGINTERN std::vector< Hex::NewShape * >::iterator std_vector_Sl_Hex_NewShape_Sm__Sg__insert__SWIG_0(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::iterator pos,std::vector< Hex::NewShape * >::value_type x){ return self->insert(pos, x); }
5406 SWIGINTERN void std_vector_Sl_Hex_NewShape_Sm__Sg__insert__SWIG_1(std::vector< Hex::NewShape * > *self,std::vector< Hex::NewShape * >::iterator pos,std::vector< Hex::NewShape * >::size_type n,std::vector< Hex::NewShape * >::value_type x){ self->insert(pos, n, x); }
5407
5408   #define SWIG_From_double   PyFloat_FromDouble
5409
5410
5411 namespace swig {
5412   template <> struct traits< double > {
5413     typedef value_category category;
5414     static const char* type_name() { return"double"; }
5415   };
5416   template <>  struct traits_asval< double > {
5417     typedef double value_type;
5418     static int asval(PyObject *obj, value_type *val) {
5419       return SWIG_AsVal_double (obj, val);
5420     }
5421   };
5422   template <>  struct traits_from< double > {
5423     typedef double value_type;
5424     static PyObject *from(const value_type& val) {
5425       return SWIG_From_double  (val);
5426     }
5427   };
5428 }
5429
5430
5431       namespace swig {
5432         template <>  struct traits<std::vector< double, std::allocator< double > > > {
5433           typedef pointer_category category;
5434           static const char* type_name() {
5435             return "std::vector<" "double" "," "std::allocator< double >" " >";
5436           }
5437         };
5438       }
5439
5440 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
5441       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5442     }
5443 SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
5444       return !(self->empty());
5445     }
5446 SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
5447       return !(self->empty());
5448     }
5449 SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
5450       return self->size();
5451     }
5452 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){
5453       return swig::getslice(self, i, j, 1);
5454     }
5455 SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
5456       swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
5457     }
5458 SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
5459       swig::setslice(self, i, j, 1, v);
5460     }
5461 SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
5462       swig::delslice(self, i, j, 1);
5463     }
5464 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
5465       swig::erase(self, swig::getpos(self, i));
5466     }
5467 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
5468       Py_ssize_t i, j, step;
5469       if( !PySlice_Check(slice) ) {
5470         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5471         return NULL;
5472       }
5473       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5474       std::vector< double,std::allocator< double > >::difference_type id = i;
5475       std::vector< double,std::allocator< double > >::difference_type jd = j;
5476       return swig::getslice(self, id, jd, step);
5477     }
5478 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
5479       Py_ssize_t i, j, step;
5480       if( !PySlice_Check(slice) ) {
5481         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5482         return;
5483       }
5484       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5485       std::vector< double,std::allocator< double > >::difference_type id = i;
5486       std::vector< double,std::allocator< double > >::difference_type jd = j;
5487       swig::setslice(self, id, jd, step, v);
5488     }
5489 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
5490       Py_ssize_t i, j, step;
5491       if( !PySlice_Check(slice) ) {
5492         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5493         return;
5494       }
5495       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5496       std::vector< double,std::allocator< double > >::difference_type id = i;
5497       std::vector< double,std::allocator< double > >::difference_type jd = j;
5498       swig::delslice(self, id, jd, step);
5499     }
5500 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
5501       Py_ssize_t i, j, step;
5502       if( !PySlice_Check(slice) ) {
5503         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5504         return;
5505       }
5506       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5507       std::vector< double,std::allocator< double > >::difference_type id = i;
5508       std::vector< double,std::allocator< double > >::difference_type jd = j;
5509       swig::delslice(self, id, jd, step);
5510     }
5511 SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
5512       return *(swig::cgetpos(self, i));
5513     }
5514 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
5515       *(swig::getpos(self,i)) = x;
5516     }
5517 SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
5518       if (self->size() == 0)
5519         throw std::out_of_range("pop from empty container");
5520       std::vector< double,std::allocator< double > >::value_type x = self->back();
5521       self->pop_back();
5522       return x;
5523     }
5524 SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
5525       self->push_back(x);
5526     }
5527 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
5528 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
5529 SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
5530 SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
5531
5532 SWIGINTERN int
5533 SWIG_AsVal_int (PyObject * obj, int *val)
5534 {
5535   long v;
5536   int res = SWIG_AsVal_long (obj, &v);
5537   if (SWIG_IsOK(res)) {
5538     if ((v < INT_MIN || v > INT_MAX)) {
5539       return SWIG_OverflowError;
5540     } else {
5541       if (val) *val = static_cast< int >(v);
5542     }
5543   }
5544   return res;
5545 }
5546
5547
5548 SWIGINTERNINLINE PyObject*
5549   SWIG_From_int  (int value)
5550 {
5551   return PyInt_FromLong((long) value);
5552 }
5553
5554
5555 namespace swig {
5556   template <> struct traits< int > {
5557     typedef value_category category;
5558     static const char* type_name() { return"int"; }
5559   };
5560   template <>  struct traits_asval< int > {
5561     typedef int value_type;
5562     static int asval(PyObject *obj, value_type *val) {
5563       return SWIG_AsVal_int (obj, val);
5564     }
5565   };
5566   template <>  struct traits_from< int > {
5567     typedef int value_type;
5568     static PyObject *from(const value_type& val) {
5569       return SWIG_From_int  (val);
5570     }
5571   };
5572 }
5573
5574
5575       namespace swig {
5576         template <>  struct traits<std::vector< int, std::allocator< int > > > {
5577           typedef pointer_category category;
5578           static const char* type_name() {
5579             return "std::vector<" "int" "," "std::allocator< int >" " >";
5580           }
5581         };
5582       }
5583
5584 SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
5585       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
5586     }
5587 SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
5588       return !(self->empty());
5589     }
5590 SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
5591       return !(self->empty());
5592     }
5593 SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
5594       return self->size();
5595     }
5596 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){
5597       return swig::getslice(self, i, j, 1);
5598     }
5599 SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
5600       swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
5601     }
5602 SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
5603       swig::setslice(self, i, j, 1, v);
5604     }
5605 SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
5606       swig::delslice(self, i, j, 1);
5607     }
5608 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
5609       swig::erase(self, swig::getpos(self, i));
5610     }
5611 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
5612       Py_ssize_t i, j, step;
5613       if( !PySlice_Check(slice) ) {
5614         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5615         return NULL;
5616       }
5617       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5618       std::vector< int,std::allocator< int > >::difference_type id = i;
5619       std::vector< int,std::allocator< int > >::difference_type jd = j;
5620       return swig::getslice(self, id, jd, step);
5621     }
5622 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
5623       Py_ssize_t i, j, step;
5624       if( !PySlice_Check(slice) ) {
5625         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5626         return;
5627       }
5628       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5629       std::vector< int,std::allocator< int > >::difference_type id = i;
5630       std::vector< int,std::allocator< int > >::difference_type jd = j;
5631       swig::setslice(self, id, jd, step, v);
5632     }
5633 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
5634       Py_ssize_t i, j, step;
5635       if( !PySlice_Check(slice) ) {
5636         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5637         return;
5638       }
5639       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5640       std::vector< int,std::allocator< int > >::difference_type id = i;
5641       std::vector< int,std::allocator< int > >::difference_type jd = j;
5642       swig::delslice(self, id, jd, step);
5643     }
5644 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
5645       Py_ssize_t i, j, step;
5646       if( !PySlice_Check(slice) ) {
5647         SWIG_Error(SWIG_TypeError, "Slice object expected.");
5648         return;
5649       }
5650       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
5651       std::vector< int,std::allocator< int > >::difference_type id = i;
5652       std::vector< int,std::allocator< int > >::difference_type jd = j;
5653       swig::delslice(self, id, jd, step);
5654     }
5655 SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){
5656       return *(swig::cgetpos(self, i));
5657     }
5658 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
5659       *(swig::getpos(self,i)) = x;
5660     }
5661 SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
5662       if (self->size() == 0)
5663         throw std::out_of_range("pop from empty container");
5664       std::vector< int,std::allocator< int > >::value_type x = self->back();
5665       self->pop_back();
5666       return x;
5667     }
5668 SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
5669       self->push_back(x);
5670     }
5671 SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos){ return self->erase(pos); }
5672 SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_1(std::vector< int > *self,std::vector< int >::iterator first,std::vector< int >::iterator last){ return self->erase(first, last); }
5673 SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::value_type const &x){ return self->insert(pos, x); }
5674 SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); }
5675
5676 SWIGINTERN swig_type_info*
5677 SWIG_pchar_descriptor(void)
5678 {
5679   static int init = 0;
5680   static swig_type_info* info = 0;
5681   if (!init) {
5682     info = SWIG_TypeQuery("_p_char");
5683     init = 1;
5684   }
5685   return info;
5686 }
5687
5688
5689 SWIGINTERNINLINE PyObject *
5690 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
5691 {
5692   if (carray) {
5693     if (size > INT_MAX) {
5694       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
5695       return pchar_descriptor ?
5696         SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
5697     } else {
5698 #if PY_VERSION_HEX >= 0x03000000
5699 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5700       return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
5701 #else
5702 #if PY_VERSION_HEX >= 0x03010000
5703       return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
5704 #else
5705       return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
5706 #endif
5707 #endif
5708 #else
5709       return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
5710 #endif
5711     }
5712   } else {
5713     return SWIG_Py_Void();
5714   }
5715 }
5716
5717
5718 SWIGINTERNINLINE PyObject *
5719 SWIG_From_char  (char c)
5720 {
5721   return SWIG_FromCharPtrAndSize(&c,1);
5722 }
5723
5724
5725 SWIGINTERNINLINE PyObject *
5726 SWIG_FromCharPtr(const char *cptr)
5727 {
5728   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
5729 }
5730
5731
5732 SWIGINTERN int
5733 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
5734 {
5735 #if PY_VERSION_HEX>=0x03000000
5736 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5737   if (PyBytes_Check(obj))
5738 #else
5739   if (PyUnicode_Check(obj))
5740 #endif
5741 #else
5742   if (PyString_Check(obj))
5743 #endif
5744   {
5745     char *cstr; Py_ssize_t len;
5746 #if PY_VERSION_HEX>=0x03000000
5747 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5748     if (!alloc && cptr) {
5749         /* We can't allow converting without allocation, since the internal
5750            representation of string in Python 3 is UCS-2/UCS-4 but we require
5751            a UTF-8 representation.
5752            TODO(bhy) More detailed explanation */
5753         return SWIG_RuntimeError;
5754     }
5755     obj = PyUnicode_AsUTF8String(obj);
5756     if(alloc) *alloc = SWIG_NEWOBJ;
5757 #endif
5758     PyBytes_AsStringAndSize(obj, &cstr, &len);
5759 #else
5760     PyString_AsStringAndSize(obj, &cstr, &len);
5761 #endif
5762     if (cptr) {
5763       if (alloc) {
5764         /*
5765            In python the user should not be able to modify the inner
5766            string representation. To warranty that, if you define
5767            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
5768            buffer is always returned.
5769
5770            The default behavior is just to return the pointer value,
5771            so, be careful.
5772         */
5773 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
5774         if (*alloc != SWIG_OLDOBJ)
5775 #else
5776         if (*alloc == SWIG_NEWOBJ)
5777 #endif
5778         {
5779           *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
5780           *alloc = SWIG_NEWOBJ;
5781         } else {
5782           *cptr = cstr;
5783           *alloc = SWIG_OLDOBJ;
5784         }
5785       } else {
5786 #if PY_VERSION_HEX>=0x03000000
5787 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5788         *cptr = PyBytes_AsString(obj);
5789 #else
5790         assert(0); /* Should never reach here with Unicode strings in Python 3 */
5791 #endif
5792 #else
5793         *cptr = SWIG_Python_str_AsChar(obj);
5794 #endif
5795       }
5796     }
5797     if (psize) *psize = len + 1;
5798 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5799     Py_XDECREF(obj);
5800 #endif
5801     return SWIG_OK;
5802   } else {
5803 #if defined(SWIG_PYTHON_2_UNICODE)
5804 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
5805 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
5806 #endif
5807 #if PY_VERSION_HEX<0x03000000
5808     if (PyUnicode_Check(obj)) {
5809       char *cstr; Py_ssize_t len;
5810       if (!alloc && cptr) {
5811         return SWIG_RuntimeError;
5812       }
5813       obj = PyUnicode_AsUTF8String(obj);
5814       if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
5815         if (cptr) {
5816           if (alloc) *alloc = SWIG_NEWOBJ;
5817           *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
5818         }
5819         if (psize) *psize = len + 1;
5820
5821         Py_XDECREF(obj);
5822         return SWIG_OK;
5823       } else {
5824         Py_XDECREF(obj);
5825       }
5826     }
5827 #endif
5828 #endif
5829
5830     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
5831     if (pchar_descriptor) {
5832       void* vptr = 0;
5833       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
5834         if (cptr) *cptr = (char *) vptr;
5835         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
5836         if (alloc) *alloc = SWIG_OLDOBJ;
5837         return SWIG_OK;
5838       }
5839     }
5840   }
5841   return SWIG_TypeError;
5842 }
5843
5844
5845
5846
5847
5848 SWIGINTERN int
5849 SWIG_AsVal_bool (PyObject *obj, bool *val)
5850 {
5851   int r;
5852   if (!PyBool_Check(obj))
5853     return SWIG_ERROR;
5854   r = PyObject_IsTrue(obj);
5855   if (r == -1)
5856     return SWIG_ERROR;
5857   if (val) *val = r ? true : false;
5858   return SWIG_OK;
5859 }
5860
5861 #ifdef __cplusplus
5862 extern "C" {
5863 #endif
5864 SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5865   PyObject *resultobj = 0;
5866   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5867   void *argp1 = 0 ;
5868   int res1 = 0 ;
5869   PyObject * obj0 = 0 ;
5870
5871   if (!PyArg_ParseTuple(args,(char *)"O:delete_SwigPyIterator",&obj0)) SWIG_fail;
5872   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
5873   if (!SWIG_IsOK(res1)) {
5874     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5875   }
5876   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5877   delete arg1;
5878   resultobj = SWIG_Py_Void();
5879   return resultobj;
5880 fail:
5881   return NULL;
5882 }
5883
5884
5885 SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5886   PyObject *resultobj = 0;
5887   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5888   void *argp1 = 0 ;
5889   int res1 = 0 ;
5890   PyObject * obj0 = 0 ;
5891   PyObject *result = 0 ;
5892
5893   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_value",&obj0)) SWIG_fail;
5894   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5895   if (!SWIG_IsOK(res1)) {
5896     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5897   }
5898   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5899   try {
5900     result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
5901   }
5902   catch(swig::stop_iteration &_e) {
5903     {
5904       (void)_e;
5905       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5906       SWIG_fail;
5907     }
5908   }
5909
5910   resultobj = result;
5911   return resultobj;
5912 fail:
5913   return NULL;
5914 }
5915
5916
5917 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5918   PyObject *resultobj = 0;
5919   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5920   size_t arg2 ;
5921   void *argp1 = 0 ;
5922   int res1 = 0 ;
5923   size_t val2 ;
5924   int ecode2 = 0 ;
5925   PyObject * obj0 = 0 ;
5926   PyObject * obj1 = 0 ;
5927   swig::SwigPyIterator *result = 0 ;
5928
5929   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_incr",&obj0,&obj1)) SWIG_fail;
5930   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5931   if (!SWIG_IsOK(res1)) {
5932     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5933   }
5934   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5935   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
5936   if (!SWIG_IsOK(ecode2)) {
5937     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
5938   }
5939   arg2 = static_cast< size_t >(val2);
5940   try {
5941     result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
5942   }
5943   catch(swig::stop_iteration &_e) {
5944     {
5945       (void)_e;
5946       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5947       SWIG_fail;
5948     }
5949   }
5950
5951   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5952   return resultobj;
5953 fail:
5954   return NULL;
5955 }
5956
5957
5958 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5959   PyObject *resultobj = 0;
5960   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5961   void *argp1 = 0 ;
5962   int res1 = 0 ;
5963   PyObject * obj0 = 0 ;
5964   swig::SwigPyIterator *result = 0 ;
5965
5966   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_incr",&obj0)) SWIG_fail;
5967   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5968   if (!SWIG_IsOK(res1)) {
5969     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5970   }
5971   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5972   try {
5973     result = (swig::SwigPyIterator *)(arg1)->incr();
5974   }
5975   catch(swig::stop_iteration &_e) {
5976     {
5977       (void)_e;
5978       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5979       SWIG_fail;
5980     }
5981   }
5982
5983   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
5984   return resultobj;
5985 fail:
5986   return NULL;
5987 }
5988
5989
5990 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
5991   Py_ssize_t argc;
5992   PyObject *argv[3] = {
5993     0
5994   };
5995   Py_ssize_t ii;
5996
5997   if (!PyTuple_Check(args)) SWIG_fail;
5998   argc = args ? PyObject_Length(args) : 0;
5999   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
6000     argv[ii] = PyTuple_GET_ITEM(args,ii);
6001   }
6002   if (argc == 1) {
6003     int _v;
6004     void *vptr = 0;
6005     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6006     _v = SWIG_CheckState(res);
6007     if (_v) {
6008       return _wrap_SwigPyIterator_incr__SWIG_1(self, args);
6009     }
6010   }
6011   if (argc == 2) {
6012     int _v;
6013     void *vptr = 0;
6014     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6015     _v = SWIG_CheckState(res);
6016     if (_v) {
6017       {
6018         int res = SWIG_AsVal_size_t(argv[1], NULL);
6019         _v = SWIG_CheckState(res);
6020       }
6021       if (_v) {
6022         return _wrap_SwigPyIterator_incr__SWIG_0(self, args);
6023       }
6024     }
6025   }
6026
6027 fail:
6028   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
6029     "  Possible C/C++ prototypes are:\n"
6030     "    swig::SwigPyIterator::incr(size_t)\n"
6031     "    swig::SwigPyIterator::incr()\n");
6032   return 0;
6033 }
6034
6035
6036 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6037   PyObject *resultobj = 0;
6038   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6039   size_t arg2 ;
6040   void *argp1 = 0 ;
6041   int res1 = 0 ;
6042   size_t val2 ;
6043   int ecode2 = 0 ;
6044   PyObject * obj0 = 0 ;
6045   PyObject * obj1 = 0 ;
6046   swig::SwigPyIterator *result = 0 ;
6047
6048   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_decr",&obj0,&obj1)) SWIG_fail;
6049   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6050   if (!SWIG_IsOK(res1)) {
6051     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6052   }
6053   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6054   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6055   if (!SWIG_IsOK(ecode2)) {
6056     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
6057   }
6058   arg2 = static_cast< size_t >(val2);
6059   try {
6060     result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
6061   }
6062   catch(swig::stop_iteration &_e) {
6063     {
6064       (void)_e;
6065       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6066       SWIG_fail;
6067     }
6068   }
6069
6070   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6071   return resultobj;
6072 fail:
6073   return NULL;
6074 }
6075
6076
6077 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6078   PyObject *resultobj = 0;
6079   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6080   void *argp1 = 0 ;
6081   int res1 = 0 ;
6082   PyObject * obj0 = 0 ;
6083   swig::SwigPyIterator *result = 0 ;
6084
6085   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_decr",&obj0)) SWIG_fail;
6086   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6087   if (!SWIG_IsOK(res1)) {
6088     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6089   }
6090   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6091   try {
6092     result = (swig::SwigPyIterator *)(arg1)->decr();
6093   }
6094   catch(swig::stop_iteration &_e) {
6095     {
6096       (void)_e;
6097       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6098       SWIG_fail;
6099     }
6100   }
6101
6102   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6103   return resultobj;
6104 fail:
6105   return NULL;
6106 }
6107
6108
6109 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
6110   Py_ssize_t argc;
6111   PyObject *argv[3] = {
6112     0
6113   };
6114   Py_ssize_t ii;
6115
6116   if (!PyTuple_Check(args)) SWIG_fail;
6117   argc = args ? PyObject_Length(args) : 0;
6118   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
6119     argv[ii] = PyTuple_GET_ITEM(args,ii);
6120   }
6121   if (argc == 1) {
6122     int _v;
6123     void *vptr = 0;
6124     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6125     _v = SWIG_CheckState(res);
6126     if (_v) {
6127       return _wrap_SwigPyIterator_decr__SWIG_1(self, args);
6128     }
6129   }
6130   if (argc == 2) {
6131     int _v;
6132     void *vptr = 0;
6133     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6134     _v = SWIG_CheckState(res);
6135     if (_v) {
6136       {
6137         int res = SWIG_AsVal_size_t(argv[1], NULL);
6138         _v = SWIG_CheckState(res);
6139       }
6140       if (_v) {
6141         return _wrap_SwigPyIterator_decr__SWIG_0(self, args);
6142       }
6143     }
6144   }
6145
6146 fail:
6147   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
6148     "  Possible C/C++ prototypes are:\n"
6149     "    swig::SwigPyIterator::decr(size_t)\n"
6150     "    swig::SwigPyIterator::decr()\n");
6151   return 0;
6152 }
6153
6154
6155 SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6156   PyObject *resultobj = 0;
6157   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6158   swig::SwigPyIterator *arg2 = 0 ;
6159   void *argp1 = 0 ;
6160   int res1 = 0 ;
6161   void *argp2 = 0 ;
6162   int res2 = 0 ;
6163   PyObject * obj0 = 0 ;
6164   PyObject * obj1 = 0 ;
6165   ptrdiff_t result;
6166
6167   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_distance",&obj0,&obj1)) SWIG_fail;
6168   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6169   if (!SWIG_IsOK(res1)) {
6170     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6171   }
6172   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6173   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
6174   if (!SWIG_IsOK(res2)) {
6175     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6176   }
6177   if (!argp2) {
6178     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6179   }
6180   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
6181   try {
6182     result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
6183   }
6184   catch(std::invalid_argument &_e) {
6185     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;
6186   }
6187
6188   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
6189   return resultobj;
6190 fail:
6191   return NULL;
6192 }
6193
6194
6195 SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6196   PyObject *resultobj = 0;
6197   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6198   swig::SwigPyIterator *arg2 = 0 ;
6199   void *argp1 = 0 ;
6200   int res1 = 0 ;
6201   void *argp2 = 0 ;
6202   int res2 = 0 ;
6203   PyObject * obj0 = 0 ;
6204   PyObject * obj1 = 0 ;
6205   bool result;
6206
6207   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_equal",&obj0,&obj1)) SWIG_fail;
6208   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6209   if (!SWIG_IsOK(res1)) {
6210     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6211   }
6212   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6213   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
6214   if (!SWIG_IsOK(res2)) {
6215     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6216   }
6217   if (!argp2) {
6218     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6219   }
6220   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
6221   try {
6222     result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
6223   }
6224   catch(std::invalid_argument &_e) {
6225     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;
6226   }
6227
6228   resultobj = SWIG_From_bool(static_cast< bool >(result));
6229   return resultobj;
6230 fail:
6231   return NULL;
6232 }
6233
6234
6235 SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6236   PyObject *resultobj = 0;
6237   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6238   void *argp1 = 0 ;
6239   int res1 = 0 ;
6240   PyObject * obj0 = 0 ;
6241   swig::SwigPyIterator *result = 0 ;
6242
6243   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_copy",&obj0)) SWIG_fail;
6244   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6245   if (!SWIG_IsOK(res1)) {
6246     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6247   }
6248   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6249   result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
6250   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
6251   return resultobj;
6252 fail:
6253   return NULL;
6254 }
6255
6256
6257 SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6258   PyObject *resultobj = 0;
6259   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6260   void *argp1 = 0 ;
6261   int res1 = 0 ;
6262   PyObject * obj0 = 0 ;
6263   PyObject *result = 0 ;
6264
6265   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_next",&obj0)) SWIG_fail;
6266   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6267   if (!SWIG_IsOK(res1)) {
6268     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6269   }
6270   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6271   try {
6272     result = (PyObject *)(arg1)->next();
6273   }
6274   catch(swig::stop_iteration &_e) {
6275     {
6276       (void)_e;
6277       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6278       SWIG_fail;
6279     }
6280   }
6281
6282   resultobj = result;
6283   return resultobj;
6284 fail:
6285   return NULL;
6286 }
6287
6288
6289 SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6290   PyObject *resultobj = 0;
6291   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6292   void *argp1 = 0 ;
6293   int res1 = 0 ;
6294   PyObject * obj0 = 0 ;
6295   PyObject *result = 0 ;
6296
6297   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator___next__",&obj0)) SWIG_fail;
6298   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6299   if (!SWIG_IsOK(res1)) {
6300     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6301   }
6302   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6303   try {
6304     result = (PyObject *)(arg1)->__next__();
6305   }
6306   catch(swig::stop_iteration &_e) {
6307     {
6308       (void)_e;
6309       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6310       SWIG_fail;
6311     }
6312   }
6313
6314   resultobj = result;
6315   return resultobj;
6316 fail:
6317   return NULL;
6318 }
6319
6320
6321 SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6322   PyObject *resultobj = 0;
6323   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6324   void *argp1 = 0 ;
6325   int res1 = 0 ;
6326   PyObject * obj0 = 0 ;
6327   PyObject *result = 0 ;
6328
6329   if (!PyArg_ParseTuple(args,(char *)"O:SwigPyIterator_previous",&obj0)) SWIG_fail;
6330   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6331   if (!SWIG_IsOK(res1)) {
6332     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6333   }
6334   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6335   try {
6336     result = (PyObject *)(arg1)->previous();
6337   }
6338   catch(swig::stop_iteration &_e) {
6339     {
6340       (void)_e;
6341       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6342       SWIG_fail;
6343     }
6344   }
6345
6346   resultobj = result;
6347   return resultobj;
6348 fail:
6349   return NULL;
6350 }
6351
6352
6353 SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6354   PyObject *resultobj = 0;
6355   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6356   ptrdiff_t arg2 ;
6357   void *argp1 = 0 ;
6358   int res1 = 0 ;
6359   ptrdiff_t val2 ;
6360   int ecode2 = 0 ;
6361   PyObject * obj0 = 0 ;
6362   PyObject * obj1 = 0 ;
6363   swig::SwigPyIterator *result = 0 ;
6364
6365   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator_advance",&obj0,&obj1)) SWIG_fail;
6366   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6367   if (!SWIG_IsOK(res1)) {
6368     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6369   }
6370   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6371   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6372   if (!SWIG_IsOK(ecode2)) {
6373     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
6374   }
6375   arg2 = static_cast< ptrdiff_t >(val2);
6376   try {
6377     result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
6378   }
6379   catch(swig::stop_iteration &_e) {
6380     {
6381       (void)_e;
6382       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6383       SWIG_fail;
6384     }
6385   }
6386
6387   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6388   return resultobj;
6389 fail:
6390   return NULL;
6391 }
6392
6393
6394 SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6395   PyObject *resultobj = 0;
6396   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6397   swig::SwigPyIterator *arg2 = 0 ;
6398   void *argp1 = 0 ;
6399   int res1 = 0 ;
6400   void *argp2 = 0 ;
6401   int res2 = 0 ;
6402   PyObject * obj0 = 0 ;
6403   PyObject * obj1 = 0 ;
6404   bool result;
6405
6406   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___eq__",&obj0,&obj1)) SWIG_fail;
6407   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6408   if (!SWIG_IsOK(res1)) {
6409     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6410   }
6411   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6412   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
6413   if (!SWIG_IsOK(res2)) {
6414     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6415   }
6416   if (!argp2) {
6417     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6418   }
6419   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
6420   result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
6421   resultobj = SWIG_From_bool(static_cast< bool >(result));
6422   return resultobj;
6423 fail:
6424   return NULL;
6425 }
6426
6427
6428 SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6429   PyObject *resultobj = 0;
6430   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6431   swig::SwigPyIterator *arg2 = 0 ;
6432   void *argp1 = 0 ;
6433   int res1 = 0 ;
6434   void *argp2 = 0 ;
6435   int res2 = 0 ;
6436   PyObject * obj0 = 0 ;
6437   PyObject * obj1 = 0 ;
6438   bool result;
6439
6440   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___ne__",&obj0,&obj1)) SWIG_fail;
6441   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6442   if (!SWIG_IsOK(res1)) {
6443     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6444   }
6445   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6446   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
6447   if (!SWIG_IsOK(res2)) {
6448     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6449   }
6450   if (!argp2) {
6451     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6452   }
6453   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
6454   result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
6455   resultobj = SWIG_From_bool(static_cast< bool >(result));
6456   return resultobj;
6457 fail:
6458   return NULL;
6459 }
6460
6461
6462 SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6463   PyObject *resultobj = 0;
6464   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6465   ptrdiff_t arg2 ;
6466   void *argp1 = 0 ;
6467   int res1 = 0 ;
6468   ptrdiff_t val2 ;
6469   int ecode2 = 0 ;
6470   PyObject * obj0 = 0 ;
6471   PyObject * obj1 = 0 ;
6472   swig::SwigPyIterator *result = 0 ;
6473
6474   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___iadd__",&obj0,&obj1)) SWIG_fail;
6475   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
6476   if (!SWIG_IsOK(res1)) {
6477     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6478   }
6479   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6480   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6481   if (!SWIG_IsOK(ecode2)) {
6482     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
6483   }
6484   arg2 = static_cast< ptrdiff_t >(val2);
6485   try {
6486     result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
6487   }
6488   catch(swig::stop_iteration &_e) {
6489     {
6490       (void)_e;
6491       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6492       SWIG_fail;
6493     }
6494   }
6495
6496   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
6497   return resultobj;
6498 fail:
6499   return NULL;
6500 }
6501
6502
6503 SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6504   PyObject *resultobj = 0;
6505   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6506   ptrdiff_t arg2 ;
6507   void *argp1 = 0 ;
6508   int res1 = 0 ;
6509   ptrdiff_t val2 ;
6510   int ecode2 = 0 ;
6511   PyObject * obj0 = 0 ;
6512   PyObject * obj1 = 0 ;
6513   swig::SwigPyIterator *result = 0 ;
6514
6515   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___isub__",&obj0,&obj1)) SWIG_fail;
6516   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
6517   if (!SWIG_IsOK(res1)) {
6518     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
6519   }
6520   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6521   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6522   if (!SWIG_IsOK(ecode2)) {
6523     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
6524   }
6525   arg2 = static_cast< ptrdiff_t >(val2);
6526   try {
6527     result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
6528   }
6529   catch(swig::stop_iteration &_e) {
6530     {
6531       (void)_e;
6532       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6533       SWIG_fail;
6534     }
6535   }
6536
6537   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
6538   return resultobj;
6539 fail:
6540   return NULL;
6541 }
6542
6543
6544 SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6545   PyObject *resultobj = 0;
6546   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6547   ptrdiff_t arg2 ;
6548   void *argp1 = 0 ;
6549   int res1 = 0 ;
6550   ptrdiff_t val2 ;
6551   int ecode2 = 0 ;
6552   PyObject * obj0 = 0 ;
6553   PyObject * obj1 = 0 ;
6554   swig::SwigPyIterator *result = 0 ;
6555
6556   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___add__",&obj0,&obj1)) SWIG_fail;
6557   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6558   if (!SWIG_IsOK(res1)) {
6559     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6560   }
6561   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6562   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6563   if (!SWIG_IsOK(ecode2)) {
6564     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
6565   }
6566   arg2 = static_cast< ptrdiff_t >(val2);
6567   try {
6568     result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
6569   }
6570   catch(swig::stop_iteration &_e) {
6571     {
6572       (void)_e;
6573       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6574       SWIG_fail;
6575     }
6576   }
6577
6578   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
6579   return resultobj;
6580 fail:
6581   return NULL;
6582 }
6583
6584
6585 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6586   PyObject *resultobj = 0;
6587   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6588   ptrdiff_t arg2 ;
6589   void *argp1 = 0 ;
6590   int res1 = 0 ;
6591   ptrdiff_t val2 ;
6592   int ecode2 = 0 ;
6593   PyObject * obj0 = 0 ;
6594   PyObject * obj1 = 0 ;
6595   swig::SwigPyIterator *result = 0 ;
6596
6597   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
6598   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6599   if (!SWIG_IsOK(res1)) {
6600     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6601   }
6602   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6603   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6604   if (!SWIG_IsOK(ecode2)) {
6605     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
6606   }
6607   arg2 = static_cast< ptrdiff_t >(val2);
6608   try {
6609     result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
6610   }
6611   catch(swig::stop_iteration &_e) {
6612     {
6613       (void)_e;
6614       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
6615       SWIG_fail;
6616     }
6617   }
6618
6619   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
6620   return resultobj;
6621 fail:
6622   return NULL;
6623 }
6624
6625
6626 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6627   PyObject *resultobj = 0;
6628   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
6629   swig::SwigPyIterator *arg2 = 0 ;
6630   void *argp1 = 0 ;
6631   int res1 = 0 ;
6632   void *argp2 = 0 ;
6633   int res2 = 0 ;
6634   PyObject * obj0 = 0 ;
6635   PyObject * obj1 = 0 ;
6636   ptrdiff_t result;
6637
6638   if (!PyArg_ParseTuple(args,(char *)"OO:SwigPyIterator___sub__",&obj0,&obj1)) SWIG_fail;
6639   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
6640   if (!SWIG_IsOK(res1)) {
6641     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
6642   }
6643   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
6644   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
6645   if (!SWIG_IsOK(res2)) {
6646     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6647   }
6648   if (!argp2) {
6649     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
6650   }
6651   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
6652   result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
6653   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
6654   return resultobj;
6655 fail:
6656   return NULL;
6657 }
6658
6659
6660 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
6661   Py_ssize_t argc;
6662   PyObject *argv[3] = {
6663     0
6664   };
6665   Py_ssize_t ii;
6666
6667   if (!PyTuple_Check(args)) SWIG_fail;
6668   argc = args ? PyObject_Length(args) : 0;
6669   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
6670     argv[ii] = PyTuple_GET_ITEM(args,ii);
6671   }
6672   if (argc == 2) {
6673     int _v;
6674     void *vptr = 0;
6675     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6676     _v = SWIG_CheckState(res);
6677     if (_v) {
6678       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
6679       _v = SWIG_CheckState(res);
6680       if (_v) {
6681         return _wrap_SwigPyIterator___sub____SWIG_1(self, args);
6682       }
6683     }
6684   }
6685   if (argc == 2) {
6686     int _v;
6687     void *vptr = 0;
6688     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
6689     _v = SWIG_CheckState(res);
6690     if (_v) {
6691       {
6692         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6693         _v = SWIG_CheckState(res);
6694       }
6695       if (_v) {
6696         return _wrap_SwigPyIterator___sub____SWIG_0(self, args);
6697       }
6698     }
6699   }
6700
6701 fail:
6702   Py_INCREF(Py_NotImplemented);
6703   return Py_NotImplemented;
6704 }
6705
6706
6707 SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6708   PyObject *obj;
6709   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
6710   SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
6711   return SWIG_Py_Void();
6712 }
6713
6714 SWIGINTERN PyObject *_wrap_VectorHexas_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6715   PyObject *resultobj = 0;
6716   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6717   PyObject **arg2 = (PyObject **) 0 ;
6718   void *argp1 = 0 ;
6719   int res1 = 0 ;
6720   PyObject * obj0 = 0 ;
6721   swig::SwigPyIterator *result = 0 ;
6722
6723   arg2 = &obj0;
6724   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_iterator",&obj0)) SWIG_fail;
6725   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6726   if (!SWIG_IsOK(res1)) {
6727     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_iterator" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6728   }
6729   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6730   result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Hexa_Sm__Sg__iterator(arg1,arg2);
6731   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
6732   return resultobj;
6733 fail:
6734   return NULL;
6735 }
6736
6737
6738 SWIGINTERN PyObject *_wrap_VectorHexas___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6739   PyObject *resultobj = 0;
6740   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6741   void *argp1 = 0 ;
6742   int res1 = 0 ;
6743   PyObject * obj0 = 0 ;
6744   bool result;
6745
6746   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___nonzero__",&obj0)) SWIG_fail;
6747   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6748   if (!SWIG_IsOK(res1)) {
6749     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6750   }
6751   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6752   result = (bool)std_vector_Sl_Hex_Hexa_Sm__Sg____nonzero__((std::vector< Hex::Hexa * > const *)arg1);
6753   resultobj = SWIG_From_bool(static_cast< bool >(result));
6754   return resultobj;
6755 fail:
6756   return NULL;
6757 }
6758
6759
6760 SWIGINTERN PyObject *_wrap_VectorHexas___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6761   PyObject *resultobj = 0;
6762   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6763   void *argp1 = 0 ;
6764   int res1 = 0 ;
6765   PyObject * obj0 = 0 ;
6766   bool result;
6767
6768   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___bool__",&obj0)) SWIG_fail;
6769   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6770   if (!SWIG_IsOK(res1)) {
6771     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___bool__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6772   }
6773   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6774   result = (bool)std_vector_Sl_Hex_Hexa_Sm__Sg____bool__((std::vector< Hex::Hexa * > const *)arg1);
6775   resultobj = SWIG_From_bool(static_cast< bool >(result));
6776   return resultobj;
6777 fail:
6778   return NULL;
6779 }
6780
6781
6782 SWIGINTERN PyObject *_wrap_VectorHexas___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6783   PyObject *resultobj = 0;
6784   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6785   void *argp1 = 0 ;
6786   int res1 = 0 ;
6787   PyObject * obj0 = 0 ;
6788   std::vector< Hex::Hexa * >::size_type result;
6789
6790   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas___len__",&obj0)) SWIG_fail;
6791   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6792   if (!SWIG_IsOK(res1)) {
6793     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___len__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
6794   }
6795   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6796   result = std_vector_Sl_Hex_Hexa_Sm__Sg____len__((std::vector< Hex::Hexa * > const *)arg1);
6797   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
6798   return resultobj;
6799 fail:
6800   return NULL;
6801 }
6802
6803
6804 SWIGINTERN PyObject *_wrap_VectorHexas___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6805   PyObject *resultobj = 0;
6806   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6807   std::vector< Hex::Hexa * >::difference_type arg2 ;
6808   std::vector< Hex::Hexa * >::difference_type arg3 ;
6809   void *argp1 = 0 ;
6810   int res1 = 0 ;
6811   ptrdiff_t val2 ;
6812   int ecode2 = 0 ;
6813   ptrdiff_t val3 ;
6814   int ecode3 = 0 ;
6815   PyObject * obj0 = 0 ;
6816   PyObject * obj1 = 0 ;
6817   PyObject * obj2 = 0 ;
6818   std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *result = 0 ;
6819
6820   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
6821   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6822   if (!SWIG_IsOK(res1)) {
6823     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6824   }
6825   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6826   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6827   if (!SWIG_IsOK(ecode2)) {
6828     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6829   }
6830   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
6831   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6832   if (!SWIG_IsOK(ecode3)) {
6833     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6834   }
6835   arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
6836   try {
6837     result = (std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *)std_vector_Sl_Hex_Hexa_Sm__Sg____getslice__(arg1,arg2,arg3);
6838   }
6839   catch(std::out_of_range &_e) {
6840     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6841   }
6842   catch(std::invalid_argument &_e) {
6843     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6844   }
6845
6846   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_OWN |  0 );
6847   return resultobj;
6848 fail:
6849   return NULL;
6850 }
6851
6852
6853 SWIGINTERN PyObject *_wrap_VectorHexas___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6854   PyObject *resultobj = 0;
6855   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6856   std::vector< Hex::Hexa * >::difference_type arg2 ;
6857   std::vector< Hex::Hexa * >::difference_type arg3 ;
6858   void *argp1 = 0 ;
6859   int res1 = 0 ;
6860   ptrdiff_t val2 ;
6861   int ecode2 = 0 ;
6862   ptrdiff_t val3 ;
6863   int ecode3 = 0 ;
6864   PyObject * obj0 = 0 ;
6865   PyObject * obj1 = 0 ;
6866   PyObject * obj2 = 0 ;
6867
6868   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
6869   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6870   if (!SWIG_IsOK(res1)) {
6871     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6872   }
6873   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6874   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6875   if (!SWIG_IsOK(ecode2)) {
6876     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6877   }
6878   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
6879   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6880   if (!SWIG_IsOK(ecode3)) {
6881     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6882   }
6883   arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
6884   try {
6885     std_vector_Sl_Hex_Hexa_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
6886   }
6887   catch(std::out_of_range &_e) {
6888     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6889   }
6890   catch(std::invalid_argument &_e) {
6891     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6892   }
6893
6894   resultobj = SWIG_Py_Void();
6895   return resultobj;
6896 fail:
6897   return NULL;
6898 }
6899
6900
6901 SWIGINTERN PyObject *_wrap_VectorHexas___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6902   PyObject *resultobj = 0;
6903   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
6904   std::vector< Hex::Hexa * >::difference_type arg2 ;
6905   std::vector< Hex::Hexa * >::difference_type arg3 ;
6906   std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *arg4 = 0 ;
6907   void *argp1 = 0 ;
6908   int res1 = 0 ;
6909   ptrdiff_t val2 ;
6910   int ecode2 = 0 ;
6911   ptrdiff_t val3 ;
6912   int ecode3 = 0 ;
6913   int res4 = SWIG_OLDOBJ ;
6914   PyObject * obj0 = 0 ;
6915   PyObject * obj1 = 0 ;
6916   PyObject * obj2 = 0 ;
6917   PyObject * obj3 = 0 ;
6918
6919   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6920   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
6921   if (!SWIG_IsOK(res1)) {
6922     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
6923   }
6924   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
6925   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
6926   if (!SWIG_IsOK(ecode2)) {
6927     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6928   }
6929   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
6930   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
6931   if (!SWIG_IsOK(ecode3)) {
6932     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
6933   }
6934   arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
6935   {
6936     std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
6937     res4 = swig::asptr(obj3, &ptr);
6938     if (!SWIG_IsOK(res4)) {
6939       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
6940     }
6941     if (!ptr) {
6942       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 &""'");
6943     }
6944     arg4 = ptr;
6945   }
6946   try {
6947     std_vector_Sl_Hex_Hexa_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)*arg4);
6948   }
6949   catch(std::out_of_range &_e) {
6950     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
6951   }
6952   catch(std::invalid_argument &_e) {
6953     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
6954   }
6955
6956   resultobj = SWIG_Py_Void();
6957   if (SWIG_IsNewObj(res4)) delete arg4;
6958   return resultobj;
6959 fail:
6960   if (SWIG_IsNewObj(res4)) delete arg4;
6961   return NULL;
6962 }
6963
6964
6965 SWIGINTERN PyObject *_wrap_VectorHexas___setslice__(PyObject *self, PyObject *args) {
6966   Py_ssize_t argc;
6967   PyObject *argv[5] = {
6968     0
6969   };
6970   Py_ssize_t ii;
6971
6972   if (!PyTuple_Check(args)) SWIG_fail;
6973   argc = args ? PyObject_Length(args) : 0;
6974   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
6975     argv[ii] = PyTuple_GET_ITEM(args,ii);
6976   }
6977   if (argc == 3) {
6978     int _v;
6979     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
6980     _v = SWIG_CheckState(res);
6981     if (_v) {
6982       {
6983         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
6984         _v = SWIG_CheckState(res);
6985       }
6986       if (_v) {
6987         {
6988           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
6989           _v = SWIG_CheckState(res);
6990         }
6991         if (_v) {
6992           return _wrap_VectorHexas___setslice____SWIG_0(self, args);
6993         }
6994       }
6995     }
6996   }
6997   if (argc == 4) {
6998     int _v;
6999     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7000     _v = SWIG_CheckState(res);
7001     if (_v) {
7002       {
7003         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
7004         _v = SWIG_CheckState(res);
7005       }
7006       if (_v) {
7007         {
7008           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
7009           _v = SWIG_CheckState(res);
7010         }
7011         if (_v) {
7012           int res = swig::asptr(argv[3], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7013           _v = SWIG_CheckState(res);
7014           if (_v) {
7015             return _wrap_VectorHexas___setslice____SWIG_1(self, args);
7016           }
7017         }
7018       }
7019     }
7020   }
7021
7022 fail:
7023   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas___setslice__'.\n"
7024     "  Possible C/C++ prototypes are:\n"
7025     "    std::vector< Hex::Hexa * >::__setslice__(std::vector< Hex::Hexa * >::difference_type,std::vector< Hex::Hexa * >::difference_type)\n"
7026     "    std::vector< Hex::Hexa * >::__setslice__(std::vector< Hex::Hexa * >::difference_type,std::vector< Hex::Hexa * >::difference_type,std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)\n");
7027   return 0;
7028 }
7029
7030
7031 SWIGINTERN PyObject *_wrap_VectorHexas___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7032   PyObject *resultobj = 0;
7033   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7034   std::vector< Hex::Hexa * >::difference_type arg2 ;
7035   std::vector< Hex::Hexa * >::difference_type arg3 ;
7036   void *argp1 = 0 ;
7037   int res1 = 0 ;
7038   ptrdiff_t val2 ;
7039   int ecode2 = 0 ;
7040   ptrdiff_t val3 ;
7041   int ecode3 = 0 ;
7042   PyObject * obj0 = 0 ;
7043   PyObject * obj1 = 0 ;
7044   PyObject * obj2 = 0 ;
7045
7046   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
7047   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7048   if (!SWIG_IsOK(res1)) {
7049     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7050   }
7051   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7052   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7053   if (!SWIG_IsOK(ecode2)) {
7054     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
7055   }
7056   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
7057   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
7058   if (!SWIG_IsOK(ecode3)) {
7059     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
7060   }
7061   arg3 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val3);
7062   try {
7063     std_vector_Sl_Hex_Hexa_Sm__Sg____delslice__(arg1,arg2,arg3);
7064   }
7065   catch(std::out_of_range &_e) {
7066     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7067   }
7068   catch(std::invalid_argument &_e) {
7069     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7070   }
7071
7072   resultobj = SWIG_Py_Void();
7073   return resultobj;
7074 fail:
7075   return NULL;
7076 }
7077
7078
7079 SWIGINTERN PyObject *_wrap_VectorHexas___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7080   PyObject *resultobj = 0;
7081   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7082   std::vector< Hex::Hexa * >::difference_type arg2 ;
7083   void *argp1 = 0 ;
7084   int res1 = 0 ;
7085   ptrdiff_t val2 ;
7086   int ecode2 = 0 ;
7087   PyObject * obj0 = 0 ;
7088   PyObject * obj1 = 0 ;
7089
7090   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___delitem__",&obj0,&obj1)) SWIG_fail;
7091   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7092   if (!SWIG_IsOK(res1)) {
7093     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7094   }
7095   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7096   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7097   if (!SWIG_IsOK(ecode2)) {
7098     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
7099   }
7100   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
7101   try {
7102     std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_0(arg1,arg2);
7103   }
7104   catch(std::out_of_range &_e) {
7105     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7106   }
7107   catch(std::invalid_argument &_e) {
7108     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7109   }
7110
7111   resultobj = SWIG_Py_Void();
7112   return resultobj;
7113 fail:
7114   return NULL;
7115 }
7116
7117
7118 SWIGINTERN PyObject *_wrap_VectorHexas___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7119   PyObject *resultobj = 0;
7120   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7121   PySliceObject *arg2 = (PySliceObject *) 0 ;
7122   void *argp1 = 0 ;
7123   int res1 = 0 ;
7124   PyObject * obj0 = 0 ;
7125   PyObject * obj1 = 0 ;
7126   std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *result = 0 ;
7127
7128   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___getitem__",&obj0,&obj1)) SWIG_fail;
7129   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7130   if (!SWIG_IsOK(res1)) {
7131     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7132   }
7133   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7134   {
7135     if (!PySlice_Check(obj1)) {
7136       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
7137     }
7138     arg2 = (PySliceObject *) obj1;
7139   }
7140   try {
7141     result = (std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *)std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_0(arg1,arg2);
7142   }
7143   catch(std::out_of_range &_e) {
7144     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7145   }
7146   catch(std::invalid_argument &_e) {
7147     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7148   }
7149
7150   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_OWN |  0 );
7151   return resultobj;
7152 fail:
7153   return NULL;
7154 }
7155
7156
7157 SWIGINTERN PyObject *_wrap_VectorHexas___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7158   PyObject *resultobj = 0;
7159   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7160   PySliceObject *arg2 = (PySliceObject *) 0 ;
7161   std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *arg3 = 0 ;
7162   void *argp1 = 0 ;
7163   int res1 = 0 ;
7164   int res3 = SWIG_OLDOBJ ;
7165   PyObject * obj0 = 0 ;
7166   PyObject * obj1 = 0 ;
7167   PyObject * obj2 = 0 ;
7168
7169   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
7170   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7171   if (!SWIG_IsOK(res1)) {
7172     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7173   }
7174   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7175   {
7176     if (!PySlice_Check(obj1)) {
7177       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
7178     }
7179     arg2 = (PySliceObject *) obj1;
7180   }
7181   {
7182     std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
7183     res3 = swig::asptr(obj2, &ptr);
7184     if (!SWIG_IsOK(res3)) {
7185       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
7186     }
7187     if (!ptr) {
7188       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &""'");
7189     }
7190     arg3 = ptr;
7191   }
7192   try {
7193     std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)*arg3);
7194   }
7195   catch(std::out_of_range &_e) {
7196     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7197   }
7198   catch(std::invalid_argument &_e) {
7199     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7200   }
7201
7202   resultobj = SWIG_Py_Void();
7203   if (SWIG_IsNewObj(res3)) delete arg3;
7204   return resultobj;
7205 fail:
7206   if (SWIG_IsNewObj(res3)) delete arg3;
7207   return NULL;
7208 }
7209
7210
7211 SWIGINTERN PyObject *_wrap_VectorHexas___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7212   PyObject *resultobj = 0;
7213   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7214   PySliceObject *arg2 = (PySliceObject *) 0 ;
7215   void *argp1 = 0 ;
7216   int res1 = 0 ;
7217   PyObject * obj0 = 0 ;
7218   PyObject * obj1 = 0 ;
7219
7220   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___setitem__",&obj0,&obj1)) SWIG_fail;
7221   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7222   if (!SWIG_IsOK(res1)) {
7223     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7224   }
7225   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7226   {
7227     if (!PySlice_Check(obj1)) {
7228       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
7229     }
7230     arg2 = (PySliceObject *) obj1;
7231   }
7232   try {
7233     std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_1(arg1,arg2);
7234   }
7235   catch(std::out_of_range &_e) {
7236     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7237   }
7238   catch(std::invalid_argument &_e) {
7239     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7240   }
7241
7242   resultobj = SWIG_Py_Void();
7243   return resultobj;
7244 fail:
7245   return NULL;
7246 }
7247
7248
7249 SWIGINTERN PyObject *_wrap_VectorHexas___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7250   PyObject *resultobj = 0;
7251   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7252   PySliceObject *arg2 = (PySliceObject *) 0 ;
7253   void *argp1 = 0 ;
7254   int res1 = 0 ;
7255   PyObject * obj0 = 0 ;
7256   PyObject * obj1 = 0 ;
7257
7258   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___delitem__",&obj0,&obj1)) SWIG_fail;
7259   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7260   if (!SWIG_IsOK(res1)) {
7261     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7262   }
7263   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7264   {
7265     if (!PySlice_Check(obj1)) {
7266       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
7267     }
7268     arg2 = (PySliceObject *) obj1;
7269   }
7270   try {
7271     std_vector_Sl_Hex_Hexa_Sm__Sg____delitem____SWIG_1(arg1,arg2);
7272   }
7273   catch(std::out_of_range &_e) {
7274     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7275   }
7276   catch(std::invalid_argument &_e) {
7277     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
7278   }
7279
7280   resultobj = SWIG_Py_Void();
7281   return resultobj;
7282 fail:
7283   return NULL;
7284 }
7285
7286
7287 SWIGINTERN PyObject *_wrap_VectorHexas___delitem__(PyObject *self, PyObject *args) {
7288   Py_ssize_t argc;
7289   PyObject *argv[3] = {
7290     0
7291   };
7292   Py_ssize_t ii;
7293
7294   if (!PyTuple_Check(args)) SWIG_fail;
7295   argc = args ? PyObject_Length(args) : 0;
7296   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
7297     argv[ii] = PyTuple_GET_ITEM(args,ii);
7298   }
7299   if (argc == 2) {
7300     int _v;
7301     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7302     _v = SWIG_CheckState(res);
7303     if (_v) {
7304       {
7305         _v = PySlice_Check(argv[1]);
7306       }
7307       if (_v) {
7308         return _wrap_VectorHexas___delitem____SWIG_1(self, args);
7309       }
7310     }
7311   }
7312   if (argc == 2) {
7313     int _v;
7314     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7315     _v = SWIG_CheckState(res);
7316     if (_v) {
7317       {
7318         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
7319         _v = SWIG_CheckState(res);
7320       }
7321       if (_v) {
7322         return _wrap_VectorHexas___delitem____SWIG_0(self, args);
7323       }
7324     }
7325   }
7326
7327 fail:
7328   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas___delitem__'.\n"
7329     "  Possible C/C++ prototypes are:\n"
7330     "    std::vector< Hex::Hexa * >::__delitem__(std::vector< Hex::Hexa * >::difference_type)\n"
7331     "    std::vector< Hex::Hexa * >::__delitem__(PySliceObject *)\n");
7332   return 0;
7333 }
7334
7335
7336 SWIGINTERN PyObject *_wrap_VectorHexas___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7337   PyObject *resultobj = 0;
7338   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7339   std::vector< Hex::Hexa * >::difference_type arg2 ;
7340   void *argp1 = 0 ;
7341   int res1 = 0 ;
7342   ptrdiff_t val2 ;
7343   int ecode2 = 0 ;
7344   PyObject * obj0 = 0 ;
7345   PyObject * obj1 = 0 ;
7346   std::vector< Hex::Hexa * >::value_type result;
7347
7348   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas___getitem__",&obj0,&obj1)) SWIG_fail;
7349   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7350   if (!SWIG_IsOK(res1)) {
7351     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7352   }
7353   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7354   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7355   if (!SWIG_IsOK(ecode2)) {
7356     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
7357   }
7358   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
7359   try {
7360     result = (std::vector< Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg____getitem____SWIG_1(arg1,arg2);
7361   }
7362   catch(std::out_of_range &_e) {
7363     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7364   }
7365
7366   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
7367   return resultobj;
7368 fail:
7369   return NULL;
7370 }
7371
7372
7373 SWIGINTERN PyObject *_wrap_VectorHexas___getitem__(PyObject *self, PyObject *args) {
7374   Py_ssize_t argc;
7375   PyObject *argv[3] = {
7376     0
7377   };
7378   Py_ssize_t ii;
7379
7380   if (!PyTuple_Check(args)) SWIG_fail;
7381   argc = args ? PyObject_Length(args) : 0;
7382   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
7383     argv[ii] = PyTuple_GET_ITEM(args,ii);
7384   }
7385   if (argc == 2) {
7386     int _v;
7387     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7388     _v = SWIG_CheckState(res);
7389     if (_v) {
7390       {
7391         _v = PySlice_Check(argv[1]);
7392       }
7393       if (_v) {
7394         return _wrap_VectorHexas___getitem____SWIG_0(self, args);
7395       }
7396     }
7397   }
7398   if (argc == 2) {
7399     int _v;
7400     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7401     _v = SWIG_CheckState(res);
7402     if (_v) {
7403       {
7404         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
7405         _v = SWIG_CheckState(res);
7406       }
7407       if (_v) {
7408         return _wrap_VectorHexas___getitem____SWIG_1(self, args);
7409       }
7410     }
7411   }
7412
7413 fail:
7414   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas___getitem__'.\n"
7415     "  Possible C/C++ prototypes are:\n"
7416     "    std::vector< Hex::Hexa * >::__getitem__(PySliceObject *)\n"
7417     "    std::vector< Hex::Hexa * >::__getitem__(std::vector< Hex::Hexa * >::difference_type)\n");
7418   return 0;
7419 }
7420
7421
7422 SWIGINTERN PyObject *_wrap_VectorHexas___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7423   PyObject *resultobj = 0;
7424   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7425   std::vector< Hex::Hexa * >::difference_type arg2 ;
7426   std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
7427   void *argp1 = 0 ;
7428   int res1 = 0 ;
7429   ptrdiff_t val2 ;
7430   int ecode2 = 0 ;
7431   void *argp3 = 0 ;
7432   int res3 = 0 ;
7433   PyObject * obj0 = 0 ;
7434   PyObject * obj1 = 0 ;
7435   PyObject * obj2 = 0 ;
7436
7437   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
7438   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7439   if (!SWIG_IsOK(res1)) {
7440     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7441   }
7442   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7443   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
7444   if (!SWIG_IsOK(ecode2)) {
7445     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::difference_type""'");
7446   }
7447   arg2 = static_cast< std::vector< Hex::Hexa * >::difference_type >(val2);
7448   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
7449   if (!SWIG_IsOK(res3)) {
7450     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
7451   }
7452   arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
7453   try {
7454     std_vector_Sl_Hex_Hexa_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
7455   }
7456   catch(std::out_of_range &_e) {
7457     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7458   }
7459
7460   resultobj = SWIG_Py_Void();
7461   return resultobj;
7462 fail:
7463   return NULL;
7464 }
7465
7466
7467 SWIGINTERN PyObject *_wrap_VectorHexas___setitem__(PyObject *self, PyObject *args) {
7468   Py_ssize_t argc;
7469   PyObject *argv[4] = {
7470     0
7471   };
7472   Py_ssize_t ii;
7473
7474   if (!PyTuple_Check(args)) SWIG_fail;
7475   argc = args ? PyObject_Length(args) : 0;
7476   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
7477     argv[ii] = PyTuple_GET_ITEM(args,ii);
7478   }
7479   if (argc == 2) {
7480     int _v;
7481     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7482     _v = SWIG_CheckState(res);
7483     if (_v) {
7484       {
7485         _v = PySlice_Check(argv[1]);
7486       }
7487       if (_v) {
7488         return _wrap_VectorHexas___setitem____SWIG_1(self, args);
7489       }
7490     }
7491   }
7492   if (argc == 3) {
7493     int _v;
7494     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7495     _v = SWIG_CheckState(res);
7496     if (_v) {
7497       {
7498         _v = PySlice_Check(argv[1]);
7499       }
7500       if (_v) {
7501         int res = swig::asptr(argv[2], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7502         _v = SWIG_CheckState(res);
7503         if (_v) {
7504           return _wrap_VectorHexas___setitem____SWIG_0(self, args);
7505         }
7506       }
7507     }
7508   }
7509   if (argc == 3) {
7510     int _v;
7511     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
7512     _v = SWIG_CheckState(res);
7513     if (_v) {
7514       {
7515         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
7516         _v = SWIG_CheckState(res);
7517       }
7518       if (_v) {
7519         void *vptr = 0;
7520         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Hexa, 0);
7521         _v = SWIG_CheckState(res);
7522         if (_v) {
7523           return _wrap_VectorHexas___setitem____SWIG_2(self, args);
7524         }
7525       }
7526     }
7527   }
7528
7529 fail:
7530   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas___setitem__'.\n"
7531     "  Possible C/C++ prototypes are:\n"
7532     "    std::vector< Hex::Hexa * >::__setitem__(PySliceObject *,std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > const &)\n"
7533     "    std::vector< Hex::Hexa * >::__setitem__(PySliceObject *)\n"
7534     "    std::vector< Hex::Hexa * >::__setitem__(std::vector< Hex::Hexa * >::difference_type,std::vector< Hex::Hexa * >::value_type)\n");
7535   return 0;
7536 }
7537
7538
7539 SWIGINTERN PyObject *_wrap_VectorHexas_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7540   PyObject *resultobj = 0;
7541   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7542   void *argp1 = 0 ;
7543   int res1 = 0 ;
7544   PyObject * obj0 = 0 ;
7545   std::vector< Hex::Hexa * >::value_type result;
7546
7547   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop",&obj0)) SWIG_fail;
7548   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7549   if (!SWIG_IsOK(res1)) {
7550     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7551   }
7552   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7553   try {
7554     result = (std::vector< Hex::Hexa * >::value_type)std_vector_Sl_Hex_Hexa_Sm__Sg__pop(arg1);
7555   }
7556   catch(std::out_of_range &_e) {
7557     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
7558   }
7559
7560   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
7561   return resultobj;
7562 fail:
7563   return NULL;
7564 }
7565
7566
7567 SWIGINTERN PyObject *_wrap_VectorHexas_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7568   PyObject *resultobj = 0;
7569   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7570   std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
7571   void *argp1 = 0 ;
7572   int res1 = 0 ;
7573   void *argp2 = 0 ;
7574   int res2 = 0 ;
7575   PyObject * obj0 = 0 ;
7576   PyObject * obj1 = 0 ;
7577
7578   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_append",&obj0,&obj1)) SWIG_fail;
7579   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7580   if (!SWIG_IsOK(res1)) {
7581     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_append" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7582   }
7583   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7584   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
7585   if (!SWIG_IsOK(res2)) {
7586     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_append" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
7587   }
7588   arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
7589   std_vector_Sl_Hex_Hexa_Sm__Sg__append(arg1,arg2);
7590   resultobj = SWIG_Py_Void();
7591   return resultobj;
7592 fail:
7593   return NULL;
7594 }
7595
7596
7597 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7598   PyObject *resultobj = 0;
7599   std::vector< Hex::Hexa * > *result = 0 ;
7600
7601   if (!PyArg_ParseTuple(args,(char *)":new_VectorHexas")) SWIG_fail;
7602   result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >();
7603   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
7604   return resultobj;
7605 fail:
7606   return NULL;
7607 }
7608
7609
7610 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7611   PyObject *resultobj = 0;
7612   std::vector< Hex::Hexa * > *arg1 = 0 ;
7613   int res1 = SWIG_OLDOBJ ;
7614   PyObject * obj0 = 0 ;
7615   std::vector< Hex::Hexa * > *result = 0 ;
7616
7617   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
7618   {
7619     std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
7620     res1 = swig::asptr(obj0, &ptr);
7621     if (!SWIG_IsOK(res1)) {
7622       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const &""'");
7623     }
7624     if (!ptr) {
7625       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const &""'");
7626     }
7627     arg1 = ptr;
7628   }
7629   result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >((std::vector< Hex::Hexa * > const &)*arg1);
7630   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
7631   if (SWIG_IsNewObj(res1)) delete arg1;
7632   return resultobj;
7633 fail:
7634   if (SWIG_IsNewObj(res1)) delete arg1;
7635   return NULL;
7636 }
7637
7638
7639 SWIGINTERN PyObject *_wrap_VectorHexas_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7640   PyObject *resultobj = 0;
7641   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7642   void *argp1 = 0 ;
7643   int res1 = 0 ;
7644   PyObject * obj0 = 0 ;
7645   bool result;
7646
7647   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_empty",&obj0)) SWIG_fail;
7648   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7649   if (!SWIG_IsOK(res1)) {
7650     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_empty" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
7651   }
7652   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7653   result = (bool)((std::vector< Hex::Hexa * > const *)arg1)->empty();
7654   resultobj = SWIG_From_bool(static_cast< bool >(result));
7655   return resultobj;
7656 fail:
7657   return NULL;
7658 }
7659
7660
7661 SWIGINTERN PyObject *_wrap_VectorHexas_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7662   PyObject *resultobj = 0;
7663   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7664   void *argp1 = 0 ;
7665   int res1 = 0 ;
7666   PyObject * obj0 = 0 ;
7667   std::vector< Hex::Hexa * >::size_type result;
7668
7669   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_size",&obj0)) SWIG_fail;
7670   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7671   if (!SWIG_IsOK(res1)) {
7672     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_size" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
7673   }
7674   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7675   result = ((std::vector< Hex::Hexa * > const *)arg1)->size();
7676   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
7677   return resultobj;
7678 fail:
7679   return NULL;
7680 }
7681
7682
7683 SWIGINTERN PyObject *_wrap_VectorHexas_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7684   PyObject *resultobj = 0;
7685   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7686   std::vector< Hex::Hexa * > *arg2 = 0 ;
7687   void *argp1 = 0 ;
7688   int res1 = 0 ;
7689   void *argp2 = 0 ;
7690   int res2 = 0 ;
7691   PyObject * obj0 = 0 ;
7692   PyObject * obj1 = 0 ;
7693
7694   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_swap",&obj0,&obj1)) SWIG_fail;
7695   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7696   if (!SWIG_IsOK(res1)) {
7697     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_swap" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7698   }
7699   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7700   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t,  0 );
7701   if (!SWIG_IsOK(res2)) {
7702     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector< Hex::Hexa * > &""'");
7703   }
7704   if (!argp2) {
7705     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorHexas_swap" "', argument " "2"" of type '" "std::vector< Hex::Hexa * > &""'");
7706   }
7707   arg2 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp2);
7708   (arg1)->swap(*arg2);
7709   resultobj = SWIG_Py_Void();
7710   return resultobj;
7711 fail:
7712   return NULL;
7713 }
7714
7715
7716 SWIGINTERN PyObject *_wrap_VectorHexas_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7717   PyObject *resultobj = 0;
7718   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7719   void *argp1 = 0 ;
7720   int res1 = 0 ;
7721   PyObject * obj0 = 0 ;
7722   std::vector< Hex::Hexa * >::iterator result;
7723
7724   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_begin",&obj0)) SWIG_fail;
7725   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7726   if (!SWIG_IsOK(res1)) {
7727     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_begin" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7728   }
7729   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7730   result = (arg1)->begin();
7731   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
7732     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7733   return resultobj;
7734 fail:
7735   return NULL;
7736 }
7737
7738
7739 SWIGINTERN PyObject *_wrap_VectorHexas_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7740   PyObject *resultobj = 0;
7741   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7742   void *argp1 = 0 ;
7743   int res1 = 0 ;
7744   PyObject * obj0 = 0 ;
7745   std::vector< Hex::Hexa * >::iterator result;
7746
7747   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_end",&obj0)) SWIG_fail;
7748   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7749   if (!SWIG_IsOK(res1)) {
7750     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_end" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7751   }
7752   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7753   result = (arg1)->end();
7754   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
7755     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7756   return resultobj;
7757 fail:
7758   return NULL;
7759 }
7760
7761
7762 SWIGINTERN PyObject *_wrap_VectorHexas_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7763   PyObject *resultobj = 0;
7764   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7765   void *argp1 = 0 ;
7766   int res1 = 0 ;
7767   PyObject * obj0 = 0 ;
7768   std::vector< Hex::Hexa * >::reverse_iterator result;
7769
7770   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rbegin",&obj0)) SWIG_fail;
7771   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7772   if (!SWIG_IsOK(res1)) {
7773     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7774   }
7775   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7776   result = (arg1)->rbegin();
7777   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::reverse_iterator & >(result)),
7778     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7779   return resultobj;
7780 fail:
7781   return NULL;
7782 }
7783
7784
7785 SWIGINTERN PyObject *_wrap_VectorHexas_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7786   PyObject *resultobj = 0;
7787   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7788   void *argp1 = 0 ;
7789   int res1 = 0 ;
7790   PyObject * obj0 = 0 ;
7791   std::vector< Hex::Hexa * >::reverse_iterator result;
7792
7793   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_rend",&obj0)) SWIG_fail;
7794   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7795   if (!SWIG_IsOK(res1)) {
7796     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_rend" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7797   }
7798   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7799   result = (arg1)->rend();
7800   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::reverse_iterator & >(result)),
7801     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7802   return resultobj;
7803 fail:
7804   return NULL;
7805 }
7806
7807
7808 SWIGINTERN PyObject *_wrap_VectorHexas_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7809   PyObject *resultobj = 0;
7810   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7811   void *argp1 = 0 ;
7812   int res1 = 0 ;
7813   PyObject * obj0 = 0 ;
7814
7815   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_clear",&obj0)) SWIG_fail;
7816   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7817   if (!SWIG_IsOK(res1)) {
7818     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_clear" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7819   }
7820   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7821   (arg1)->clear();
7822   resultobj = SWIG_Py_Void();
7823   return resultobj;
7824 fail:
7825   return NULL;
7826 }
7827
7828
7829 SWIGINTERN PyObject *_wrap_VectorHexas_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7830   PyObject *resultobj = 0;
7831   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7832   void *argp1 = 0 ;
7833   int res1 = 0 ;
7834   PyObject * obj0 = 0 ;
7835   SwigValueWrapper< std::allocator< Hex::Hexa * > > result;
7836
7837   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_get_allocator",&obj0)) SWIG_fail;
7838   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7839   if (!SWIG_IsOK(res1)) {
7840     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
7841   }
7842   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7843   result = ((std::vector< Hex::Hexa * > const *)arg1)->get_allocator();
7844   resultobj = SWIG_NewPointerObj((new std::vector< Hex::Hexa * >::allocator_type(static_cast< const std::vector< Hex::Hexa * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Hex__Hexa_p_t, SWIG_POINTER_OWN |  0 );
7845   return resultobj;
7846 fail:
7847   return NULL;
7848 }
7849
7850
7851 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7852   PyObject *resultobj = 0;
7853   std::vector< Hex::Hexa * >::size_type arg1 ;
7854   size_t val1 ;
7855   int ecode1 = 0 ;
7856   PyObject * obj0 = 0 ;
7857   std::vector< Hex::Hexa * > *result = 0 ;
7858
7859   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorHexas",&obj0)) SWIG_fail;
7860   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
7861   if (!SWIG_IsOK(ecode1)) {
7862     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
7863   }
7864   arg1 = static_cast< std::vector< Hex::Hexa * >::size_type >(val1);
7865   result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >(arg1);
7866   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
7867   return resultobj;
7868 fail:
7869   return NULL;
7870 }
7871
7872
7873 SWIGINTERN PyObject *_wrap_VectorHexas_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7874   PyObject *resultobj = 0;
7875   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7876   void *argp1 = 0 ;
7877   int res1 = 0 ;
7878   PyObject * obj0 = 0 ;
7879
7880   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_pop_back",&obj0)) SWIG_fail;
7881   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7882   if (!SWIG_IsOK(res1)) {
7883     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7884   }
7885   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7886   (arg1)->pop_back();
7887   resultobj = SWIG_Py_Void();
7888   return resultobj;
7889 fail:
7890   return NULL;
7891 }
7892
7893
7894 SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7895   PyObject *resultobj = 0;
7896   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7897   std::vector< Hex::Hexa * >::size_type arg2 ;
7898   void *argp1 = 0 ;
7899   int res1 = 0 ;
7900   size_t val2 ;
7901   int ecode2 = 0 ;
7902   PyObject * obj0 = 0 ;
7903   PyObject * obj1 = 0 ;
7904
7905   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_resize",&obj0,&obj1)) SWIG_fail;
7906   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7907   if (!SWIG_IsOK(res1)) {
7908     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7909   }
7910   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7911   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7912   if (!SWIG_IsOK(ecode2)) {
7913     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
7914   }
7915   arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
7916   (arg1)->resize(arg2);
7917   resultobj = SWIG_Py_Void();
7918   return resultobj;
7919 fail:
7920   return NULL;
7921 }
7922
7923
7924 SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7925   PyObject *resultobj = 0;
7926   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7927   std::vector< Hex::Hexa * >::iterator arg2 ;
7928   void *argp1 = 0 ;
7929   int res1 = 0 ;
7930   swig::SwigPyIterator *iter2 = 0 ;
7931   int res2 ;
7932   PyObject * obj0 = 0 ;
7933   PyObject * obj1 = 0 ;
7934   std::vector< Hex::Hexa * >::iterator result;
7935
7936   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_erase",&obj0,&obj1)) SWIG_fail;
7937   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7938   if (!SWIG_IsOK(res1)) {
7939     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7940   }
7941   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7942   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
7943   if (!SWIG_IsOK(res2) || !iter2) {
7944     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7945   } else {
7946     swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
7947     if (iter_t) {
7948       arg2 = iter_t->get_current();
7949     } else {
7950       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7951     }
7952   }
7953   result = std_vector_Sl_Hex_Hexa_Sm__Sg__erase__SWIG_0(arg1,arg2);
7954   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
7955     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
7956   return resultobj;
7957 fail:
7958   return NULL;
7959 }
7960
7961
7962 SWIGINTERN PyObject *_wrap_VectorHexas_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7963   PyObject *resultobj = 0;
7964   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
7965   std::vector< Hex::Hexa * >::iterator arg2 ;
7966   std::vector< Hex::Hexa * >::iterator arg3 ;
7967   void *argp1 = 0 ;
7968   int res1 = 0 ;
7969   swig::SwigPyIterator *iter2 = 0 ;
7970   int res2 ;
7971   swig::SwigPyIterator *iter3 = 0 ;
7972   int res3 ;
7973   PyObject * obj0 = 0 ;
7974   PyObject * obj1 = 0 ;
7975   PyObject * obj2 = 0 ;
7976   std::vector< Hex::Hexa * >::iterator result;
7977
7978   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_erase",&obj0,&obj1,&obj2)) SWIG_fail;
7979   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
7980   if (!SWIG_IsOK(res1)) {
7981     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_erase" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
7982   }
7983   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
7984   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
7985   if (!SWIG_IsOK(res2) || !iter2) {
7986     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7987   } else {
7988     swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
7989     if (iter_t) {
7990       arg2 = iter_t->get_current();
7991     } else {
7992       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7993     }
7994   }
7995   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
7996   if (!SWIG_IsOK(res3) || !iter3) {
7997     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
7998   } else {
7999     swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter3);
8000     if (iter_t) {
8001       arg3 = iter_t->get_current();
8002     } else {
8003       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_erase" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
8004     }
8005   }
8006   result = std_vector_Sl_Hex_Hexa_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
8007   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
8008     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
8009   return resultobj;
8010 fail:
8011   return NULL;
8012 }
8013
8014
8015 SWIGINTERN PyObject *_wrap_VectorHexas_erase(PyObject *self, PyObject *args) {
8016   Py_ssize_t argc;
8017   PyObject *argv[4] = {
8018     0
8019   };
8020   Py_ssize_t ii;
8021
8022   if (!PyTuple_Check(args)) SWIG_fail;
8023   argc = args ? PyObject_Length(args) : 0;
8024   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
8025     argv[ii] = PyTuple_GET_ITEM(args,ii);
8026   }
8027   if (argc == 2) {
8028     int _v;
8029     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8030     _v = SWIG_CheckState(res);
8031     if (_v) {
8032       swig::SwigPyIterator *iter = 0;
8033       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8034       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
8035       if (_v) {
8036         return _wrap_VectorHexas_erase__SWIG_0(self, args);
8037       }
8038     }
8039   }
8040   if (argc == 3) {
8041     int _v;
8042     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8043     _v = SWIG_CheckState(res);
8044     if (_v) {
8045       swig::SwigPyIterator *iter = 0;
8046       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8047       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
8048       if (_v) {
8049         swig::SwigPyIterator *iter = 0;
8050         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8051         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
8052         if (_v) {
8053           return _wrap_VectorHexas_erase__SWIG_1(self, args);
8054         }
8055       }
8056     }
8057   }
8058
8059 fail:
8060   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas_erase'.\n"
8061     "  Possible C/C++ prototypes are:\n"
8062     "    std::vector< Hex::Hexa * >::erase(std::vector< Hex::Hexa * >::iterator)\n"
8063     "    std::vector< Hex::Hexa * >::erase(std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::iterator)\n");
8064   return 0;
8065 }
8066
8067
8068 SWIGINTERN PyObject *_wrap_new_VectorHexas__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8069   PyObject *resultobj = 0;
8070   std::vector< Hex::Hexa * >::size_type arg1 ;
8071   std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8072   size_t val1 ;
8073   int ecode1 = 0 ;
8074   void *argp2 = 0 ;
8075   int res2 = 0 ;
8076   PyObject * obj0 = 0 ;
8077   PyObject * obj1 = 0 ;
8078   std::vector< Hex::Hexa * > *result = 0 ;
8079
8080   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorHexas",&obj0,&obj1)) SWIG_fail;
8081   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
8082   if (!SWIG_IsOK(ecode1)) {
8083     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
8084   }
8085   arg1 = static_cast< std::vector< Hex::Hexa * >::size_type >(val1);
8086   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
8087   if (!SWIG_IsOK(res2)) {
8088     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorHexas" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8089   }
8090   arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
8091   result = (std::vector< Hex::Hexa * > *)new std::vector< Hex::Hexa * >(arg1,arg2);
8092   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_NEW |  0 );
8093   return resultobj;
8094 fail:
8095   return NULL;
8096 }
8097
8098
8099 SWIGINTERN PyObject *_wrap_new_VectorHexas(PyObject *self, PyObject *args) {
8100   Py_ssize_t argc;
8101   PyObject *argv[3] = {
8102     0
8103   };
8104   Py_ssize_t ii;
8105
8106   if (!PyTuple_Check(args)) SWIG_fail;
8107   argc = args ? PyObject_Length(args) : 0;
8108   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
8109     argv[ii] = PyTuple_GET_ITEM(args,ii);
8110   }
8111   if (argc == 0) {
8112     return _wrap_new_VectorHexas__SWIG_0(self, args);
8113   }
8114   if (argc == 1) {
8115     int _v;
8116     {
8117       int res = SWIG_AsVal_size_t(argv[0], NULL);
8118       _v = SWIG_CheckState(res);
8119     }
8120     if (_v) {
8121       return _wrap_new_VectorHexas__SWIG_2(self, args);
8122     }
8123   }
8124   if (argc == 1) {
8125     int _v;
8126     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8127     _v = SWIG_CheckState(res);
8128     if (_v) {
8129       return _wrap_new_VectorHexas__SWIG_1(self, args);
8130     }
8131   }
8132   if (argc == 2) {
8133     int _v;
8134     {
8135       int res = SWIG_AsVal_size_t(argv[0], NULL);
8136       _v = SWIG_CheckState(res);
8137     }
8138     if (_v) {
8139       void *vptr = 0;
8140       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Hexa, 0);
8141       _v = SWIG_CheckState(res);
8142       if (_v) {
8143         return _wrap_new_VectorHexas__SWIG_3(self, args);
8144       }
8145     }
8146   }
8147
8148 fail:
8149   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorHexas'.\n"
8150     "  Possible C/C++ prototypes are:\n"
8151     "    std::vector< Hex::Hexa * >::vector()\n"
8152     "    std::vector< Hex::Hexa * >::vector(std::vector< Hex::Hexa * > const &)\n"
8153     "    std::vector< Hex::Hexa * >::vector(std::vector< Hex::Hexa * >::size_type)\n"
8154     "    std::vector< Hex::Hexa * >::vector(std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
8155   return 0;
8156 }
8157
8158
8159 SWIGINTERN PyObject *_wrap_VectorHexas_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8160   PyObject *resultobj = 0;
8161   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8162   std::vector< Hex::Hexa * >::value_type arg2 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8163   void *argp1 = 0 ;
8164   int res1 = 0 ;
8165   void *argp2 = 0 ;
8166   int res2 = 0 ;
8167   PyObject * obj0 = 0 ;
8168   PyObject * obj1 = 0 ;
8169
8170   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_push_back",&obj0,&obj1)) SWIG_fail;
8171   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
8172   if (!SWIG_IsOK(res1)) {
8173     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_push_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8174   }
8175   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8176   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
8177   if (!SWIG_IsOK(res2)) {
8178     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorHexas_push_back" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8179   }
8180   arg2 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp2);
8181   (arg1)->push_back(arg2);
8182   resultobj = SWIG_Py_Void();
8183   return resultobj;
8184 fail:
8185   return NULL;
8186 }
8187
8188
8189 SWIGINTERN PyObject *_wrap_VectorHexas_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8190   PyObject *resultobj = 0;
8191   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8192   void *argp1 = 0 ;
8193   int res1 = 0 ;
8194   PyObject * obj0 = 0 ;
8195   std::vector< Hex::Hexa * >::value_type result;
8196
8197   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_front",&obj0)) SWIG_fail;
8198   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
8199   if (!SWIG_IsOK(res1)) {
8200     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_front" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
8201   }
8202   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8203   result = (std::vector< Hex::Hexa * >::value_type)((std::vector< Hex::Hexa * > const *)arg1)->front();
8204   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
8205   return resultobj;
8206 fail:
8207   return NULL;
8208 }
8209
8210
8211 SWIGINTERN PyObject *_wrap_VectorHexas_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8212   PyObject *resultobj = 0;
8213   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8214   void *argp1 = 0 ;
8215   int res1 = 0 ;
8216   PyObject * obj0 = 0 ;
8217   std::vector< Hex::Hexa * >::value_type result;
8218
8219   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_back",&obj0)) SWIG_fail;
8220   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
8221   if (!SWIG_IsOK(res1)) {
8222     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_back" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
8223   }
8224   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8225   result = (std::vector< Hex::Hexa * >::value_type)((std::vector< Hex::Hexa * > const *)arg1)->back();
8226   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
8227   return resultobj;
8228 fail:
8229   return NULL;
8230 }
8231
8232
8233 SWIGINTERN PyObject *_wrap_VectorHexas_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8234   PyObject *resultobj = 0;
8235   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8236   std::vector< Hex::Hexa * >::size_type arg2 ;
8237   std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8238   void *argp1 = 0 ;
8239   int res1 = 0 ;
8240   size_t val2 ;
8241   int ecode2 = 0 ;
8242   void *argp3 = 0 ;
8243   int res3 = 0 ;
8244   PyObject * obj0 = 0 ;
8245   PyObject * obj1 = 0 ;
8246   PyObject * obj2 = 0 ;
8247
8248   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_assign",&obj0,&obj1,&obj2)) SWIG_fail;
8249   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
8250   if (!SWIG_IsOK(res1)) {
8251     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_assign" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8252   }
8253   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8254   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8255   if (!SWIG_IsOK(ecode2)) {
8256     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_assign" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
8257   }
8258   arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
8259   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
8260   if (!SWIG_IsOK(res3)) {
8261     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_assign" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8262   }
8263   arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
8264   (arg1)->assign(arg2,arg3);
8265   resultobj = SWIG_Py_Void();
8266   return resultobj;
8267 fail:
8268   return NULL;
8269 }
8270
8271
8272 SWIGINTERN PyObject *_wrap_VectorHexas_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8273   PyObject *resultobj = 0;
8274   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8275   std::vector< Hex::Hexa * >::size_type arg2 ;
8276   std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8277   void *argp1 = 0 ;
8278   int res1 = 0 ;
8279   size_t val2 ;
8280   int ecode2 = 0 ;
8281   void *argp3 = 0 ;
8282   int res3 = 0 ;
8283   PyObject * obj0 = 0 ;
8284   PyObject * obj1 = 0 ;
8285   PyObject * obj2 = 0 ;
8286
8287   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_resize",&obj0,&obj1,&obj2)) SWIG_fail;
8288   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
8289   if (!SWIG_IsOK(res1)) {
8290     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_resize" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8291   }
8292   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8293   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8294   if (!SWIG_IsOK(ecode2)) {
8295     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_resize" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
8296   }
8297   arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
8298   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
8299   if (!SWIG_IsOK(res3)) {
8300     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_resize" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8301   }
8302   arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
8303   (arg1)->resize(arg2,arg3);
8304   resultobj = SWIG_Py_Void();
8305   return resultobj;
8306 fail:
8307   return NULL;
8308 }
8309
8310
8311 SWIGINTERN PyObject *_wrap_VectorHexas_resize(PyObject *self, PyObject *args) {
8312   Py_ssize_t argc;
8313   PyObject *argv[4] = {
8314     0
8315   };
8316   Py_ssize_t ii;
8317
8318   if (!PyTuple_Check(args)) SWIG_fail;
8319   argc = args ? PyObject_Length(args) : 0;
8320   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
8321     argv[ii] = PyTuple_GET_ITEM(args,ii);
8322   }
8323   if (argc == 2) {
8324     int _v;
8325     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8326     _v = SWIG_CheckState(res);
8327     if (_v) {
8328       {
8329         int res = SWIG_AsVal_size_t(argv[1], NULL);
8330         _v = SWIG_CheckState(res);
8331       }
8332       if (_v) {
8333         return _wrap_VectorHexas_resize__SWIG_0(self, args);
8334       }
8335     }
8336   }
8337   if (argc == 3) {
8338     int _v;
8339     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8340     _v = SWIG_CheckState(res);
8341     if (_v) {
8342       {
8343         int res = SWIG_AsVal_size_t(argv[1], NULL);
8344         _v = SWIG_CheckState(res);
8345       }
8346       if (_v) {
8347         void *vptr = 0;
8348         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Hexa, 0);
8349         _v = SWIG_CheckState(res);
8350         if (_v) {
8351           return _wrap_VectorHexas_resize__SWIG_1(self, args);
8352         }
8353       }
8354     }
8355   }
8356
8357 fail:
8358   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas_resize'.\n"
8359     "  Possible C/C++ prototypes are:\n"
8360     "    std::vector< Hex::Hexa * >::resize(std::vector< Hex::Hexa * >::size_type)\n"
8361     "    std::vector< Hex::Hexa * >::resize(std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
8362   return 0;
8363 }
8364
8365
8366 SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8367   PyObject *resultobj = 0;
8368   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8369   std::vector< Hex::Hexa * >::iterator arg2 ;
8370   std::vector< Hex::Hexa * >::value_type arg3 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8371   void *argp1 = 0 ;
8372   int res1 = 0 ;
8373   swig::SwigPyIterator *iter2 = 0 ;
8374   int res2 ;
8375   void *argp3 = 0 ;
8376   int res3 = 0 ;
8377   PyObject * obj0 = 0 ;
8378   PyObject * obj1 = 0 ;
8379   PyObject * obj2 = 0 ;
8380   std::vector< Hex::Hexa * >::iterator result;
8381
8382   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorHexas_insert",&obj0,&obj1,&obj2)) SWIG_fail;
8383   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
8384   if (!SWIG_IsOK(res1)) {
8385     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8386   }
8387   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8388   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
8389   if (!SWIG_IsOK(res2) || !iter2) {
8390     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
8391   } else {
8392     swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
8393     if (iter_t) {
8394       arg2 = iter_t->get_current();
8395     } else {
8396       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
8397     }
8398   }
8399   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
8400   if (!SWIG_IsOK(res3)) {
8401     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8402   }
8403   arg3 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp3);
8404   result = std_vector_Sl_Hex_Hexa_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
8405   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Hexa * >::iterator & >(result)),
8406     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
8407   return resultobj;
8408 fail:
8409   return NULL;
8410 }
8411
8412
8413 SWIGINTERN PyObject *_wrap_VectorHexas_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8414   PyObject *resultobj = 0;
8415   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8416   std::vector< Hex::Hexa * >::iterator arg2 ;
8417   std::vector< Hex::Hexa * >::size_type arg3 ;
8418   std::vector< Hex::Hexa * >::value_type arg4 = (std::vector< Hex::Hexa * >::value_type) 0 ;
8419   void *argp1 = 0 ;
8420   int res1 = 0 ;
8421   swig::SwigPyIterator *iter2 = 0 ;
8422   int res2 ;
8423   size_t val3 ;
8424   int ecode3 = 0 ;
8425   void *argp4 = 0 ;
8426   int res4 = 0 ;
8427   PyObject * obj0 = 0 ;
8428   PyObject * obj1 = 0 ;
8429   PyObject * obj2 = 0 ;
8430   PyObject * obj3 = 0 ;
8431
8432   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorHexas_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8433   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
8434   if (!SWIG_IsOK(res1)) {
8435     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_insert" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8436   }
8437   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8438   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
8439   if (!SWIG_IsOK(res2) || !iter2) {
8440     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
8441   } else {
8442     swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter2);
8443     if (iter_t) {
8444       arg2 = iter_t->get_current();
8445     } else {
8446       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorHexas_insert" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::iterator""'");
8447     }
8448   }
8449   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8450   if (!SWIG_IsOK(ecode3)) {
8451     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorHexas_insert" "', argument " "3"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
8452   }
8453   arg3 = static_cast< std::vector< Hex::Hexa * >::size_type >(val3);
8454   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
8455   if (!SWIG_IsOK(res4)) {
8456     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorHexas_insert" "', argument " "4"" of type '" "std::vector< Hex::Hexa * >::value_type""'");
8457   }
8458   arg4 = reinterpret_cast< std::vector< Hex::Hexa * >::value_type >(argp4);
8459   std_vector_Sl_Hex_Hexa_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
8460   resultobj = SWIG_Py_Void();
8461   return resultobj;
8462 fail:
8463   return NULL;
8464 }
8465
8466
8467 SWIGINTERN PyObject *_wrap_VectorHexas_insert(PyObject *self, PyObject *args) {
8468   Py_ssize_t argc;
8469   PyObject *argv[5] = {
8470     0
8471   };
8472   Py_ssize_t ii;
8473
8474   if (!PyTuple_Check(args)) SWIG_fail;
8475   argc = args ? PyObject_Length(args) : 0;
8476   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
8477     argv[ii] = PyTuple_GET_ITEM(args,ii);
8478   }
8479   if (argc == 3) {
8480     int _v;
8481     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8482     _v = SWIG_CheckState(res);
8483     if (_v) {
8484       swig::SwigPyIterator *iter = 0;
8485       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8486       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
8487       if (_v) {
8488         void *vptr = 0;
8489         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Hexa, 0);
8490         _v = SWIG_CheckState(res);
8491         if (_v) {
8492           return _wrap_VectorHexas_insert__SWIG_0(self, args);
8493         }
8494       }
8495     }
8496   }
8497   if (argc == 4) {
8498     int _v;
8499     int res = swig::asptr(argv[0], (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > >**)(0));
8500     _v = SWIG_CheckState(res);
8501     if (_v) {
8502       swig::SwigPyIterator *iter = 0;
8503       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
8504       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Hexa * >::iterator > *>(iter) != 0));
8505       if (_v) {
8506         {
8507           int res = SWIG_AsVal_size_t(argv[2], NULL);
8508           _v = SWIG_CheckState(res);
8509         }
8510         if (_v) {
8511           void *vptr = 0;
8512           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Hexa, 0);
8513           _v = SWIG_CheckState(res);
8514           if (_v) {
8515             return _wrap_VectorHexas_insert__SWIG_1(self, args);
8516           }
8517         }
8518       }
8519     }
8520   }
8521
8522 fail:
8523   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorHexas_insert'.\n"
8524     "  Possible C/C++ prototypes are:\n"
8525     "    std::vector< Hex::Hexa * >::insert(std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::value_type)\n"
8526     "    std::vector< Hex::Hexa * >::insert(std::vector< Hex::Hexa * >::iterator,std::vector< Hex::Hexa * >::size_type,std::vector< Hex::Hexa * >::value_type)\n");
8527   return 0;
8528 }
8529
8530
8531 SWIGINTERN PyObject *_wrap_VectorHexas_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8532   PyObject *resultobj = 0;
8533   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8534   std::vector< Hex::Hexa * >::size_type arg2 ;
8535   void *argp1 = 0 ;
8536   int res1 = 0 ;
8537   size_t val2 ;
8538   int ecode2 = 0 ;
8539   PyObject * obj0 = 0 ;
8540   PyObject * obj1 = 0 ;
8541
8542   if (!PyArg_ParseTuple(args,(char *)"OO:VectorHexas_reserve",&obj0,&obj1)) SWIG_fail;
8543   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
8544   if (!SWIG_IsOK(res1)) {
8545     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_reserve" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8546   }
8547   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8548   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8549   if (!SWIG_IsOK(ecode2)) {
8550     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorHexas_reserve" "', argument " "2"" of type '" "std::vector< Hex::Hexa * >::size_type""'");
8551   }
8552   arg2 = static_cast< std::vector< Hex::Hexa * >::size_type >(val2);
8553   (arg1)->reserve(arg2);
8554   resultobj = SWIG_Py_Void();
8555   return resultobj;
8556 fail:
8557   return NULL;
8558 }
8559
8560
8561 SWIGINTERN PyObject *_wrap_VectorHexas_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8562   PyObject *resultobj = 0;
8563   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8564   void *argp1 = 0 ;
8565   int res1 = 0 ;
8566   PyObject * obj0 = 0 ;
8567   std::vector< Hex::Hexa * >::size_type result;
8568
8569   if (!PyArg_ParseTuple(args,(char *)"O:VectorHexas_capacity",&obj0)) SWIG_fail;
8570   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0 |  0 );
8571   if (!SWIG_IsOK(res1)) {
8572     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorHexas_capacity" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > const *""'");
8573   }
8574   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8575   result = ((std::vector< Hex::Hexa * > const *)arg1)->capacity();
8576   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8577   return resultobj;
8578 fail:
8579   return NULL;
8580 }
8581
8582
8583 SWIGINTERN PyObject *_wrap_delete_VectorHexas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8584   PyObject *resultobj = 0;
8585   std::vector< Hex::Hexa * > *arg1 = (std::vector< Hex::Hexa * > *) 0 ;
8586   void *argp1 = 0 ;
8587   int res1 = 0 ;
8588   PyObject * obj0 = 0 ;
8589
8590   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorHexas",&obj0)) SWIG_fail;
8591   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_POINTER_DISOWN |  0 );
8592   if (!SWIG_IsOK(res1)) {
8593     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorHexas" "', argument " "1"" of type '" "std::vector< Hex::Hexa * > *""'");
8594   }
8595   arg1 = reinterpret_cast< std::vector< Hex::Hexa * > * >(argp1);
8596   delete arg1;
8597   resultobj = SWIG_Py_Void();
8598   return resultobj;
8599 fail:
8600   return NULL;
8601 }
8602
8603
8604 SWIGINTERN PyObject *VectorHexas_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8605   PyObject *obj;
8606   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
8607   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, SWIG_NewClientData(obj));
8608   return SWIG_Py_Void();
8609 }
8610
8611 SWIGINTERN PyObject *_wrap_VectorQuads_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8612   PyObject *resultobj = 0;
8613   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8614   PyObject **arg2 = (PyObject **) 0 ;
8615   void *argp1 = 0 ;
8616   int res1 = 0 ;
8617   PyObject * obj0 = 0 ;
8618   swig::SwigPyIterator *result = 0 ;
8619
8620   arg2 = &obj0;
8621   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_iterator",&obj0)) SWIG_fail;
8622   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8623   if (!SWIG_IsOK(res1)) {
8624     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_iterator" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8625   }
8626   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8627   result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Quad_Sm__Sg__iterator(arg1,arg2);
8628   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
8629   return resultobj;
8630 fail:
8631   return NULL;
8632 }
8633
8634
8635 SWIGINTERN PyObject *_wrap_VectorQuads___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8636   PyObject *resultobj = 0;
8637   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8638   void *argp1 = 0 ;
8639   int res1 = 0 ;
8640   PyObject * obj0 = 0 ;
8641   bool result;
8642
8643   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___nonzero__",&obj0)) SWIG_fail;
8644   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8645   if (!SWIG_IsOK(res1)) {
8646     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8647   }
8648   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8649   result = (bool)std_vector_Sl_Hex_Quad_Sm__Sg____nonzero__((std::vector< Hex::Quad * > const *)arg1);
8650   resultobj = SWIG_From_bool(static_cast< bool >(result));
8651   return resultobj;
8652 fail:
8653   return NULL;
8654 }
8655
8656
8657 SWIGINTERN PyObject *_wrap_VectorQuads___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8658   PyObject *resultobj = 0;
8659   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8660   void *argp1 = 0 ;
8661   int res1 = 0 ;
8662   PyObject * obj0 = 0 ;
8663   bool result;
8664
8665   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___bool__",&obj0)) SWIG_fail;
8666   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8667   if (!SWIG_IsOK(res1)) {
8668     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___bool__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8669   }
8670   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8671   result = (bool)std_vector_Sl_Hex_Quad_Sm__Sg____bool__((std::vector< Hex::Quad * > const *)arg1);
8672   resultobj = SWIG_From_bool(static_cast< bool >(result));
8673   return resultobj;
8674 fail:
8675   return NULL;
8676 }
8677
8678
8679 SWIGINTERN PyObject *_wrap_VectorQuads___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8680   PyObject *resultobj = 0;
8681   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8682   void *argp1 = 0 ;
8683   int res1 = 0 ;
8684   PyObject * obj0 = 0 ;
8685   std::vector< Hex::Quad * >::size_type result;
8686
8687   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads___len__",&obj0)) SWIG_fail;
8688   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8689   if (!SWIG_IsOK(res1)) {
8690     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___len__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
8691   }
8692   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8693   result = std_vector_Sl_Hex_Quad_Sm__Sg____len__((std::vector< Hex::Quad * > const *)arg1);
8694   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
8695   return resultobj;
8696 fail:
8697   return NULL;
8698 }
8699
8700
8701 SWIGINTERN PyObject *_wrap_VectorQuads___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8702   PyObject *resultobj = 0;
8703   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8704   std::vector< Hex::Quad * >::difference_type arg2 ;
8705   std::vector< Hex::Quad * >::difference_type arg3 ;
8706   void *argp1 = 0 ;
8707   int res1 = 0 ;
8708   ptrdiff_t val2 ;
8709   int ecode2 = 0 ;
8710   ptrdiff_t val3 ;
8711   int ecode3 = 0 ;
8712   PyObject * obj0 = 0 ;
8713   PyObject * obj1 = 0 ;
8714   PyObject * obj2 = 0 ;
8715   std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *result = 0 ;
8716
8717   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8718   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8719   if (!SWIG_IsOK(res1)) {
8720     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8721   }
8722   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8723   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8724   if (!SWIG_IsOK(ecode2)) {
8725     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8726   }
8727   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8728   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8729   if (!SWIG_IsOK(ecode3)) {
8730     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8731   }
8732   arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
8733   try {
8734     result = (std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *)std_vector_Sl_Hex_Quad_Sm__Sg____getslice__(arg1,arg2,arg3);
8735   }
8736   catch(std::out_of_range &_e) {
8737     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8738   }
8739   catch(std::invalid_argument &_e) {
8740     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8741   }
8742
8743   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_OWN |  0 );
8744   return resultobj;
8745 fail:
8746   return NULL;
8747 }
8748
8749
8750 SWIGINTERN PyObject *_wrap_VectorQuads___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8751   PyObject *resultobj = 0;
8752   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8753   std::vector< Hex::Quad * >::difference_type arg2 ;
8754   std::vector< Hex::Quad * >::difference_type arg3 ;
8755   void *argp1 = 0 ;
8756   int res1 = 0 ;
8757   ptrdiff_t val2 ;
8758   int ecode2 = 0 ;
8759   ptrdiff_t val3 ;
8760   int ecode3 = 0 ;
8761   PyObject * obj0 = 0 ;
8762   PyObject * obj1 = 0 ;
8763   PyObject * obj2 = 0 ;
8764
8765   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8766   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8767   if (!SWIG_IsOK(res1)) {
8768     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8769   }
8770   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8771   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8772   if (!SWIG_IsOK(ecode2)) {
8773     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8774   }
8775   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8776   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8777   if (!SWIG_IsOK(ecode3)) {
8778     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8779   }
8780   arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
8781   try {
8782     std_vector_Sl_Hex_Quad_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
8783   }
8784   catch(std::out_of_range &_e) {
8785     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8786   }
8787   catch(std::invalid_argument &_e) {
8788     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8789   }
8790
8791   resultobj = SWIG_Py_Void();
8792   return resultobj;
8793 fail:
8794   return NULL;
8795 }
8796
8797
8798 SWIGINTERN PyObject *_wrap_VectorQuads___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8799   PyObject *resultobj = 0;
8800   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8801   std::vector< Hex::Quad * >::difference_type arg2 ;
8802   std::vector< Hex::Quad * >::difference_type arg3 ;
8803   std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *arg4 = 0 ;
8804   void *argp1 = 0 ;
8805   int res1 = 0 ;
8806   ptrdiff_t val2 ;
8807   int ecode2 = 0 ;
8808   ptrdiff_t val3 ;
8809   int ecode3 = 0 ;
8810   int res4 = SWIG_OLDOBJ ;
8811   PyObject * obj0 = 0 ;
8812   PyObject * obj1 = 0 ;
8813   PyObject * obj2 = 0 ;
8814   PyObject * obj3 = 0 ;
8815
8816   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8817   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8818   if (!SWIG_IsOK(res1)) {
8819     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8820   }
8821   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8822   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8823   if (!SWIG_IsOK(ecode2)) {
8824     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8825   }
8826   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8827   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8828   if (!SWIG_IsOK(ecode3)) {
8829     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8830   }
8831   arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
8832   {
8833     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
8834     res4 = swig::asptr(obj3, &ptr);
8835     if (!SWIG_IsOK(res4)) {
8836       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
8837     }
8838     if (!ptr) {
8839       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 &""'");
8840     }
8841     arg4 = ptr;
8842   }
8843   try {
8844     std_vector_Sl_Hex_Quad_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)*arg4);
8845   }
8846   catch(std::out_of_range &_e) {
8847     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8848   }
8849   catch(std::invalid_argument &_e) {
8850     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8851   }
8852
8853   resultobj = SWIG_Py_Void();
8854   if (SWIG_IsNewObj(res4)) delete arg4;
8855   return resultobj;
8856 fail:
8857   if (SWIG_IsNewObj(res4)) delete arg4;
8858   return NULL;
8859 }
8860
8861
8862 SWIGINTERN PyObject *_wrap_VectorQuads___setslice__(PyObject *self, PyObject *args) {
8863   Py_ssize_t argc;
8864   PyObject *argv[5] = {
8865     0
8866   };
8867   Py_ssize_t ii;
8868
8869   if (!PyTuple_Check(args)) SWIG_fail;
8870   argc = args ? PyObject_Length(args) : 0;
8871   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
8872     argv[ii] = PyTuple_GET_ITEM(args,ii);
8873   }
8874   if (argc == 3) {
8875     int _v;
8876     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8877     _v = SWIG_CheckState(res);
8878     if (_v) {
8879       {
8880         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
8881         _v = SWIG_CheckState(res);
8882       }
8883       if (_v) {
8884         {
8885           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
8886           _v = SWIG_CheckState(res);
8887         }
8888         if (_v) {
8889           return _wrap_VectorQuads___setslice____SWIG_0(self, args);
8890         }
8891       }
8892     }
8893   }
8894   if (argc == 4) {
8895     int _v;
8896     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8897     _v = SWIG_CheckState(res);
8898     if (_v) {
8899       {
8900         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
8901         _v = SWIG_CheckState(res);
8902       }
8903       if (_v) {
8904         {
8905           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
8906           _v = SWIG_CheckState(res);
8907         }
8908         if (_v) {
8909           int res = swig::asptr(argv[3], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
8910           _v = SWIG_CheckState(res);
8911           if (_v) {
8912             return _wrap_VectorQuads___setslice____SWIG_1(self, args);
8913           }
8914         }
8915       }
8916     }
8917   }
8918
8919 fail:
8920   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads___setslice__'.\n"
8921     "  Possible C/C++ prototypes are:\n"
8922     "    std::vector< Hex::Quad * >::__setslice__(std::vector< Hex::Quad * >::difference_type,std::vector< Hex::Quad * >::difference_type)\n"
8923     "    std::vector< Hex::Quad * >::__setslice__(std::vector< Hex::Quad * >::difference_type,std::vector< Hex::Quad * >::difference_type,std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)\n");
8924   return 0;
8925 }
8926
8927
8928 SWIGINTERN PyObject *_wrap_VectorQuads___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8929   PyObject *resultobj = 0;
8930   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8931   std::vector< Hex::Quad * >::difference_type arg2 ;
8932   std::vector< Hex::Quad * >::difference_type arg3 ;
8933   void *argp1 = 0 ;
8934   int res1 = 0 ;
8935   ptrdiff_t val2 ;
8936   int ecode2 = 0 ;
8937   ptrdiff_t val3 ;
8938   int ecode3 = 0 ;
8939   PyObject * obj0 = 0 ;
8940   PyObject * obj1 = 0 ;
8941   PyObject * obj2 = 0 ;
8942
8943   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
8944   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8945   if (!SWIG_IsOK(res1)) {
8946     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8947   }
8948   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8949   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8950   if (!SWIG_IsOK(ecode2)) {
8951     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8952   }
8953   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8954   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
8955   if (!SWIG_IsOK(ecode3)) {
8956     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8957   }
8958   arg3 = static_cast< std::vector< Hex::Quad * >::difference_type >(val3);
8959   try {
8960     std_vector_Sl_Hex_Quad_Sm__Sg____delslice__(arg1,arg2,arg3);
8961   }
8962   catch(std::out_of_range &_e) {
8963     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
8964   }
8965   catch(std::invalid_argument &_e) {
8966     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
8967   }
8968
8969   resultobj = SWIG_Py_Void();
8970   return resultobj;
8971 fail:
8972   return NULL;
8973 }
8974
8975
8976 SWIGINTERN PyObject *_wrap_VectorQuads___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8977   PyObject *resultobj = 0;
8978   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
8979   std::vector< Hex::Quad * >::difference_type arg2 ;
8980   void *argp1 = 0 ;
8981   int res1 = 0 ;
8982   ptrdiff_t val2 ;
8983   int ecode2 = 0 ;
8984   PyObject * obj0 = 0 ;
8985   PyObject * obj1 = 0 ;
8986
8987   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___delitem__",&obj0,&obj1)) SWIG_fail;
8988   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
8989   if (!SWIG_IsOK(res1)) {
8990     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
8991   }
8992   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
8993   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
8994   if (!SWIG_IsOK(ecode2)) {
8995     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
8996   }
8997   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
8998   try {
8999     std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_0(arg1,arg2);
9000   }
9001   catch(std::out_of_range &_e) {
9002     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9003   }
9004   catch(std::invalid_argument &_e) {
9005     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9006   }
9007
9008   resultobj = SWIG_Py_Void();
9009   return resultobj;
9010 fail:
9011   return NULL;
9012 }
9013
9014
9015 SWIGINTERN PyObject *_wrap_VectorQuads___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9016   PyObject *resultobj = 0;
9017   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9018   PySliceObject *arg2 = (PySliceObject *) 0 ;
9019   void *argp1 = 0 ;
9020   int res1 = 0 ;
9021   PyObject * obj0 = 0 ;
9022   PyObject * obj1 = 0 ;
9023   std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *result = 0 ;
9024
9025   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___getitem__",&obj0,&obj1)) SWIG_fail;
9026   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9027   if (!SWIG_IsOK(res1)) {
9028     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9029   }
9030   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9031   {
9032     if (!PySlice_Check(obj1)) {
9033       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
9034     }
9035     arg2 = (PySliceObject *) obj1;
9036   }
9037   try {
9038     result = (std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *)std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_0(arg1,arg2);
9039   }
9040   catch(std::out_of_range &_e) {
9041     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9042   }
9043   catch(std::invalid_argument &_e) {
9044     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9045   }
9046
9047   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_OWN |  0 );
9048   return resultobj;
9049 fail:
9050   return NULL;
9051 }
9052
9053
9054 SWIGINTERN PyObject *_wrap_VectorQuads___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9055   PyObject *resultobj = 0;
9056   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9057   PySliceObject *arg2 = (PySliceObject *) 0 ;
9058   std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *arg3 = 0 ;
9059   void *argp1 = 0 ;
9060   int res1 = 0 ;
9061   int res3 = SWIG_OLDOBJ ;
9062   PyObject * obj0 = 0 ;
9063   PyObject * obj1 = 0 ;
9064   PyObject * obj2 = 0 ;
9065
9066   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
9067   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9068   if (!SWIG_IsOK(res1)) {
9069     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9070   }
9071   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9072   {
9073     if (!PySlice_Check(obj1)) {
9074       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
9075     }
9076     arg2 = (PySliceObject *) obj1;
9077   }
9078   {
9079     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
9080     res3 = swig::asptr(obj2, &ptr);
9081     if (!SWIG_IsOK(res3)) {
9082       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
9083     }
9084     if (!ptr) {
9085       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &""'");
9086     }
9087     arg3 = ptr;
9088   }
9089   try {
9090     std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)*arg3);
9091   }
9092   catch(std::out_of_range &_e) {
9093     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9094   }
9095   catch(std::invalid_argument &_e) {
9096     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9097   }
9098
9099   resultobj = SWIG_Py_Void();
9100   if (SWIG_IsNewObj(res3)) delete arg3;
9101   return resultobj;
9102 fail:
9103   if (SWIG_IsNewObj(res3)) delete arg3;
9104   return NULL;
9105 }
9106
9107
9108 SWIGINTERN PyObject *_wrap_VectorQuads___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9109   PyObject *resultobj = 0;
9110   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9111   PySliceObject *arg2 = (PySliceObject *) 0 ;
9112   void *argp1 = 0 ;
9113   int res1 = 0 ;
9114   PyObject * obj0 = 0 ;
9115   PyObject * obj1 = 0 ;
9116
9117   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___setitem__",&obj0,&obj1)) SWIG_fail;
9118   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9119   if (!SWIG_IsOK(res1)) {
9120     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9121   }
9122   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9123   {
9124     if (!PySlice_Check(obj1)) {
9125       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
9126     }
9127     arg2 = (PySliceObject *) obj1;
9128   }
9129   try {
9130     std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_1(arg1,arg2);
9131   }
9132   catch(std::out_of_range &_e) {
9133     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9134   }
9135   catch(std::invalid_argument &_e) {
9136     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9137   }
9138
9139   resultobj = SWIG_Py_Void();
9140   return resultobj;
9141 fail:
9142   return NULL;
9143 }
9144
9145
9146 SWIGINTERN PyObject *_wrap_VectorQuads___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9147   PyObject *resultobj = 0;
9148   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9149   PySliceObject *arg2 = (PySliceObject *) 0 ;
9150   void *argp1 = 0 ;
9151   int res1 = 0 ;
9152   PyObject * obj0 = 0 ;
9153   PyObject * obj1 = 0 ;
9154
9155   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___delitem__",&obj0,&obj1)) SWIG_fail;
9156   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9157   if (!SWIG_IsOK(res1)) {
9158     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9159   }
9160   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9161   {
9162     if (!PySlice_Check(obj1)) {
9163       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
9164     }
9165     arg2 = (PySliceObject *) obj1;
9166   }
9167   try {
9168     std_vector_Sl_Hex_Quad_Sm__Sg____delitem____SWIG_1(arg1,arg2);
9169   }
9170   catch(std::out_of_range &_e) {
9171     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9172   }
9173   catch(std::invalid_argument &_e) {
9174     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
9175   }
9176
9177   resultobj = SWIG_Py_Void();
9178   return resultobj;
9179 fail:
9180   return NULL;
9181 }
9182
9183
9184 SWIGINTERN PyObject *_wrap_VectorQuads___delitem__(PyObject *self, PyObject *args) {
9185   Py_ssize_t argc;
9186   PyObject *argv[3] = {
9187     0
9188   };
9189   Py_ssize_t ii;
9190
9191   if (!PyTuple_Check(args)) SWIG_fail;
9192   argc = args ? PyObject_Length(args) : 0;
9193   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
9194     argv[ii] = PyTuple_GET_ITEM(args,ii);
9195   }
9196   if (argc == 2) {
9197     int _v;
9198     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9199     _v = SWIG_CheckState(res);
9200     if (_v) {
9201       {
9202         _v = PySlice_Check(argv[1]);
9203       }
9204       if (_v) {
9205         return _wrap_VectorQuads___delitem____SWIG_1(self, args);
9206       }
9207     }
9208   }
9209   if (argc == 2) {
9210     int _v;
9211     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9212     _v = SWIG_CheckState(res);
9213     if (_v) {
9214       {
9215         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
9216         _v = SWIG_CheckState(res);
9217       }
9218       if (_v) {
9219         return _wrap_VectorQuads___delitem____SWIG_0(self, args);
9220       }
9221     }
9222   }
9223
9224 fail:
9225   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads___delitem__'.\n"
9226     "  Possible C/C++ prototypes are:\n"
9227     "    std::vector< Hex::Quad * >::__delitem__(std::vector< Hex::Quad * >::difference_type)\n"
9228     "    std::vector< Hex::Quad * >::__delitem__(PySliceObject *)\n");
9229   return 0;
9230 }
9231
9232
9233 SWIGINTERN PyObject *_wrap_VectorQuads___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9234   PyObject *resultobj = 0;
9235   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9236   std::vector< Hex::Quad * >::difference_type arg2 ;
9237   void *argp1 = 0 ;
9238   int res1 = 0 ;
9239   ptrdiff_t val2 ;
9240   int ecode2 = 0 ;
9241   PyObject * obj0 = 0 ;
9242   PyObject * obj1 = 0 ;
9243   std::vector< Hex::Quad * >::value_type result;
9244
9245   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads___getitem__",&obj0,&obj1)) SWIG_fail;
9246   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9247   if (!SWIG_IsOK(res1)) {
9248     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9249   }
9250   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9251   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
9252   if (!SWIG_IsOK(ecode2)) {
9253     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
9254   }
9255   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
9256   try {
9257     result = (std::vector< Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg____getitem____SWIG_1(arg1,arg2);
9258   }
9259   catch(std::out_of_range &_e) {
9260     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9261   }
9262
9263   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
9264   return resultobj;
9265 fail:
9266   return NULL;
9267 }
9268
9269
9270 SWIGINTERN PyObject *_wrap_VectorQuads___getitem__(PyObject *self, PyObject *args) {
9271   Py_ssize_t argc;
9272   PyObject *argv[3] = {
9273     0
9274   };
9275   Py_ssize_t ii;
9276
9277   if (!PyTuple_Check(args)) SWIG_fail;
9278   argc = args ? PyObject_Length(args) : 0;
9279   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
9280     argv[ii] = PyTuple_GET_ITEM(args,ii);
9281   }
9282   if (argc == 2) {
9283     int _v;
9284     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9285     _v = SWIG_CheckState(res);
9286     if (_v) {
9287       {
9288         _v = PySlice_Check(argv[1]);
9289       }
9290       if (_v) {
9291         return _wrap_VectorQuads___getitem____SWIG_0(self, args);
9292       }
9293     }
9294   }
9295   if (argc == 2) {
9296     int _v;
9297     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9298     _v = SWIG_CheckState(res);
9299     if (_v) {
9300       {
9301         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
9302         _v = SWIG_CheckState(res);
9303       }
9304       if (_v) {
9305         return _wrap_VectorQuads___getitem____SWIG_1(self, args);
9306       }
9307     }
9308   }
9309
9310 fail:
9311   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads___getitem__'.\n"
9312     "  Possible C/C++ prototypes are:\n"
9313     "    std::vector< Hex::Quad * >::__getitem__(PySliceObject *)\n"
9314     "    std::vector< Hex::Quad * >::__getitem__(std::vector< Hex::Quad * >::difference_type)\n");
9315   return 0;
9316 }
9317
9318
9319 SWIGINTERN PyObject *_wrap_VectorQuads___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9320   PyObject *resultobj = 0;
9321   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9322   std::vector< Hex::Quad * >::difference_type arg2 ;
9323   std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
9324   void *argp1 = 0 ;
9325   int res1 = 0 ;
9326   ptrdiff_t val2 ;
9327   int ecode2 = 0 ;
9328   void *argp3 = 0 ;
9329   int res3 = 0 ;
9330   PyObject * obj0 = 0 ;
9331   PyObject * obj1 = 0 ;
9332   PyObject * obj2 = 0 ;
9333
9334   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
9335   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9336   if (!SWIG_IsOK(res1)) {
9337     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9338   }
9339   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9340   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
9341   if (!SWIG_IsOK(ecode2)) {
9342     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::difference_type""'");
9343   }
9344   arg2 = static_cast< std::vector< Hex::Quad * >::difference_type >(val2);
9345   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
9346   if (!SWIG_IsOK(res3)) {
9347     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
9348   }
9349   arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
9350   try {
9351     std_vector_Sl_Hex_Quad_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
9352   }
9353   catch(std::out_of_range &_e) {
9354     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9355   }
9356
9357   resultobj = SWIG_Py_Void();
9358   return resultobj;
9359 fail:
9360   return NULL;
9361 }
9362
9363
9364 SWIGINTERN PyObject *_wrap_VectorQuads___setitem__(PyObject *self, PyObject *args) {
9365   Py_ssize_t argc;
9366   PyObject *argv[4] = {
9367     0
9368   };
9369   Py_ssize_t ii;
9370
9371   if (!PyTuple_Check(args)) SWIG_fail;
9372   argc = args ? PyObject_Length(args) : 0;
9373   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
9374     argv[ii] = PyTuple_GET_ITEM(args,ii);
9375   }
9376   if (argc == 2) {
9377     int _v;
9378     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9379     _v = SWIG_CheckState(res);
9380     if (_v) {
9381       {
9382         _v = PySlice_Check(argv[1]);
9383       }
9384       if (_v) {
9385         return _wrap_VectorQuads___setitem____SWIG_1(self, args);
9386       }
9387     }
9388   }
9389   if (argc == 3) {
9390     int _v;
9391     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9392     _v = SWIG_CheckState(res);
9393     if (_v) {
9394       {
9395         _v = PySlice_Check(argv[1]);
9396       }
9397       if (_v) {
9398         int res = swig::asptr(argv[2], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9399         _v = SWIG_CheckState(res);
9400         if (_v) {
9401           return _wrap_VectorQuads___setitem____SWIG_0(self, args);
9402         }
9403       }
9404     }
9405   }
9406   if (argc == 3) {
9407     int _v;
9408     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9409     _v = SWIG_CheckState(res);
9410     if (_v) {
9411       {
9412         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
9413         _v = SWIG_CheckState(res);
9414       }
9415       if (_v) {
9416         void *vptr = 0;
9417         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Quad, 0);
9418         _v = SWIG_CheckState(res);
9419         if (_v) {
9420           return _wrap_VectorQuads___setitem____SWIG_2(self, args);
9421         }
9422       }
9423     }
9424   }
9425
9426 fail:
9427   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads___setitem__'.\n"
9428     "  Possible C/C++ prototypes are:\n"
9429     "    std::vector< Hex::Quad * >::__setitem__(PySliceObject *,std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > const &)\n"
9430     "    std::vector< Hex::Quad * >::__setitem__(PySliceObject *)\n"
9431     "    std::vector< Hex::Quad * >::__setitem__(std::vector< Hex::Quad * >::difference_type,std::vector< Hex::Quad * >::value_type)\n");
9432   return 0;
9433 }
9434
9435
9436 SWIGINTERN PyObject *_wrap_VectorQuads_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9437   PyObject *resultobj = 0;
9438   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9439   void *argp1 = 0 ;
9440   int res1 = 0 ;
9441   PyObject * obj0 = 0 ;
9442   std::vector< Hex::Quad * >::value_type result;
9443
9444   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop",&obj0)) SWIG_fail;
9445   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9446   if (!SWIG_IsOK(res1)) {
9447     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9448   }
9449   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9450   try {
9451     result = (std::vector< Hex::Quad * >::value_type)std_vector_Sl_Hex_Quad_Sm__Sg__pop(arg1);
9452   }
9453   catch(std::out_of_range &_e) {
9454     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
9455   }
9456
9457   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
9458   return resultobj;
9459 fail:
9460   return NULL;
9461 }
9462
9463
9464 SWIGINTERN PyObject *_wrap_VectorQuads_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9465   PyObject *resultobj = 0;
9466   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9467   std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
9468   void *argp1 = 0 ;
9469   int res1 = 0 ;
9470   void *argp2 = 0 ;
9471   int res2 = 0 ;
9472   PyObject * obj0 = 0 ;
9473   PyObject * obj1 = 0 ;
9474
9475   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_append",&obj0,&obj1)) SWIG_fail;
9476   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9477   if (!SWIG_IsOK(res1)) {
9478     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_append" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9479   }
9480   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9481   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
9482   if (!SWIG_IsOK(res2)) {
9483     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_append" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
9484   }
9485   arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
9486   std_vector_Sl_Hex_Quad_Sm__Sg__append(arg1,arg2);
9487   resultobj = SWIG_Py_Void();
9488   return resultobj;
9489 fail:
9490   return NULL;
9491 }
9492
9493
9494 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9495   PyObject *resultobj = 0;
9496   std::vector< Hex::Quad * > *result = 0 ;
9497
9498   if (!PyArg_ParseTuple(args,(char *)":new_VectorQuads")) SWIG_fail;
9499   result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >();
9500   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
9501   return resultobj;
9502 fail:
9503   return NULL;
9504 }
9505
9506
9507 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9508   PyObject *resultobj = 0;
9509   std::vector< Hex::Quad * > *arg1 = 0 ;
9510   int res1 = SWIG_OLDOBJ ;
9511   PyObject * obj0 = 0 ;
9512   std::vector< Hex::Quad * > *result = 0 ;
9513
9514   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
9515   {
9516     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
9517     res1 = swig::asptr(obj0, &ptr);
9518     if (!SWIG_IsOK(res1)) {
9519       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const &""'");
9520     }
9521     if (!ptr) {
9522       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const &""'");
9523     }
9524     arg1 = ptr;
9525   }
9526   result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >((std::vector< Hex::Quad * > const &)*arg1);
9527   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
9528   if (SWIG_IsNewObj(res1)) delete arg1;
9529   return resultobj;
9530 fail:
9531   if (SWIG_IsNewObj(res1)) delete arg1;
9532   return NULL;
9533 }
9534
9535
9536 SWIGINTERN PyObject *_wrap_VectorQuads_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9537   PyObject *resultobj = 0;
9538   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9539   void *argp1 = 0 ;
9540   int res1 = 0 ;
9541   PyObject * obj0 = 0 ;
9542   bool result;
9543
9544   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_empty",&obj0)) SWIG_fail;
9545   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9546   if (!SWIG_IsOK(res1)) {
9547     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_empty" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
9548   }
9549   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9550   result = (bool)((std::vector< Hex::Quad * > const *)arg1)->empty();
9551   resultobj = SWIG_From_bool(static_cast< bool >(result));
9552   return resultobj;
9553 fail:
9554   return NULL;
9555 }
9556
9557
9558 SWIGINTERN PyObject *_wrap_VectorQuads_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9559   PyObject *resultobj = 0;
9560   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9561   void *argp1 = 0 ;
9562   int res1 = 0 ;
9563   PyObject * obj0 = 0 ;
9564   std::vector< Hex::Quad * >::size_type result;
9565
9566   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_size",&obj0)) SWIG_fail;
9567   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9568   if (!SWIG_IsOK(res1)) {
9569     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_size" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
9570   }
9571   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9572   result = ((std::vector< Hex::Quad * > const *)arg1)->size();
9573   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9574   return resultobj;
9575 fail:
9576   return NULL;
9577 }
9578
9579
9580 SWIGINTERN PyObject *_wrap_VectorQuads_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9581   PyObject *resultobj = 0;
9582   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9583   std::vector< Hex::Quad * > *arg2 = 0 ;
9584   void *argp1 = 0 ;
9585   int res1 = 0 ;
9586   void *argp2 = 0 ;
9587   int res2 = 0 ;
9588   PyObject * obj0 = 0 ;
9589   PyObject * obj1 = 0 ;
9590
9591   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_swap",&obj0,&obj1)) SWIG_fail;
9592   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9593   if (!SWIG_IsOK(res1)) {
9594     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_swap" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9595   }
9596   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9597   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t,  0 );
9598   if (!SWIG_IsOK(res2)) {
9599     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector< Hex::Quad * > &""'");
9600   }
9601   if (!argp2) {
9602     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorQuads_swap" "', argument " "2"" of type '" "std::vector< Hex::Quad * > &""'");
9603   }
9604   arg2 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp2);
9605   (arg1)->swap(*arg2);
9606   resultobj = SWIG_Py_Void();
9607   return resultobj;
9608 fail:
9609   return NULL;
9610 }
9611
9612
9613 SWIGINTERN PyObject *_wrap_VectorQuads_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9614   PyObject *resultobj = 0;
9615   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9616   void *argp1 = 0 ;
9617   int res1 = 0 ;
9618   PyObject * obj0 = 0 ;
9619   std::vector< Hex::Quad * >::iterator result;
9620
9621   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_begin",&obj0)) SWIG_fail;
9622   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9623   if (!SWIG_IsOK(res1)) {
9624     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_begin" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9625   }
9626   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9627   result = (arg1)->begin();
9628   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
9629     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9630   return resultobj;
9631 fail:
9632   return NULL;
9633 }
9634
9635
9636 SWIGINTERN PyObject *_wrap_VectorQuads_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9637   PyObject *resultobj = 0;
9638   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9639   void *argp1 = 0 ;
9640   int res1 = 0 ;
9641   PyObject * obj0 = 0 ;
9642   std::vector< Hex::Quad * >::iterator result;
9643
9644   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_end",&obj0)) SWIG_fail;
9645   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9646   if (!SWIG_IsOK(res1)) {
9647     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_end" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9648   }
9649   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9650   result = (arg1)->end();
9651   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
9652     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9653   return resultobj;
9654 fail:
9655   return NULL;
9656 }
9657
9658
9659 SWIGINTERN PyObject *_wrap_VectorQuads_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9660   PyObject *resultobj = 0;
9661   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9662   void *argp1 = 0 ;
9663   int res1 = 0 ;
9664   PyObject * obj0 = 0 ;
9665   std::vector< Hex::Quad * >::reverse_iterator result;
9666
9667   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rbegin",&obj0)) SWIG_fail;
9668   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9669   if (!SWIG_IsOK(res1)) {
9670     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9671   }
9672   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9673   result = (arg1)->rbegin();
9674   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::reverse_iterator & >(result)),
9675     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9676   return resultobj;
9677 fail:
9678   return NULL;
9679 }
9680
9681
9682 SWIGINTERN PyObject *_wrap_VectorQuads_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9683   PyObject *resultobj = 0;
9684   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9685   void *argp1 = 0 ;
9686   int res1 = 0 ;
9687   PyObject * obj0 = 0 ;
9688   std::vector< Hex::Quad * >::reverse_iterator result;
9689
9690   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_rend",&obj0)) SWIG_fail;
9691   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9692   if (!SWIG_IsOK(res1)) {
9693     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_rend" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9694   }
9695   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9696   result = (arg1)->rend();
9697   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::reverse_iterator & >(result)),
9698     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9699   return resultobj;
9700 fail:
9701   return NULL;
9702 }
9703
9704
9705 SWIGINTERN PyObject *_wrap_VectorQuads_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9706   PyObject *resultobj = 0;
9707   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9708   void *argp1 = 0 ;
9709   int res1 = 0 ;
9710   PyObject * obj0 = 0 ;
9711
9712   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_clear",&obj0)) SWIG_fail;
9713   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9714   if (!SWIG_IsOK(res1)) {
9715     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_clear" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9716   }
9717   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9718   (arg1)->clear();
9719   resultobj = SWIG_Py_Void();
9720   return resultobj;
9721 fail:
9722   return NULL;
9723 }
9724
9725
9726 SWIGINTERN PyObject *_wrap_VectorQuads_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9727   PyObject *resultobj = 0;
9728   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9729   void *argp1 = 0 ;
9730   int res1 = 0 ;
9731   PyObject * obj0 = 0 ;
9732   SwigValueWrapper< std::allocator< Hex::Quad * > > result;
9733
9734   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_get_allocator",&obj0)) SWIG_fail;
9735   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9736   if (!SWIG_IsOK(res1)) {
9737     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
9738   }
9739   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9740   result = ((std::vector< Hex::Quad * > const *)arg1)->get_allocator();
9741   resultobj = SWIG_NewPointerObj((new std::vector< Hex::Quad * >::allocator_type(static_cast< const std::vector< Hex::Quad * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Hex__Quad_p_t, SWIG_POINTER_OWN |  0 );
9742   return resultobj;
9743 fail:
9744   return NULL;
9745 }
9746
9747
9748 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9749   PyObject *resultobj = 0;
9750   std::vector< Hex::Quad * >::size_type arg1 ;
9751   size_t val1 ;
9752   int ecode1 = 0 ;
9753   PyObject * obj0 = 0 ;
9754   std::vector< Hex::Quad * > *result = 0 ;
9755
9756   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorQuads",&obj0)) SWIG_fail;
9757   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
9758   if (!SWIG_IsOK(ecode1)) {
9759     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * >::size_type""'");
9760   }
9761   arg1 = static_cast< std::vector< Hex::Quad * >::size_type >(val1);
9762   result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >(arg1);
9763   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
9764   return resultobj;
9765 fail:
9766   return NULL;
9767 }
9768
9769
9770 SWIGINTERN PyObject *_wrap_VectorQuads_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9771   PyObject *resultobj = 0;
9772   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9773   void *argp1 = 0 ;
9774   int res1 = 0 ;
9775   PyObject * obj0 = 0 ;
9776
9777   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_pop_back",&obj0)) SWIG_fail;
9778   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9779   if (!SWIG_IsOK(res1)) {
9780     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9781   }
9782   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9783   (arg1)->pop_back();
9784   resultobj = SWIG_Py_Void();
9785   return resultobj;
9786 fail:
9787   return NULL;
9788 }
9789
9790
9791 SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9792   PyObject *resultobj = 0;
9793   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9794   std::vector< Hex::Quad * >::size_type arg2 ;
9795   void *argp1 = 0 ;
9796   int res1 = 0 ;
9797   size_t val2 ;
9798   int ecode2 = 0 ;
9799   PyObject * obj0 = 0 ;
9800   PyObject * obj1 = 0 ;
9801
9802   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_resize",&obj0,&obj1)) SWIG_fail;
9803   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9804   if (!SWIG_IsOK(res1)) {
9805     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9806   }
9807   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9808   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
9809   if (!SWIG_IsOK(ecode2)) {
9810     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
9811   }
9812   arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
9813   (arg1)->resize(arg2);
9814   resultobj = SWIG_Py_Void();
9815   return resultobj;
9816 fail:
9817   return NULL;
9818 }
9819
9820
9821 SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9822   PyObject *resultobj = 0;
9823   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9824   std::vector< Hex::Quad * >::iterator arg2 ;
9825   void *argp1 = 0 ;
9826   int res1 = 0 ;
9827   swig::SwigPyIterator *iter2 = 0 ;
9828   int res2 ;
9829   PyObject * obj0 = 0 ;
9830   PyObject * obj1 = 0 ;
9831   std::vector< Hex::Quad * >::iterator result;
9832
9833   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_erase",&obj0,&obj1)) SWIG_fail;
9834   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9835   if (!SWIG_IsOK(res1)) {
9836     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9837   }
9838   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9839   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
9840   if (!SWIG_IsOK(res2) || !iter2) {
9841     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9842   } else {
9843     swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
9844     if (iter_t) {
9845       arg2 = iter_t->get_current();
9846     } else {
9847       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9848     }
9849   }
9850   result = std_vector_Sl_Hex_Quad_Sm__Sg__erase__SWIG_0(arg1,arg2);
9851   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
9852     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9853   return resultobj;
9854 fail:
9855   return NULL;
9856 }
9857
9858
9859 SWIGINTERN PyObject *_wrap_VectorQuads_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9860   PyObject *resultobj = 0;
9861   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
9862   std::vector< Hex::Quad * >::iterator arg2 ;
9863   std::vector< Hex::Quad * >::iterator arg3 ;
9864   void *argp1 = 0 ;
9865   int res1 = 0 ;
9866   swig::SwigPyIterator *iter2 = 0 ;
9867   int res2 ;
9868   swig::SwigPyIterator *iter3 = 0 ;
9869   int res3 ;
9870   PyObject * obj0 = 0 ;
9871   PyObject * obj1 = 0 ;
9872   PyObject * obj2 = 0 ;
9873   std::vector< Hex::Quad * >::iterator result;
9874
9875   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_erase",&obj0,&obj1,&obj2)) SWIG_fail;
9876   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
9877   if (!SWIG_IsOK(res1)) {
9878     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_erase" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
9879   }
9880   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
9881   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
9882   if (!SWIG_IsOK(res2) || !iter2) {
9883     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9884   } else {
9885     swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
9886     if (iter_t) {
9887       arg2 = iter_t->get_current();
9888     } else {
9889       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9890     }
9891   }
9892   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
9893   if (!SWIG_IsOK(res3) || !iter3) {
9894     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9895   } else {
9896     swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter3);
9897     if (iter_t) {
9898       arg3 = iter_t->get_current();
9899     } else {
9900       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_erase" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::iterator""'");
9901     }
9902   }
9903   result = std_vector_Sl_Hex_Quad_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
9904   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
9905     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
9906   return resultobj;
9907 fail:
9908   return NULL;
9909 }
9910
9911
9912 SWIGINTERN PyObject *_wrap_VectorQuads_erase(PyObject *self, PyObject *args) {
9913   Py_ssize_t argc;
9914   PyObject *argv[4] = {
9915     0
9916   };
9917   Py_ssize_t ii;
9918
9919   if (!PyTuple_Check(args)) SWIG_fail;
9920   argc = args ? PyObject_Length(args) : 0;
9921   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
9922     argv[ii] = PyTuple_GET_ITEM(args,ii);
9923   }
9924   if (argc == 2) {
9925     int _v;
9926     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9927     _v = SWIG_CheckState(res);
9928     if (_v) {
9929       swig::SwigPyIterator *iter = 0;
9930       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9931       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
9932       if (_v) {
9933         return _wrap_VectorQuads_erase__SWIG_0(self, args);
9934       }
9935     }
9936   }
9937   if (argc == 3) {
9938     int _v;
9939     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
9940     _v = SWIG_CheckState(res);
9941     if (_v) {
9942       swig::SwigPyIterator *iter = 0;
9943       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9944       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
9945       if (_v) {
9946         swig::SwigPyIterator *iter = 0;
9947         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
9948         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
9949         if (_v) {
9950           return _wrap_VectorQuads_erase__SWIG_1(self, args);
9951         }
9952       }
9953     }
9954   }
9955
9956 fail:
9957   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads_erase'.\n"
9958     "  Possible C/C++ prototypes are:\n"
9959     "    std::vector< Hex::Quad * >::erase(std::vector< Hex::Quad * >::iterator)\n"
9960     "    std::vector< Hex::Quad * >::erase(std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::iterator)\n");
9961   return 0;
9962 }
9963
9964
9965 SWIGINTERN PyObject *_wrap_new_VectorQuads__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9966   PyObject *resultobj = 0;
9967   std::vector< Hex::Quad * >::size_type arg1 ;
9968   std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
9969   size_t val1 ;
9970   int ecode1 = 0 ;
9971   void *argp2 = 0 ;
9972   int res2 = 0 ;
9973   PyObject * obj0 = 0 ;
9974   PyObject * obj1 = 0 ;
9975   std::vector< Hex::Quad * > *result = 0 ;
9976
9977   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorQuads",&obj0,&obj1)) SWIG_fail;
9978   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
9979   if (!SWIG_IsOK(ecode1)) {
9980     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * >::size_type""'");
9981   }
9982   arg1 = static_cast< std::vector< Hex::Quad * >::size_type >(val1);
9983   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
9984   if (!SWIG_IsOK(res2)) {
9985     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorQuads" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
9986   }
9987   arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
9988   result = (std::vector< Hex::Quad * > *)new std::vector< Hex::Quad * >(arg1,arg2);
9989   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_NEW |  0 );
9990   return resultobj;
9991 fail:
9992   return NULL;
9993 }
9994
9995
9996 SWIGINTERN PyObject *_wrap_new_VectorQuads(PyObject *self, PyObject *args) {
9997   Py_ssize_t argc;
9998   PyObject *argv[3] = {
9999     0
10000   };
10001   Py_ssize_t ii;
10002
10003   if (!PyTuple_Check(args)) SWIG_fail;
10004   argc = args ? PyObject_Length(args) : 0;
10005   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
10006     argv[ii] = PyTuple_GET_ITEM(args,ii);
10007   }
10008   if (argc == 0) {
10009     return _wrap_new_VectorQuads__SWIG_0(self, args);
10010   }
10011   if (argc == 1) {
10012     int _v;
10013     {
10014       int res = SWIG_AsVal_size_t(argv[0], NULL);
10015       _v = SWIG_CheckState(res);
10016     }
10017     if (_v) {
10018       return _wrap_new_VectorQuads__SWIG_2(self, args);
10019     }
10020   }
10021   if (argc == 1) {
10022     int _v;
10023     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
10024     _v = SWIG_CheckState(res);
10025     if (_v) {
10026       return _wrap_new_VectorQuads__SWIG_1(self, args);
10027     }
10028   }
10029   if (argc == 2) {
10030     int _v;
10031     {
10032       int res = SWIG_AsVal_size_t(argv[0], NULL);
10033       _v = SWIG_CheckState(res);
10034     }
10035     if (_v) {
10036       void *vptr = 0;
10037       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Quad, 0);
10038       _v = SWIG_CheckState(res);
10039       if (_v) {
10040         return _wrap_new_VectorQuads__SWIG_3(self, args);
10041       }
10042     }
10043   }
10044
10045 fail:
10046   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorQuads'.\n"
10047     "  Possible C/C++ prototypes are:\n"
10048     "    std::vector< Hex::Quad * >::vector()\n"
10049     "    std::vector< Hex::Quad * >::vector(std::vector< Hex::Quad * > const &)\n"
10050     "    std::vector< Hex::Quad * >::vector(std::vector< Hex::Quad * >::size_type)\n"
10051     "    std::vector< Hex::Quad * >::vector(std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
10052   return 0;
10053 }
10054
10055
10056 SWIGINTERN PyObject *_wrap_VectorQuads_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10057   PyObject *resultobj = 0;
10058   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10059   std::vector< Hex::Quad * >::value_type arg2 = (std::vector< Hex::Quad * >::value_type) 0 ;
10060   void *argp1 = 0 ;
10061   int res1 = 0 ;
10062   void *argp2 = 0 ;
10063   int res2 = 0 ;
10064   PyObject * obj0 = 0 ;
10065   PyObject * obj1 = 0 ;
10066
10067   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_push_back",&obj0,&obj1)) SWIG_fail;
10068   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
10069   if (!SWIG_IsOK(res1)) {
10070     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_push_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10071   }
10072   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10073   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
10074   if (!SWIG_IsOK(res2)) {
10075     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorQuads_push_back" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::value_type""'");
10076   }
10077   arg2 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp2);
10078   (arg1)->push_back(arg2);
10079   resultobj = SWIG_Py_Void();
10080   return resultobj;
10081 fail:
10082   return NULL;
10083 }
10084
10085
10086 SWIGINTERN PyObject *_wrap_VectorQuads_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10087   PyObject *resultobj = 0;
10088   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10089   void *argp1 = 0 ;
10090   int res1 = 0 ;
10091   PyObject * obj0 = 0 ;
10092   std::vector< Hex::Quad * >::value_type result;
10093
10094   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_front",&obj0)) SWIG_fail;
10095   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
10096   if (!SWIG_IsOK(res1)) {
10097     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_front" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
10098   }
10099   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10100   result = (std::vector< Hex::Quad * >::value_type)((std::vector< Hex::Quad * > const *)arg1)->front();
10101   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
10102   return resultobj;
10103 fail:
10104   return NULL;
10105 }
10106
10107
10108 SWIGINTERN PyObject *_wrap_VectorQuads_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10109   PyObject *resultobj = 0;
10110   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10111   void *argp1 = 0 ;
10112   int res1 = 0 ;
10113   PyObject * obj0 = 0 ;
10114   std::vector< Hex::Quad * >::value_type result;
10115
10116   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_back",&obj0)) SWIG_fail;
10117   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
10118   if (!SWIG_IsOK(res1)) {
10119     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_back" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
10120   }
10121   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10122   result = (std::vector< Hex::Quad * >::value_type)((std::vector< Hex::Quad * > const *)arg1)->back();
10123   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
10124   return resultobj;
10125 fail:
10126   return NULL;
10127 }
10128
10129
10130 SWIGINTERN PyObject *_wrap_VectorQuads_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10131   PyObject *resultobj = 0;
10132   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10133   std::vector< Hex::Quad * >::size_type arg2 ;
10134   std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
10135   void *argp1 = 0 ;
10136   int res1 = 0 ;
10137   size_t val2 ;
10138   int ecode2 = 0 ;
10139   void *argp3 = 0 ;
10140   int res3 = 0 ;
10141   PyObject * obj0 = 0 ;
10142   PyObject * obj1 = 0 ;
10143   PyObject * obj2 = 0 ;
10144
10145   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_assign",&obj0,&obj1,&obj2)) SWIG_fail;
10146   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
10147   if (!SWIG_IsOK(res1)) {
10148     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_assign" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10149   }
10150   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10151   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10152   if (!SWIG_IsOK(ecode2)) {
10153     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_assign" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
10154   }
10155   arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
10156   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
10157   if (!SWIG_IsOK(res3)) {
10158     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_assign" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
10159   }
10160   arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
10161   (arg1)->assign(arg2,arg3);
10162   resultobj = SWIG_Py_Void();
10163   return resultobj;
10164 fail:
10165   return NULL;
10166 }
10167
10168
10169 SWIGINTERN PyObject *_wrap_VectorQuads_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10170   PyObject *resultobj = 0;
10171   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10172   std::vector< Hex::Quad * >::size_type arg2 ;
10173   std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
10174   void *argp1 = 0 ;
10175   int res1 = 0 ;
10176   size_t val2 ;
10177   int ecode2 = 0 ;
10178   void *argp3 = 0 ;
10179   int res3 = 0 ;
10180   PyObject * obj0 = 0 ;
10181   PyObject * obj1 = 0 ;
10182   PyObject * obj2 = 0 ;
10183
10184   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_resize",&obj0,&obj1,&obj2)) SWIG_fail;
10185   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
10186   if (!SWIG_IsOK(res1)) {
10187     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_resize" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10188   }
10189   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10190   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10191   if (!SWIG_IsOK(ecode2)) {
10192     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_resize" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
10193   }
10194   arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
10195   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
10196   if (!SWIG_IsOK(res3)) {
10197     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_resize" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
10198   }
10199   arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
10200   (arg1)->resize(arg2,arg3);
10201   resultobj = SWIG_Py_Void();
10202   return resultobj;
10203 fail:
10204   return NULL;
10205 }
10206
10207
10208 SWIGINTERN PyObject *_wrap_VectorQuads_resize(PyObject *self, PyObject *args) {
10209   Py_ssize_t argc;
10210   PyObject *argv[4] = {
10211     0
10212   };
10213   Py_ssize_t ii;
10214
10215   if (!PyTuple_Check(args)) SWIG_fail;
10216   argc = args ? PyObject_Length(args) : 0;
10217   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
10218     argv[ii] = PyTuple_GET_ITEM(args,ii);
10219   }
10220   if (argc == 2) {
10221     int _v;
10222     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
10223     _v = SWIG_CheckState(res);
10224     if (_v) {
10225       {
10226         int res = SWIG_AsVal_size_t(argv[1], NULL);
10227         _v = SWIG_CheckState(res);
10228       }
10229       if (_v) {
10230         return _wrap_VectorQuads_resize__SWIG_0(self, args);
10231       }
10232     }
10233   }
10234   if (argc == 3) {
10235     int _v;
10236     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
10237     _v = SWIG_CheckState(res);
10238     if (_v) {
10239       {
10240         int res = SWIG_AsVal_size_t(argv[1], NULL);
10241         _v = SWIG_CheckState(res);
10242       }
10243       if (_v) {
10244         void *vptr = 0;
10245         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Quad, 0);
10246         _v = SWIG_CheckState(res);
10247         if (_v) {
10248           return _wrap_VectorQuads_resize__SWIG_1(self, args);
10249         }
10250       }
10251     }
10252   }
10253
10254 fail:
10255   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads_resize'.\n"
10256     "  Possible C/C++ prototypes are:\n"
10257     "    std::vector< Hex::Quad * >::resize(std::vector< Hex::Quad * >::size_type)\n"
10258     "    std::vector< Hex::Quad * >::resize(std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
10259   return 0;
10260 }
10261
10262
10263 SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10264   PyObject *resultobj = 0;
10265   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10266   std::vector< Hex::Quad * >::iterator arg2 ;
10267   std::vector< Hex::Quad * >::value_type arg3 = (std::vector< Hex::Quad * >::value_type) 0 ;
10268   void *argp1 = 0 ;
10269   int res1 = 0 ;
10270   swig::SwigPyIterator *iter2 = 0 ;
10271   int res2 ;
10272   void *argp3 = 0 ;
10273   int res3 = 0 ;
10274   PyObject * obj0 = 0 ;
10275   PyObject * obj1 = 0 ;
10276   PyObject * obj2 = 0 ;
10277   std::vector< Hex::Quad * >::iterator result;
10278
10279   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorQuads_insert",&obj0,&obj1,&obj2)) SWIG_fail;
10280   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
10281   if (!SWIG_IsOK(res1)) {
10282     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10283   }
10284   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10285   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
10286   if (!SWIG_IsOK(res2) || !iter2) {
10287     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
10288   } else {
10289     swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
10290     if (iter_t) {
10291       arg2 = iter_t->get_current();
10292     } else {
10293       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
10294     }
10295   }
10296   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
10297   if (!SWIG_IsOK(res3)) {
10298     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::value_type""'");
10299   }
10300   arg3 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp3);
10301   result = std_vector_Sl_Hex_Quad_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
10302   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Quad * >::iterator & >(result)),
10303     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
10304   return resultobj;
10305 fail:
10306   return NULL;
10307 }
10308
10309
10310 SWIGINTERN PyObject *_wrap_VectorQuads_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10311   PyObject *resultobj = 0;
10312   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10313   std::vector< Hex::Quad * >::iterator arg2 ;
10314   std::vector< Hex::Quad * >::size_type arg3 ;
10315   std::vector< Hex::Quad * >::value_type arg4 = (std::vector< Hex::Quad * >::value_type) 0 ;
10316   void *argp1 = 0 ;
10317   int res1 = 0 ;
10318   swig::SwigPyIterator *iter2 = 0 ;
10319   int res2 ;
10320   size_t val3 ;
10321   int ecode3 = 0 ;
10322   void *argp4 = 0 ;
10323   int res4 = 0 ;
10324   PyObject * obj0 = 0 ;
10325   PyObject * obj1 = 0 ;
10326   PyObject * obj2 = 0 ;
10327   PyObject * obj3 = 0 ;
10328
10329   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorQuads_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10330   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
10331   if (!SWIG_IsOK(res1)) {
10332     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_insert" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10333   }
10334   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10335   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
10336   if (!SWIG_IsOK(res2) || !iter2) {
10337     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
10338   } else {
10339     swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter2);
10340     if (iter_t) {
10341       arg2 = iter_t->get_current();
10342     } else {
10343       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorQuads_insert" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::iterator""'");
10344     }
10345   }
10346   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
10347   if (!SWIG_IsOK(ecode3)) {
10348     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorQuads_insert" "', argument " "3"" of type '" "std::vector< Hex::Quad * >::size_type""'");
10349   }
10350   arg3 = static_cast< std::vector< Hex::Quad * >::size_type >(val3);
10351   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
10352   if (!SWIG_IsOK(res4)) {
10353     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorQuads_insert" "', argument " "4"" of type '" "std::vector< Hex::Quad * >::value_type""'");
10354   }
10355   arg4 = reinterpret_cast< std::vector< Hex::Quad * >::value_type >(argp4);
10356   std_vector_Sl_Hex_Quad_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
10357   resultobj = SWIG_Py_Void();
10358   return resultobj;
10359 fail:
10360   return NULL;
10361 }
10362
10363
10364 SWIGINTERN PyObject *_wrap_VectorQuads_insert(PyObject *self, PyObject *args) {
10365   Py_ssize_t argc;
10366   PyObject *argv[5] = {
10367     0
10368   };
10369   Py_ssize_t ii;
10370
10371   if (!PyTuple_Check(args)) SWIG_fail;
10372   argc = args ? PyObject_Length(args) : 0;
10373   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
10374     argv[ii] = PyTuple_GET_ITEM(args,ii);
10375   }
10376   if (argc == 3) {
10377     int _v;
10378     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
10379     _v = SWIG_CheckState(res);
10380     if (_v) {
10381       swig::SwigPyIterator *iter = 0;
10382       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
10383       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
10384       if (_v) {
10385         void *vptr = 0;
10386         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Quad, 0);
10387         _v = SWIG_CheckState(res);
10388         if (_v) {
10389           return _wrap_VectorQuads_insert__SWIG_0(self, args);
10390         }
10391       }
10392     }
10393   }
10394   if (argc == 4) {
10395     int _v;
10396     int res = swig::asptr(argv[0], (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > >**)(0));
10397     _v = SWIG_CheckState(res);
10398     if (_v) {
10399       swig::SwigPyIterator *iter = 0;
10400       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
10401       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Quad * >::iterator > *>(iter) != 0));
10402       if (_v) {
10403         {
10404           int res = SWIG_AsVal_size_t(argv[2], NULL);
10405           _v = SWIG_CheckState(res);
10406         }
10407         if (_v) {
10408           void *vptr = 0;
10409           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Quad, 0);
10410           _v = SWIG_CheckState(res);
10411           if (_v) {
10412             return _wrap_VectorQuads_insert__SWIG_1(self, args);
10413           }
10414         }
10415       }
10416     }
10417   }
10418
10419 fail:
10420   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorQuads_insert'.\n"
10421     "  Possible C/C++ prototypes are:\n"
10422     "    std::vector< Hex::Quad * >::insert(std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::value_type)\n"
10423     "    std::vector< Hex::Quad * >::insert(std::vector< Hex::Quad * >::iterator,std::vector< Hex::Quad * >::size_type,std::vector< Hex::Quad * >::value_type)\n");
10424   return 0;
10425 }
10426
10427
10428 SWIGINTERN PyObject *_wrap_VectorQuads_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10429   PyObject *resultobj = 0;
10430   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10431   std::vector< Hex::Quad * >::size_type arg2 ;
10432   void *argp1 = 0 ;
10433   int res1 = 0 ;
10434   size_t val2 ;
10435   int ecode2 = 0 ;
10436   PyObject * obj0 = 0 ;
10437   PyObject * obj1 = 0 ;
10438
10439   if (!PyArg_ParseTuple(args,(char *)"OO:VectorQuads_reserve",&obj0,&obj1)) SWIG_fail;
10440   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
10441   if (!SWIG_IsOK(res1)) {
10442     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_reserve" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10443   }
10444   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10445   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10446   if (!SWIG_IsOK(ecode2)) {
10447     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorQuads_reserve" "', argument " "2"" of type '" "std::vector< Hex::Quad * >::size_type""'");
10448   }
10449   arg2 = static_cast< std::vector< Hex::Quad * >::size_type >(val2);
10450   (arg1)->reserve(arg2);
10451   resultobj = SWIG_Py_Void();
10452   return resultobj;
10453 fail:
10454   return NULL;
10455 }
10456
10457
10458 SWIGINTERN PyObject *_wrap_VectorQuads_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10459   PyObject *resultobj = 0;
10460   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10461   void *argp1 = 0 ;
10462   int res1 = 0 ;
10463   PyObject * obj0 = 0 ;
10464   std::vector< Hex::Quad * >::size_type result;
10465
10466   if (!PyArg_ParseTuple(args,(char *)"O:VectorQuads_capacity",&obj0)) SWIG_fail;
10467   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0 |  0 );
10468   if (!SWIG_IsOK(res1)) {
10469     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorQuads_capacity" "', argument " "1"" of type '" "std::vector< Hex::Quad * > const *""'");
10470   }
10471   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10472   result = ((std::vector< Hex::Quad * > const *)arg1)->capacity();
10473   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10474   return resultobj;
10475 fail:
10476   return NULL;
10477 }
10478
10479
10480 SWIGINTERN PyObject *_wrap_delete_VectorQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10481   PyObject *resultobj = 0;
10482   std::vector< Hex::Quad * > *arg1 = (std::vector< Hex::Quad * > *) 0 ;
10483   void *argp1 = 0 ;
10484   int res1 = 0 ;
10485   PyObject * obj0 = 0 ;
10486
10487   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorQuads",&obj0)) SWIG_fail;
10488   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_POINTER_DISOWN |  0 );
10489   if (!SWIG_IsOK(res1)) {
10490     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorQuads" "', argument " "1"" of type '" "std::vector< Hex::Quad * > *""'");
10491   }
10492   arg1 = reinterpret_cast< std::vector< Hex::Quad * > * >(argp1);
10493   delete arg1;
10494   resultobj = SWIG_Py_Void();
10495   return resultobj;
10496 fail:
10497   return NULL;
10498 }
10499
10500
10501 SWIGINTERN PyObject *VectorQuads_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10502   PyObject *obj;
10503   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
10504   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, SWIG_NewClientData(obj));
10505   return SWIG_Py_Void();
10506 }
10507
10508 SWIGINTERN PyObject *_wrap_VectorEdges_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10509   PyObject *resultobj = 0;
10510   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10511   PyObject **arg2 = (PyObject **) 0 ;
10512   void *argp1 = 0 ;
10513   int res1 = 0 ;
10514   PyObject * obj0 = 0 ;
10515   swig::SwigPyIterator *result = 0 ;
10516
10517   arg2 = &obj0;
10518   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_iterator",&obj0)) SWIG_fail;
10519   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10520   if (!SWIG_IsOK(res1)) {
10521     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_iterator" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10522   }
10523   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10524   result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Edge_Sm__Sg__iterator(arg1,arg2);
10525   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
10526   return resultobj;
10527 fail:
10528   return NULL;
10529 }
10530
10531
10532 SWIGINTERN PyObject *_wrap_VectorEdges___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10533   PyObject *resultobj = 0;
10534   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10535   void *argp1 = 0 ;
10536   int res1 = 0 ;
10537   PyObject * obj0 = 0 ;
10538   bool result;
10539
10540   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___nonzero__",&obj0)) SWIG_fail;
10541   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10542   if (!SWIG_IsOK(res1)) {
10543     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10544   }
10545   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10546   result = (bool)std_vector_Sl_Hex_Edge_Sm__Sg____nonzero__((std::vector< Hex::Edge * > const *)arg1);
10547   resultobj = SWIG_From_bool(static_cast< bool >(result));
10548   return resultobj;
10549 fail:
10550   return NULL;
10551 }
10552
10553
10554 SWIGINTERN PyObject *_wrap_VectorEdges___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10555   PyObject *resultobj = 0;
10556   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10557   void *argp1 = 0 ;
10558   int res1 = 0 ;
10559   PyObject * obj0 = 0 ;
10560   bool result;
10561
10562   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___bool__",&obj0)) SWIG_fail;
10563   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10564   if (!SWIG_IsOK(res1)) {
10565     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___bool__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10566   }
10567   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10568   result = (bool)std_vector_Sl_Hex_Edge_Sm__Sg____bool__((std::vector< Hex::Edge * > const *)arg1);
10569   resultobj = SWIG_From_bool(static_cast< bool >(result));
10570   return resultobj;
10571 fail:
10572   return NULL;
10573 }
10574
10575
10576 SWIGINTERN PyObject *_wrap_VectorEdges___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10577   PyObject *resultobj = 0;
10578   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10579   void *argp1 = 0 ;
10580   int res1 = 0 ;
10581   PyObject * obj0 = 0 ;
10582   std::vector< Hex::Edge * >::size_type result;
10583
10584   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges___len__",&obj0)) SWIG_fail;
10585   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10586   if (!SWIG_IsOK(res1)) {
10587     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___len__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
10588   }
10589   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10590   result = std_vector_Sl_Hex_Edge_Sm__Sg____len__((std::vector< Hex::Edge * > const *)arg1);
10591   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10592   return resultobj;
10593 fail:
10594   return NULL;
10595 }
10596
10597
10598 SWIGINTERN PyObject *_wrap_VectorEdges___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10599   PyObject *resultobj = 0;
10600   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10601   std::vector< Hex::Edge * >::difference_type arg2 ;
10602   std::vector< Hex::Edge * >::difference_type arg3 ;
10603   void *argp1 = 0 ;
10604   int res1 = 0 ;
10605   ptrdiff_t val2 ;
10606   int ecode2 = 0 ;
10607   ptrdiff_t val3 ;
10608   int ecode3 = 0 ;
10609   PyObject * obj0 = 0 ;
10610   PyObject * obj1 = 0 ;
10611   PyObject * obj2 = 0 ;
10612   std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *result = 0 ;
10613
10614   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
10615   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10616   if (!SWIG_IsOK(res1)) {
10617     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10618   }
10619   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10620   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10621   if (!SWIG_IsOK(ecode2)) {
10622     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10623   }
10624   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
10625   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10626   if (!SWIG_IsOK(ecode3)) {
10627     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10628   }
10629   arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
10630   try {
10631     result = (std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *)std_vector_Sl_Hex_Edge_Sm__Sg____getslice__(arg1,arg2,arg3);
10632   }
10633   catch(std::out_of_range &_e) {
10634     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10635   }
10636   catch(std::invalid_argument &_e) {
10637     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10638   }
10639
10640   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_OWN |  0 );
10641   return resultobj;
10642 fail:
10643   return NULL;
10644 }
10645
10646
10647 SWIGINTERN PyObject *_wrap_VectorEdges___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10648   PyObject *resultobj = 0;
10649   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10650   std::vector< Hex::Edge * >::difference_type arg2 ;
10651   std::vector< Hex::Edge * >::difference_type arg3 ;
10652   void *argp1 = 0 ;
10653   int res1 = 0 ;
10654   ptrdiff_t val2 ;
10655   int ecode2 = 0 ;
10656   ptrdiff_t val3 ;
10657   int ecode3 = 0 ;
10658   PyObject * obj0 = 0 ;
10659   PyObject * obj1 = 0 ;
10660   PyObject * obj2 = 0 ;
10661
10662   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
10663   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10664   if (!SWIG_IsOK(res1)) {
10665     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10666   }
10667   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10668   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10669   if (!SWIG_IsOK(ecode2)) {
10670     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10671   }
10672   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
10673   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10674   if (!SWIG_IsOK(ecode3)) {
10675     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10676   }
10677   arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
10678   try {
10679     std_vector_Sl_Hex_Edge_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
10680   }
10681   catch(std::out_of_range &_e) {
10682     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10683   }
10684   catch(std::invalid_argument &_e) {
10685     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10686   }
10687
10688   resultobj = SWIG_Py_Void();
10689   return resultobj;
10690 fail:
10691   return NULL;
10692 }
10693
10694
10695 SWIGINTERN PyObject *_wrap_VectorEdges___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10696   PyObject *resultobj = 0;
10697   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10698   std::vector< Hex::Edge * >::difference_type arg2 ;
10699   std::vector< Hex::Edge * >::difference_type arg3 ;
10700   std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *arg4 = 0 ;
10701   void *argp1 = 0 ;
10702   int res1 = 0 ;
10703   ptrdiff_t val2 ;
10704   int ecode2 = 0 ;
10705   ptrdiff_t val3 ;
10706   int ecode3 = 0 ;
10707   int res4 = SWIG_OLDOBJ ;
10708   PyObject * obj0 = 0 ;
10709   PyObject * obj1 = 0 ;
10710   PyObject * obj2 = 0 ;
10711   PyObject * obj3 = 0 ;
10712
10713   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10714   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10715   if (!SWIG_IsOK(res1)) {
10716     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10717   }
10718   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10719   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10720   if (!SWIG_IsOK(ecode2)) {
10721     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10722   }
10723   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
10724   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10725   if (!SWIG_IsOK(ecode3)) {
10726     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10727   }
10728   arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
10729   {
10730     std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
10731     res4 = swig::asptr(obj3, &ptr);
10732     if (!SWIG_IsOK(res4)) {
10733       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
10734     }
10735     if (!ptr) {
10736       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 &""'");
10737     }
10738     arg4 = ptr;
10739   }
10740   try {
10741     std_vector_Sl_Hex_Edge_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)*arg4);
10742   }
10743   catch(std::out_of_range &_e) {
10744     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10745   }
10746   catch(std::invalid_argument &_e) {
10747     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10748   }
10749
10750   resultobj = SWIG_Py_Void();
10751   if (SWIG_IsNewObj(res4)) delete arg4;
10752   return resultobj;
10753 fail:
10754   if (SWIG_IsNewObj(res4)) delete arg4;
10755   return NULL;
10756 }
10757
10758
10759 SWIGINTERN PyObject *_wrap_VectorEdges___setslice__(PyObject *self, PyObject *args) {
10760   Py_ssize_t argc;
10761   PyObject *argv[5] = {
10762     0
10763   };
10764   Py_ssize_t ii;
10765
10766   if (!PyTuple_Check(args)) SWIG_fail;
10767   argc = args ? PyObject_Length(args) : 0;
10768   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
10769     argv[ii] = PyTuple_GET_ITEM(args,ii);
10770   }
10771   if (argc == 3) {
10772     int _v;
10773     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10774     _v = SWIG_CheckState(res);
10775     if (_v) {
10776       {
10777         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
10778         _v = SWIG_CheckState(res);
10779       }
10780       if (_v) {
10781         {
10782           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
10783           _v = SWIG_CheckState(res);
10784         }
10785         if (_v) {
10786           return _wrap_VectorEdges___setslice____SWIG_0(self, args);
10787         }
10788       }
10789     }
10790   }
10791   if (argc == 4) {
10792     int _v;
10793     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10794     _v = SWIG_CheckState(res);
10795     if (_v) {
10796       {
10797         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
10798         _v = SWIG_CheckState(res);
10799       }
10800       if (_v) {
10801         {
10802           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
10803           _v = SWIG_CheckState(res);
10804         }
10805         if (_v) {
10806           int res = swig::asptr(argv[3], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
10807           _v = SWIG_CheckState(res);
10808           if (_v) {
10809             return _wrap_VectorEdges___setslice____SWIG_1(self, args);
10810           }
10811         }
10812       }
10813     }
10814   }
10815
10816 fail:
10817   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges___setslice__'.\n"
10818     "  Possible C/C++ prototypes are:\n"
10819     "    std::vector< Hex::Edge * >::__setslice__(std::vector< Hex::Edge * >::difference_type,std::vector< Hex::Edge * >::difference_type)\n"
10820     "    std::vector< Hex::Edge * >::__setslice__(std::vector< Hex::Edge * >::difference_type,std::vector< Hex::Edge * >::difference_type,std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)\n");
10821   return 0;
10822 }
10823
10824
10825 SWIGINTERN PyObject *_wrap_VectorEdges___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10826   PyObject *resultobj = 0;
10827   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10828   std::vector< Hex::Edge * >::difference_type arg2 ;
10829   std::vector< Hex::Edge * >::difference_type arg3 ;
10830   void *argp1 = 0 ;
10831   int res1 = 0 ;
10832   ptrdiff_t val2 ;
10833   int ecode2 = 0 ;
10834   ptrdiff_t val3 ;
10835   int ecode3 = 0 ;
10836   PyObject * obj0 = 0 ;
10837   PyObject * obj1 = 0 ;
10838   PyObject * obj2 = 0 ;
10839
10840   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
10841   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10842   if (!SWIG_IsOK(res1)) {
10843     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10844   }
10845   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10846   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10847   if (!SWIG_IsOK(ecode2)) {
10848     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10849   }
10850   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
10851   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
10852   if (!SWIG_IsOK(ecode3)) {
10853     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10854   }
10855   arg3 = static_cast< std::vector< Hex::Edge * >::difference_type >(val3);
10856   try {
10857     std_vector_Sl_Hex_Edge_Sm__Sg____delslice__(arg1,arg2,arg3);
10858   }
10859   catch(std::out_of_range &_e) {
10860     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10861   }
10862   catch(std::invalid_argument &_e) {
10863     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10864   }
10865
10866   resultobj = SWIG_Py_Void();
10867   return resultobj;
10868 fail:
10869   return NULL;
10870 }
10871
10872
10873 SWIGINTERN PyObject *_wrap_VectorEdges___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10874   PyObject *resultobj = 0;
10875   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10876   std::vector< Hex::Edge * >::difference_type arg2 ;
10877   void *argp1 = 0 ;
10878   int res1 = 0 ;
10879   ptrdiff_t val2 ;
10880   int ecode2 = 0 ;
10881   PyObject * obj0 = 0 ;
10882   PyObject * obj1 = 0 ;
10883
10884   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___delitem__",&obj0,&obj1)) SWIG_fail;
10885   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10886   if (!SWIG_IsOK(res1)) {
10887     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10888   }
10889   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10890   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
10891   if (!SWIG_IsOK(ecode2)) {
10892     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
10893   }
10894   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
10895   try {
10896     std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_0(arg1,arg2);
10897   }
10898   catch(std::out_of_range &_e) {
10899     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10900   }
10901   catch(std::invalid_argument &_e) {
10902     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10903   }
10904
10905   resultobj = SWIG_Py_Void();
10906   return resultobj;
10907 fail:
10908   return NULL;
10909 }
10910
10911
10912 SWIGINTERN PyObject *_wrap_VectorEdges___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10913   PyObject *resultobj = 0;
10914   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10915   PySliceObject *arg2 = (PySliceObject *) 0 ;
10916   void *argp1 = 0 ;
10917   int res1 = 0 ;
10918   PyObject * obj0 = 0 ;
10919   PyObject * obj1 = 0 ;
10920   std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *result = 0 ;
10921
10922   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___getitem__",&obj0,&obj1)) SWIG_fail;
10923   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10924   if (!SWIG_IsOK(res1)) {
10925     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10926   }
10927   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10928   {
10929     if (!PySlice_Check(obj1)) {
10930       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
10931     }
10932     arg2 = (PySliceObject *) obj1;
10933   }
10934   try {
10935     result = (std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *)std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_0(arg1,arg2);
10936   }
10937   catch(std::out_of_range &_e) {
10938     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10939   }
10940   catch(std::invalid_argument &_e) {
10941     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10942   }
10943
10944   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_OWN |  0 );
10945   return resultobj;
10946 fail:
10947   return NULL;
10948 }
10949
10950
10951 SWIGINTERN PyObject *_wrap_VectorEdges___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10952   PyObject *resultobj = 0;
10953   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
10954   PySliceObject *arg2 = (PySliceObject *) 0 ;
10955   std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *arg3 = 0 ;
10956   void *argp1 = 0 ;
10957   int res1 = 0 ;
10958   int res3 = SWIG_OLDOBJ ;
10959   PyObject * obj0 = 0 ;
10960   PyObject * obj1 = 0 ;
10961   PyObject * obj2 = 0 ;
10962
10963   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
10964   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
10965   if (!SWIG_IsOK(res1)) {
10966     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
10967   }
10968   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
10969   {
10970     if (!PySlice_Check(obj1)) {
10971       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
10972     }
10973     arg2 = (PySliceObject *) obj1;
10974   }
10975   {
10976     std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
10977     res3 = swig::asptr(obj2, &ptr);
10978     if (!SWIG_IsOK(res3)) {
10979       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
10980     }
10981     if (!ptr) {
10982       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &""'");
10983     }
10984     arg3 = ptr;
10985   }
10986   try {
10987     std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)*arg3);
10988   }
10989   catch(std::out_of_range &_e) {
10990     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
10991   }
10992   catch(std::invalid_argument &_e) {
10993     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
10994   }
10995
10996   resultobj = SWIG_Py_Void();
10997   if (SWIG_IsNewObj(res3)) delete arg3;
10998   return resultobj;
10999 fail:
11000   if (SWIG_IsNewObj(res3)) delete arg3;
11001   return NULL;
11002 }
11003
11004
11005 SWIGINTERN PyObject *_wrap_VectorEdges___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11006   PyObject *resultobj = 0;
11007   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11008   PySliceObject *arg2 = (PySliceObject *) 0 ;
11009   void *argp1 = 0 ;
11010   int res1 = 0 ;
11011   PyObject * obj0 = 0 ;
11012   PyObject * obj1 = 0 ;
11013
11014   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___setitem__",&obj0,&obj1)) SWIG_fail;
11015   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11016   if (!SWIG_IsOK(res1)) {
11017     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11018   }
11019   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11020   {
11021     if (!PySlice_Check(obj1)) {
11022       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
11023     }
11024     arg2 = (PySliceObject *) obj1;
11025   }
11026   try {
11027     std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_1(arg1,arg2);
11028   }
11029   catch(std::out_of_range &_e) {
11030     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11031   }
11032   catch(std::invalid_argument &_e) {
11033     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
11034   }
11035
11036   resultobj = SWIG_Py_Void();
11037   return resultobj;
11038 fail:
11039   return NULL;
11040 }
11041
11042
11043 SWIGINTERN PyObject *_wrap_VectorEdges___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11044   PyObject *resultobj = 0;
11045   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11046   PySliceObject *arg2 = (PySliceObject *) 0 ;
11047   void *argp1 = 0 ;
11048   int res1 = 0 ;
11049   PyObject * obj0 = 0 ;
11050   PyObject * obj1 = 0 ;
11051
11052   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___delitem__",&obj0,&obj1)) SWIG_fail;
11053   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11054   if (!SWIG_IsOK(res1)) {
11055     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11056   }
11057   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11058   {
11059     if (!PySlice_Check(obj1)) {
11060       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
11061     }
11062     arg2 = (PySliceObject *) obj1;
11063   }
11064   try {
11065     std_vector_Sl_Hex_Edge_Sm__Sg____delitem____SWIG_1(arg1,arg2);
11066   }
11067   catch(std::out_of_range &_e) {
11068     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11069   }
11070   catch(std::invalid_argument &_e) {
11071     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
11072   }
11073
11074   resultobj = SWIG_Py_Void();
11075   return resultobj;
11076 fail:
11077   return NULL;
11078 }
11079
11080
11081 SWIGINTERN PyObject *_wrap_VectorEdges___delitem__(PyObject *self, PyObject *args) {
11082   Py_ssize_t argc;
11083   PyObject *argv[3] = {
11084     0
11085   };
11086   Py_ssize_t ii;
11087
11088   if (!PyTuple_Check(args)) SWIG_fail;
11089   argc = args ? PyObject_Length(args) : 0;
11090   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
11091     argv[ii] = PyTuple_GET_ITEM(args,ii);
11092   }
11093   if (argc == 2) {
11094     int _v;
11095     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11096     _v = SWIG_CheckState(res);
11097     if (_v) {
11098       {
11099         _v = PySlice_Check(argv[1]);
11100       }
11101       if (_v) {
11102         return _wrap_VectorEdges___delitem____SWIG_1(self, args);
11103       }
11104     }
11105   }
11106   if (argc == 2) {
11107     int _v;
11108     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11109     _v = SWIG_CheckState(res);
11110     if (_v) {
11111       {
11112         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
11113         _v = SWIG_CheckState(res);
11114       }
11115       if (_v) {
11116         return _wrap_VectorEdges___delitem____SWIG_0(self, args);
11117       }
11118     }
11119   }
11120
11121 fail:
11122   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges___delitem__'.\n"
11123     "  Possible C/C++ prototypes are:\n"
11124     "    std::vector< Hex::Edge * >::__delitem__(std::vector< Hex::Edge * >::difference_type)\n"
11125     "    std::vector< Hex::Edge * >::__delitem__(PySliceObject *)\n");
11126   return 0;
11127 }
11128
11129
11130 SWIGINTERN PyObject *_wrap_VectorEdges___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11131   PyObject *resultobj = 0;
11132   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11133   std::vector< Hex::Edge * >::difference_type arg2 ;
11134   void *argp1 = 0 ;
11135   int res1 = 0 ;
11136   ptrdiff_t val2 ;
11137   int ecode2 = 0 ;
11138   PyObject * obj0 = 0 ;
11139   PyObject * obj1 = 0 ;
11140   std::vector< Hex::Edge * >::value_type result;
11141
11142   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges___getitem__",&obj0,&obj1)) SWIG_fail;
11143   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11144   if (!SWIG_IsOK(res1)) {
11145     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11146   }
11147   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11148   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11149   if (!SWIG_IsOK(ecode2)) {
11150     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
11151   }
11152   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
11153   try {
11154     result = (std::vector< Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg____getitem____SWIG_1(arg1,arg2);
11155   }
11156   catch(std::out_of_range &_e) {
11157     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11158   }
11159
11160   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
11161   return resultobj;
11162 fail:
11163   return NULL;
11164 }
11165
11166
11167 SWIGINTERN PyObject *_wrap_VectorEdges___getitem__(PyObject *self, PyObject *args) {
11168   Py_ssize_t argc;
11169   PyObject *argv[3] = {
11170     0
11171   };
11172   Py_ssize_t ii;
11173
11174   if (!PyTuple_Check(args)) SWIG_fail;
11175   argc = args ? PyObject_Length(args) : 0;
11176   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
11177     argv[ii] = PyTuple_GET_ITEM(args,ii);
11178   }
11179   if (argc == 2) {
11180     int _v;
11181     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11182     _v = SWIG_CheckState(res);
11183     if (_v) {
11184       {
11185         _v = PySlice_Check(argv[1]);
11186       }
11187       if (_v) {
11188         return _wrap_VectorEdges___getitem____SWIG_0(self, args);
11189       }
11190     }
11191   }
11192   if (argc == 2) {
11193     int _v;
11194     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11195     _v = SWIG_CheckState(res);
11196     if (_v) {
11197       {
11198         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
11199         _v = SWIG_CheckState(res);
11200       }
11201       if (_v) {
11202         return _wrap_VectorEdges___getitem____SWIG_1(self, args);
11203       }
11204     }
11205   }
11206
11207 fail:
11208   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges___getitem__'.\n"
11209     "  Possible C/C++ prototypes are:\n"
11210     "    std::vector< Hex::Edge * >::__getitem__(PySliceObject *)\n"
11211     "    std::vector< Hex::Edge * >::__getitem__(std::vector< Hex::Edge * >::difference_type)\n");
11212   return 0;
11213 }
11214
11215
11216 SWIGINTERN PyObject *_wrap_VectorEdges___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11217   PyObject *resultobj = 0;
11218   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11219   std::vector< Hex::Edge * >::difference_type arg2 ;
11220   std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
11221   void *argp1 = 0 ;
11222   int res1 = 0 ;
11223   ptrdiff_t val2 ;
11224   int ecode2 = 0 ;
11225   void *argp3 = 0 ;
11226   int res3 = 0 ;
11227   PyObject * obj0 = 0 ;
11228   PyObject * obj1 = 0 ;
11229   PyObject * obj2 = 0 ;
11230
11231   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
11232   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11233   if (!SWIG_IsOK(res1)) {
11234     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11235   }
11236   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11237   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
11238   if (!SWIG_IsOK(ecode2)) {
11239     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::difference_type""'");
11240   }
11241   arg2 = static_cast< std::vector< Hex::Edge * >::difference_type >(val2);
11242   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
11243   if (!SWIG_IsOK(res3)) {
11244     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
11245   }
11246   arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
11247   try {
11248     std_vector_Sl_Hex_Edge_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
11249   }
11250   catch(std::out_of_range &_e) {
11251     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11252   }
11253
11254   resultobj = SWIG_Py_Void();
11255   return resultobj;
11256 fail:
11257   return NULL;
11258 }
11259
11260
11261 SWIGINTERN PyObject *_wrap_VectorEdges___setitem__(PyObject *self, PyObject *args) {
11262   Py_ssize_t argc;
11263   PyObject *argv[4] = {
11264     0
11265   };
11266   Py_ssize_t ii;
11267
11268   if (!PyTuple_Check(args)) SWIG_fail;
11269   argc = args ? PyObject_Length(args) : 0;
11270   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
11271     argv[ii] = PyTuple_GET_ITEM(args,ii);
11272   }
11273   if (argc == 2) {
11274     int _v;
11275     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11276     _v = SWIG_CheckState(res);
11277     if (_v) {
11278       {
11279         _v = PySlice_Check(argv[1]);
11280       }
11281       if (_v) {
11282         return _wrap_VectorEdges___setitem____SWIG_1(self, args);
11283       }
11284     }
11285   }
11286   if (argc == 3) {
11287     int _v;
11288     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11289     _v = SWIG_CheckState(res);
11290     if (_v) {
11291       {
11292         _v = PySlice_Check(argv[1]);
11293       }
11294       if (_v) {
11295         int res = swig::asptr(argv[2], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11296         _v = SWIG_CheckState(res);
11297         if (_v) {
11298           return _wrap_VectorEdges___setitem____SWIG_0(self, args);
11299         }
11300       }
11301     }
11302   }
11303   if (argc == 3) {
11304     int _v;
11305     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11306     _v = SWIG_CheckState(res);
11307     if (_v) {
11308       {
11309         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
11310         _v = SWIG_CheckState(res);
11311       }
11312       if (_v) {
11313         void *vptr = 0;
11314         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
11315         _v = SWIG_CheckState(res);
11316         if (_v) {
11317           return _wrap_VectorEdges___setitem____SWIG_2(self, args);
11318         }
11319       }
11320     }
11321   }
11322
11323 fail:
11324   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges___setitem__'.\n"
11325     "  Possible C/C++ prototypes are:\n"
11326     "    std::vector< Hex::Edge * >::__setitem__(PySliceObject *,std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > const &)\n"
11327     "    std::vector< Hex::Edge * >::__setitem__(PySliceObject *)\n"
11328     "    std::vector< Hex::Edge * >::__setitem__(std::vector< Hex::Edge * >::difference_type,std::vector< Hex::Edge * >::value_type)\n");
11329   return 0;
11330 }
11331
11332
11333 SWIGINTERN PyObject *_wrap_VectorEdges_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11334   PyObject *resultobj = 0;
11335   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11336   void *argp1 = 0 ;
11337   int res1 = 0 ;
11338   PyObject * obj0 = 0 ;
11339   std::vector< Hex::Edge * >::value_type result;
11340
11341   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop",&obj0)) SWIG_fail;
11342   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11343   if (!SWIG_IsOK(res1)) {
11344     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11345   }
11346   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11347   try {
11348     result = (std::vector< Hex::Edge * >::value_type)std_vector_Sl_Hex_Edge_Sm__Sg__pop(arg1);
11349   }
11350   catch(std::out_of_range &_e) {
11351     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
11352   }
11353
11354   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
11355   return resultobj;
11356 fail:
11357   return NULL;
11358 }
11359
11360
11361 SWIGINTERN PyObject *_wrap_VectorEdges_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11362   PyObject *resultobj = 0;
11363   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11364   std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
11365   void *argp1 = 0 ;
11366   int res1 = 0 ;
11367   void *argp2 = 0 ;
11368   int res2 = 0 ;
11369   PyObject * obj0 = 0 ;
11370   PyObject * obj1 = 0 ;
11371
11372   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_append",&obj0,&obj1)) SWIG_fail;
11373   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11374   if (!SWIG_IsOK(res1)) {
11375     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_append" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11376   }
11377   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11378   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
11379   if (!SWIG_IsOK(res2)) {
11380     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_append" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
11381   }
11382   arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
11383   std_vector_Sl_Hex_Edge_Sm__Sg__append(arg1,arg2);
11384   resultobj = SWIG_Py_Void();
11385   return resultobj;
11386 fail:
11387   return NULL;
11388 }
11389
11390
11391 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11392   PyObject *resultobj = 0;
11393   std::vector< Hex::Edge * > *result = 0 ;
11394
11395   if (!PyArg_ParseTuple(args,(char *)":new_VectorEdges")) SWIG_fail;
11396   result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >();
11397   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
11398   return resultobj;
11399 fail:
11400   return NULL;
11401 }
11402
11403
11404 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11405   PyObject *resultobj = 0;
11406   std::vector< Hex::Edge * > *arg1 = 0 ;
11407   int res1 = SWIG_OLDOBJ ;
11408   PyObject * obj0 = 0 ;
11409   std::vector< Hex::Edge * > *result = 0 ;
11410
11411   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
11412   {
11413     std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
11414     res1 = swig::asptr(obj0, &ptr);
11415     if (!SWIG_IsOK(res1)) {
11416       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const &""'");
11417     }
11418     if (!ptr) {
11419       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const &""'");
11420     }
11421     arg1 = ptr;
11422   }
11423   result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >((std::vector< Hex::Edge * > const &)*arg1);
11424   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
11425   if (SWIG_IsNewObj(res1)) delete arg1;
11426   return resultobj;
11427 fail:
11428   if (SWIG_IsNewObj(res1)) delete arg1;
11429   return NULL;
11430 }
11431
11432
11433 SWIGINTERN PyObject *_wrap_VectorEdges_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11434   PyObject *resultobj = 0;
11435   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11436   void *argp1 = 0 ;
11437   int res1 = 0 ;
11438   PyObject * obj0 = 0 ;
11439   bool result;
11440
11441   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_empty",&obj0)) SWIG_fail;
11442   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11443   if (!SWIG_IsOK(res1)) {
11444     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_empty" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
11445   }
11446   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11447   result = (bool)((std::vector< Hex::Edge * > const *)arg1)->empty();
11448   resultobj = SWIG_From_bool(static_cast< bool >(result));
11449   return resultobj;
11450 fail:
11451   return NULL;
11452 }
11453
11454
11455 SWIGINTERN PyObject *_wrap_VectorEdges_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11456   PyObject *resultobj = 0;
11457   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11458   void *argp1 = 0 ;
11459   int res1 = 0 ;
11460   PyObject * obj0 = 0 ;
11461   std::vector< Hex::Edge * >::size_type result;
11462
11463   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_size",&obj0)) SWIG_fail;
11464   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11465   if (!SWIG_IsOK(res1)) {
11466     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_size" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
11467   }
11468   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11469   result = ((std::vector< Hex::Edge * > const *)arg1)->size();
11470   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11471   return resultobj;
11472 fail:
11473   return NULL;
11474 }
11475
11476
11477 SWIGINTERN PyObject *_wrap_VectorEdges_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11478   PyObject *resultobj = 0;
11479   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11480   std::vector< Hex::Edge * > *arg2 = 0 ;
11481   void *argp1 = 0 ;
11482   int res1 = 0 ;
11483   void *argp2 = 0 ;
11484   int res2 = 0 ;
11485   PyObject * obj0 = 0 ;
11486   PyObject * obj1 = 0 ;
11487
11488   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_swap",&obj0,&obj1)) SWIG_fail;
11489   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11490   if (!SWIG_IsOK(res1)) {
11491     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_swap" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11492   }
11493   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11494   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t,  0 );
11495   if (!SWIG_IsOK(res2)) {
11496     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector< Hex::Edge * > &""'");
11497   }
11498   if (!argp2) {
11499     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorEdges_swap" "', argument " "2"" of type '" "std::vector< Hex::Edge * > &""'");
11500   }
11501   arg2 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp2);
11502   (arg1)->swap(*arg2);
11503   resultobj = SWIG_Py_Void();
11504   return resultobj;
11505 fail:
11506   return NULL;
11507 }
11508
11509
11510 SWIGINTERN PyObject *_wrap_VectorEdges_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11511   PyObject *resultobj = 0;
11512   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11513   void *argp1 = 0 ;
11514   int res1 = 0 ;
11515   PyObject * obj0 = 0 ;
11516   std::vector< Hex::Edge * >::iterator result;
11517
11518   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_begin",&obj0)) SWIG_fail;
11519   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11520   if (!SWIG_IsOK(res1)) {
11521     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_begin" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11522   }
11523   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11524   result = (arg1)->begin();
11525   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
11526     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11527   return resultobj;
11528 fail:
11529   return NULL;
11530 }
11531
11532
11533 SWIGINTERN PyObject *_wrap_VectorEdges_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11534   PyObject *resultobj = 0;
11535   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11536   void *argp1 = 0 ;
11537   int res1 = 0 ;
11538   PyObject * obj0 = 0 ;
11539   std::vector< Hex::Edge * >::iterator result;
11540
11541   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_end",&obj0)) SWIG_fail;
11542   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11543   if (!SWIG_IsOK(res1)) {
11544     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_end" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11545   }
11546   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11547   result = (arg1)->end();
11548   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
11549     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11550   return resultobj;
11551 fail:
11552   return NULL;
11553 }
11554
11555
11556 SWIGINTERN PyObject *_wrap_VectorEdges_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11557   PyObject *resultobj = 0;
11558   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11559   void *argp1 = 0 ;
11560   int res1 = 0 ;
11561   PyObject * obj0 = 0 ;
11562   std::vector< Hex::Edge * >::reverse_iterator result;
11563
11564   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rbegin",&obj0)) SWIG_fail;
11565   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11566   if (!SWIG_IsOK(res1)) {
11567     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11568   }
11569   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11570   result = (arg1)->rbegin();
11571   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::reverse_iterator & >(result)),
11572     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11573   return resultobj;
11574 fail:
11575   return NULL;
11576 }
11577
11578
11579 SWIGINTERN PyObject *_wrap_VectorEdges_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11580   PyObject *resultobj = 0;
11581   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11582   void *argp1 = 0 ;
11583   int res1 = 0 ;
11584   PyObject * obj0 = 0 ;
11585   std::vector< Hex::Edge * >::reverse_iterator result;
11586
11587   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_rend",&obj0)) SWIG_fail;
11588   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11589   if (!SWIG_IsOK(res1)) {
11590     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_rend" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11591   }
11592   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11593   result = (arg1)->rend();
11594   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::reverse_iterator & >(result)),
11595     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11596   return resultobj;
11597 fail:
11598   return NULL;
11599 }
11600
11601
11602 SWIGINTERN PyObject *_wrap_VectorEdges_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11603   PyObject *resultobj = 0;
11604   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11605   void *argp1 = 0 ;
11606   int res1 = 0 ;
11607   PyObject * obj0 = 0 ;
11608
11609   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_clear",&obj0)) SWIG_fail;
11610   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11611   if (!SWIG_IsOK(res1)) {
11612     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_clear" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11613   }
11614   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11615   (arg1)->clear();
11616   resultobj = SWIG_Py_Void();
11617   return resultobj;
11618 fail:
11619   return NULL;
11620 }
11621
11622
11623 SWIGINTERN PyObject *_wrap_VectorEdges_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11624   PyObject *resultobj = 0;
11625   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11626   void *argp1 = 0 ;
11627   int res1 = 0 ;
11628   PyObject * obj0 = 0 ;
11629   SwigValueWrapper< std::allocator< Hex::Edge * > > result;
11630
11631   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_get_allocator",&obj0)) SWIG_fail;
11632   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11633   if (!SWIG_IsOK(res1)) {
11634     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
11635   }
11636   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11637   result = ((std::vector< Hex::Edge * > const *)arg1)->get_allocator();
11638   resultobj = SWIG_NewPointerObj((new std::vector< Hex::Edge * >::allocator_type(static_cast< const std::vector< Hex::Edge * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Hex__Edge_p_t, SWIG_POINTER_OWN |  0 );
11639   return resultobj;
11640 fail:
11641   return NULL;
11642 }
11643
11644
11645 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11646   PyObject *resultobj = 0;
11647   std::vector< Hex::Edge * >::size_type arg1 ;
11648   size_t val1 ;
11649   int ecode1 = 0 ;
11650   PyObject * obj0 = 0 ;
11651   std::vector< Hex::Edge * > *result = 0 ;
11652
11653   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorEdges",&obj0)) SWIG_fail;
11654   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11655   if (!SWIG_IsOK(ecode1)) {
11656     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * >::size_type""'");
11657   }
11658   arg1 = static_cast< std::vector< Hex::Edge * >::size_type >(val1);
11659   result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >(arg1);
11660   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
11661   return resultobj;
11662 fail:
11663   return NULL;
11664 }
11665
11666
11667 SWIGINTERN PyObject *_wrap_VectorEdges_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11668   PyObject *resultobj = 0;
11669   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11670   void *argp1 = 0 ;
11671   int res1 = 0 ;
11672   PyObject * obj0 = 0 ;
11673
11674   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_pop_back",&obj0)) SWIG_fail;
11675   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11676   if (!SWIG_IsOK(res1)) {
11677     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11678   }
11679   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11680   (arg1)->pop_back();
11681   resultobj = SWIG_Py_Void();
11682   return resultobj;
11683 fail:
11684   return NULL;
11685 }
11686
11687
11688 SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11689   PyObject *resultobj = 0;
11690   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11691   std::vector< Hex::Edge * >::size_type arg2 ;
11692   void *argp1 = 0 ;
11693   int res1 = 0 ;
11694   size_t val2 ;
11695   int ecode2 = 0 ;
11696   PyObject * obj0 = 0 ;
11697   PyObject * obj1 = 0 ;
11698
11699   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_resize",&obj0,&obj1)) SWIG_fail;
11700   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11701   if (!SWIG_IsOK(res1)) {
11702     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11703   }
11704   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11705   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11706   if (!SWIG_IsOK(ecode2)) {
11707     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
11708   }
11709   arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
11710   (arg1)->resize(arg2);
11711   resultobj = SWIG_Py_Void();
11712   return resultobj;
11713 fail:
11714   return NULL;
11715 }
11716
11717
11718 SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11719   PyObject *resultobj = 0;
11720   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11721   std::vector< Hex::Edge * >::iterator arg2 ;
11722   void *argp1 = 0 ;
11723   int res1 = 0 ;
11724   swig::SwigPyIterator *iter2 = 0 ;
11725   int res2 ;
11726   PyObject * obj0 = 0 ;
11727   PyObject * obj1 = 0 ;
11728   std::vector< Hex::Edge * >::iterator result;
11729
11730   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_erase",&obj0,&obj1)) SWIG_fail;
11731   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11732   if (!SWIG_IsOK(res1)) {
11733     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11734   }
11735   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11736   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
11737   if (!SWIG_IsOK(res2) || !iter2) {
11738     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11739   } else {
11740     swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
11741     if (iter_t) {
11742       arg2 = iter_t->get_current();
11743     } else {
11744       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11745     }
11746   }
11747   result = std_vector_Sl_Hex_Edge_Sm__Sg__erase__SWIG_0(arg1,arg2);
11748   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
11749     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11750   return resultobj;
11751 fail:
11752   return NULL;
11753 }
11754
11755
11756 SWIGINTERN PyObject *_wrap_VectorEdges_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11757   PyObject *resultobj = 0;
11758   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11759   std::vector< Hex::Edge * >::iterator arg2 ;
11760   std::vector< Hex::Edge * >::iterator arg3 ;
11761   void *argp1 = 0 ;
11762   int res1 = 0 ;
11763   swig::SwigPyIterator *iter2 = 0 ;
11764   int res2 ;
11765   swig::SwigPyIterator *iter3 = 0 ;
11766   int res3 ;
11767   PyObject * obj0 = 0 ;
11768   PyObject * obj1 = 0 ;
11769   PyObject * obj2 = 0 ;
11770   std::vector< Hex::Edge * >::iterator result;
11771
11772   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_erase",&obj0,&obj1,&obj2)) SWIG_fail;
11773   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11774   if (!SWIG_IsOK(res1)) {
11775     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_erase" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11776   }
11777   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11778   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
11779   if (!SWIG_IsOK(res2) || !iter2) {
11780     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11781   } else {
11782     swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
11783     if (iter_t) {
11784       arg2 = iter_t->get_current();
11785     } else {
11786       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11787     }
11788   }
11789   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
11790   if (!SWIG_IsOK(res3) || !iter3) {
11791     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11792   } else {
11793     swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter3);
11794     if (iter_t) {
11795       arg3 = iter_t->get_current();
11796     } else {
11797       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_erase" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::iterator""'");
11798     }
11799   }
11800   result = std_vector_Sl_Hex_Edge_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
11801   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
11802     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
11803   return resultobj;
11804 fail:
11805   return NULL;
11806 }
11807
11808
11809 SWIGINTERN PyObject *_wrap_VectorEdges_erase(PyObject *self, PyObject *args) {
11810   Py_ssize_t argc;
11811   PyObject *argv[4] = {
11812     0
11813   };
11814   Py_ssize_t ii;
11815
11816   if (!PyTuple_Check(args)) SWIG_fail;
11817   argc = args ? PyObject_Length(args) : 0;
11818   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
11819     argv[ii] = PyTuple_GET_ITEM(args,ii);
11820   }
11821   if (argc == 2) {
11822     int _v;
11823     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11824     _v = SWIG_CheckState(res);
11825     if (_v) {
11826       swig::SwigPyIterator *iter = 0;
11827       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
11828       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
11829       if (_v) {
11830         return _wrap_VectorEdges_erase__SWIG_0(self, args);
11831       }
11832     }
11833   }
11834   if (argc == 3) {
11835     int _v;
11836     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11837     _v = SWIG_CheckState(res);
11838     if (_v) {
11839       swig::SwigPyIterator *iter = 0;
11840       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
11841       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
11842       if (_v) {
11843         swig::SwigPyIterator *iter = 0;
11844         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
11845         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
11846         if (_v) {
11847           return _wrap_VectorEdges_erase__SWIG_1(self, args);
11848         }
11849       }
11850     }
11851   }
11852
11853 fail:
11854   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges_erase'.\n"
11855     "  Possible C/C++ prototypes are:\n"
11856     "    std::vector< Hex::Edge * >::erase(std::vector< Hex::Edge * >::iterator)\n"
11857     "    std::vector< Hex::Edge * >::erase(std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::iterator)\n");
11858   return 0;
11859 }
11860
11861
11862 SWIGINTERN PyObject *_wrap_new_VectorEdges__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11863   PyObject *resultobj = 0;
11864   std::vector< Hex::Edge * >::size_type arg1 ;
11865   std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
11866   size_t val1 ;
11867   int ecode1 = 0 ;
11868   void *argp2 = 0 ;
11869   int res2 = 0 ;
11870   PyObject * obj0 = 0 ;
11871   PyObject * obj1 = 0 ;
11872   std::vector< Hex::Edge * > *result = 0 ;
11873
11874   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorEdges",&obj0,&obj1)) SWIG_fail;
11875   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11876   if (!SWIG_IsOK(ecode1)) {
11877     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * >::size_type""'");
11878   }
11879   arg1 = static_cast< std::vector< Hex::Edge * >::size_type >(val1);
11880   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
11881   if (!SWIG_IsOK(res2)) {
11882     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorEdges" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
11883   }
11884   arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
11885   result = (std::vector< Hex::Edge * > *)new std::vector< Hex::Edge * >(arg1,arg2);
11886   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_NEW |  0 );
11887   return resultobj;
11888 fail:
11889   return NULL;
11890 }
11891
11892
11893 SWIGINTERN PyObject *_wrap_new_VectorEdges(PyObject *self, PyObject *args) {
11894   Py_ssize_t argc;
11895   PyObject *argv[3] = {
11896     0
11897   };
11898   Py_ssize_t ii;
11899
11900   if (!PyTuple_Check(args)) SWIG_fail;
11901   argc = args ? PyObject_Length(args) : 0;
11902   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
11903     argv[ii] = PyTuple_GET_ITEM(args,ii);
11904   }
11905   if (argc == 0) {
11906     return _wrap_new_VectorEdges__SWIG_0(self, args);
11907   }
11908   if (argc == 1) {
11909     int _v;
11910     {
11911       int res = SWIG_AsVal_size_t(argv[0], NULL);
11912       _v = SWIG_CheckState(res);
11913     }
11914     if (_v) {
11915       return _wrap_new_VectorEdges__SWIG_2(self, args);
11916     }
11917   }
11918   if (argc == 1) {
11919     int _v;
11920     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
11921     _v = SWIG_CheckState(res);
11922     if (_v) {
11923       return _wrap_new_VectorEdges__SWIG_1(self, args);
11924     }
11925   }
11926   if (argc == 2) {
11927     int _v;
11928     {
11929       int res = SWIG_AsVal_size_t(argv[0], NULL);
11930       _v = SWIG_CheckState(res);
11931     }
11932     if (_v) {
11933       void *vptr = 0;
11934       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Edge, 0);
11935       _v = SWIG_CheckState(res);
11936       if (_v) {
11937         return _wrap_new_VectorEdges__SWIG_3(self, args);
11938       }
11939     }
11940   }
11941
11942 fail:
11943   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorEdges'.\n"
11944     "  Possible C/C++ prototypes are:\n"
11945     "    std::vector< Hex::Edge * >::vector()\n"
11946     "    std::vector< Hex::Edge * >::vector(std::vector< Hex::Edge * > const &)\n"
11947     "    std::vector< Hex::Edge * >::vector(std::vector< Hex::Edge * >::size_type)\n"
11948     "    std::vector< Hex::Edge * >::vector(std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
11949   return 0;
11950 }
11951
11952
11953 SWIGINTERN PyObject *_wrap_VectorEdges_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11954   PyObject *resultobj = 0;
11955   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11956   std::vector< Hex::Edge * >::value_type arg2 = (std::vector< Hex::Edge * >::value_type) 0 ;
11957   void *argp1 = 0 ;
11958   int res1 = 0 ;
11959   void *argp2 = 0 ;
11960   int res2 = 0 ;
11961   PyObject * obj0 = 0 ;
11962   PyObject * obj1 = 0 ;
11963
11964   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_push_back",&obj0,&obj1)) SWIG_fail;
11965   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11966   if (!SWIG_IsOK(res1)) {
11967     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_push_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
11968   }
11969   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11970   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
11971   if (!SWIG_IsOK(res2)) {
11972     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorEdges_push_back" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::value_type""'");
11973   }
11974   arg2 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp2);
11975   (arg1)->push_back(arg2);
11976   resultobj = SWIG_Py_Void();
11977   return resultobj;
11978 fail:
11979   return NULL;
11980 }
11981
11982
11983 SWIGINTERN PyObject *_wrap_VectorEdges_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11984   PyObject *resultobj = 0;
11985   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
11986   void *argp1 = 0 ;
11987   int res1 = 0 ;
11988   PyObject * obj0 = 0 ;
11989   std::vector< Hex::Edge * >::value_type result;
11990
11991   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_front",&obj0)) SWIG_fail;
11992   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
11993   if (!SWIG_IsOK(res1)) {
11994     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_front" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
11995   }
11996   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
11997   result = (std::vector< Hex::Edge * >::value_type)((std::vector< Hex::Edge * > const *)arg1)->front();
11998   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
11999   return resultobj;
12000 fail:
12001   return NULL;
12002 }
12003
12004
12005 SWIGINTERN PyObject *_wrap_VectorEdges_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12006   PyObject *resultobj = 0;
12007   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12008   void *argp1 = 0 ;
12009   int res1 = 0 ;
12010   PyObject * obj0 = 0 ;
12011   std::vector< Hex::Edge * >::value_type result;
12012
12013   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_back",&obj0)) SWIG_fail;
12014   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
12015   if (!SWIG_IsOK(res1)) {
12016     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_back" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
12017   }
12018   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12019   result = (std::vector< Hex::Edge * >::value_type)((std::vector< Hex::Edge * > const *)arg1)->back();
12020   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
12021   return resultobj;
12022 fail:
12023   return NULL;
12024 }
12025
12026
12027 SWIGINTERN PyObject *_wrap_VectorEdges_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12028   PyObject *resultobj = 0;
12029   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12030   std::vector< Hex::Edge * >::size_type arg2 ;
12031   std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
12032   void *argp1 = 0 ;
12033   int res1 = 0 ;
12034   size_t val2 ;
12035   int ecode2 = 0 ;
12036   void *argp3 = 0 ;
12037   int res3 = 0 ;
12038   PyObject * obj0 = 0 ;
12039   PyObject * obj1 = 0 ;
12040   PyObject * obj2 = 0 ;
12041
12042   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_assign",&obj0,&obj1,&obj2)) SWIG_fail;
12043   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
12044   if (!SWIG_IsOK(res1)) {
12045     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_assign" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12046   }
12047   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12048   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12049   if (!SWIG_IsOK(ecode2)) {
12050     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_assign" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
12051   }
12052   arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
12053   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
12054   if (!SWIG_IsOK(res3)) {
12055     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_assign" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
12056   }
12057   arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
12058   (arg1)->assign(arg2,arg3);
12059   resultobj = SWIG_Py_Void();
12060   return resultobj;
12061 fail:
12062   return NULL;
12063 }
12064
12065
12066 SWIGINTERN PyObject *_wrap_VectorEdges_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12067   PyObject *resultobj = 0;
12068   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12069   std::vector< Hex::Edge * >::size_type arg2 ;
12070   std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
12071   void *argp1 = 0 ;
12072   int res1 = 0 ;
12073   size_t val2 ;
12074   int ecode2 = 0 ;
12075   void *argp3 = 0 ;
12076   int res3 = 0 ;
12077   PyObject * obj0 = 0 ;
12078   PyObject * obj1 = 0 ;
12079   PyObject * obj2 = 0 ;
12080
12081   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_resize",&obj0,&obj1,&obj2)) SWIG_fail;
12082   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
12083   if (!SWIG_IsOK(res1)) {
12084     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_resize" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12085   }
12086   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12087   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12088   if (!SWIG_IsOK(ecode2)) {
12089     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_resize" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
12090   }
12091   arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
12092   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
12093   if (!SWIG_IsOK(res3)) {
12094     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_resize" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
12095   }
12096   arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
12097   (arg1)->resize(arg2,arg3);
12098   resultobj = SWIG_Py_Void();
12099   return resultobj;
12100 fail:
12101   return NULL;
12102 }
12103
12104
12105 SWIGINTERN PyObject *_wrap_VectorEdges_resize(PyObject *self, PyObject *args) {
12106   Py_ssize_t argc;
12107   PyObject *argv[4] = {
12108     0
12109   };
12110   Py_ssize_t ii;
12111
12112   if (!PyTuple_Check(args)) SWIG_fail;
12113   argc = args ? PyObject_Length(args) : 0;
12114   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
12115     argv[ii] = PyTuple_GET_ITEM(args,ii);
12116   }
12117   if (argc == 2) {
12118     int _v;
12119     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
12120     _v = SWIG_CheckState(res);
12121     if (_v) {
12122       {
12123         int res = SWIG_AsVal_size_t(argv[1], NULL);
12124         _v = SWIG_CheckState(res);
12125       }
12126       if (_v) {
12127         return _wrap_VectorEdges_resize__SWIG_0(self, args);
12128       }
12129     }
12130   }
12131   if (argc == 3) {
12132     int _v;
12133     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
12134     _v = SWIG_CheckState(res);
12135     if (_v) {
12136       {
12137         int res = SWIG_AsVal_size_t(argv[1], NULL);
12138         _v = SWIG_CheckState(res);
12139       }
12140       if (_v) {
12141         void *vptr = 0;
12142         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
12143         _v = SWIG_CheckState(res);
12144         if (_v) {
12145           return _wrap_VectorEdges_resize__SWIG_1(self, args);
12146         }
12147       }
12148     }
12149   }
12150
12151 fail:
12152   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges_resize'.\n"
12153     "  Possible C/C++ prototypes are:\n"
12154     "    std::vector< Hex::Edge * >::resize(std::vector< Hex::Edge * >::size_type)\n"
12155     "    std::vector< Hex::Edge * >::resize(std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
12156   return 0;
12157 }
12158
12159
12160 SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12161   PyObject *resultobj = 0;
12162   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12163   std::vector< Hex::Edge * >::iterator arg2 ;
12164   std::vector< Hex::Edge * >::value_type arg3 = (std::vector< Hex::Edge * >::value_type) 0 ;
12165   void *argp1 = 0 ;
12166   int res1 = 0 ;
12167   swig::SwigPyIterator *iter2 = 0 ;
12168   int res2 ;
12169   void *argp3 = 0 ;
12170   int res3 = 0 ;
12171   PyObject * obj0 = 0 ;
12172   PyObject * obj1 = 0 ;
12173   PyObject * obj2 = 0 ;
12174   std::vector< Hex::Edge * >::iterator result;
12175
12176   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorEdges_insert",&obj0,&obj1,&obj2)) SWIG_fail;
12177   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
12178   if (!SWIG_IsOK(res1)) {
12179     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12180   }
12181   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12182   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
12183   if (!SWIG_IsOK(res2) || !iter2) {
12184     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
12185   } else {
12186     swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
12187     if (iter_t) {
12188       arg2 = iter_t->get_current();
12189     } else {
12190       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
12191     }
12192   }
12193   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
12194   if (!SWIG_IsOK(res3)) {
12195     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::value_type""'");
12196   }
12197   arg3 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp3);
12198   result = std_vector_Sl_Hex_Edge_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
12199   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Edge * >::iterator & >(result)),
12200     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
12201   return resultobj;
12202 fail:
12203   return NULL;
12204 }
12205
12206
12207 SWIGINTERN PyObject *_wrap_VectorEdges_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12208   PyObject *resultobj = 0;
12209   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12210   std::vector< Hex::Edge * >::iterator arg2 ;
12211   std::vector< Hex::Edge * >::size_type arg3 ;
12212   std::vector< Hex::Edge * >::value_type arg4 = (std::vector< Hex::Edge * >::value_type) 0 ;
12213   void *argp1 = 0 ;
12214   int res1 = 0 ;
12215   swig::SwigPyIterator *iter2 = 0 ;
12216   int res2 ;
12217   size_t val3 ;
12218   int ecode3 = 0 ;
12219   void *argp4 = 0 ;
12220   int res4 = 0 ;
12221   PyObject * obj0 = 0 ;
12222   PyObject * obj1 = 0 ;
12223   PyObject * obj2 = 0 ;
12224   PyObject * obj3 = 0 ;
12225
12226   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorEdges_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12227   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
12228   if (!SWIG_IsOK(res1)) {
12229     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_insert" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12230   }
12231   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12232   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
12233   if (!SWIG_IsOK(res2) || !iter2) {
12234     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
12235   } else {
12236     swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter2);
12237     if (iter_t) {
12238       arg2 = iter_t->get_current();
12239     } else {
12240       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorEdges_insert" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::iterator""'");
12241     }
12242   }
12243   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
12244   if (!SWIG_IsOK(ecode3)) {
12245     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorEdges_insert" "', argument " "3"" of type '" "std::vector< Hex::Edge * >::size_type""'");
12246   }
12247   arg3 = static_cast< std::vector< Hex::Edge * >::size_type >(val3);
12248   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Edge, 0 |  0 );
12249   if (!SWIG_IsOK(res4)) {
12250     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorEdges_insert" "', argument " "4"" of type '" "std::vector< Hex::Edge * >::value_type""'");
12251   }
12252   arg4 = reinterpret_cast< std::vector< Hex::Edge * >::value_type >(argp4);
12253   std_vector_Sl_Hex_Edge_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
12254   resultobj = SWIG_Py_Void();
12255   return resultobj;
12256 fail:
12257   return NULL;
12258 }
12259
12260
12261 SWIGINTERN PyObject *_wrap_VectorEdges_insert(PyObject *self, PyObject *args) {
12262   Py_ssize_t argc;
12263   PyObject *argv[5] = {
12264     0
12265   };
12266   Py_ssize_t ii;
12267
12268   if (!PyTuple_Check(args)) SWIG_fail;
12269   argc = args ? PyObject_Length(args) : 0;
12270   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
12271     argv[ii] = PyTuple_GET_ITEM(args,ii);
12272   }
12273   if (argc == 3) {
12274     int _v;
12275     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
12276     _v = SWIG_CheckState(res);
12277     if (_v) {
12278       swig::SwigPyIterator *iter = 0;
12279       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
12280       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
12281       if (_v) {
12282         void *vptr = 0;
12283         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
12284         _v = SWIG_CheckState(res);
12285         if (_v) {
12286           return _wrap_VectorEdges_insert__SWIG_0(self, args);
12287         }
12288       }
12289     }
12290   }
12291   if (argc == 4) {
12292     int _v;
12293     int res = swig::asptr(argv[0], (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > >**)(0));
12294     _v = SWIG_CheckState(res);
12295     if (_v) {
12296       swig::SwigPyIterator *iter = 0;
12297       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
12298       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Edge * >::iterator > *>(iter) != 0));
12299       if (_v) {
12300         {
12301           int res = SWIG_AsVal_size_t(argv[2], NULL);
12302           _v = SWIG_CheckState(res);
12303         }
12304         if (_v) {
12305           void *vptr = 0;
12306           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Edge, 0);
12307           _v = SWIG_CheckState(res);
12308           if (_v) {
12309             return _wrap_VectorEdges_insert__SWIG_1(self, args);
12310           }
12311         }
12312       }
12313     }
12314   }
12315
12316 fail:
12317   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorEdges_insert'.\n"
12318     "  Possible C/C++ prototypes are:\n"
12319     "    std::vector< Hex::Edge * >::insert(std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::value_type)\n"
12320     "    std::vector< Hex::Edge * >::insert(std::vector< Hex::Edge * >::iterator,std::vector< Hex::Edge * >::size_type,std::vector< Hex::Edge * >::value_type)\n");
12321   return 0;
12322 }
12323
12324
12325 SWIGINTERN PyObject *_wrap_VectorEdges_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12326   PyObject *resultobj = 0;
12327   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12328   std::vector< Hex::Edge * >::size_type arg2 ;
12329   void *argp1 = 0 ;
12330   int res1 = 0 ;
12331   size_t val2 ;
12332   int ecode2 = 0 ;
12333   PyObject * obj0 = 0 ;
12334   PyObject * obj1 = 0 ;
12335
12336   if (!PyArg_ParseTuple(args,(char *)"OO:VectorEdges_reserve",&obj0,&obj1)) SWIG_fail;
12337   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
12338   if (!SWIG_IsOK(res1)) {
12339     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_reserve" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12340   }
12341   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12342   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12343   if (!SWIG_IsOK(ecode2)) {
12344     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorEdges_reserve" "', argument " "2"" of type '" "std::vector< Hex::Edge * >::size_type""'");
12345   }
12346   arg2 = static_cast< std::vector< Hex::Edge * >::size_type >(val2);
12347   (arg1)->reserve(arg2);
12348   resultobj = SWIG_Py_Void();
12349   return resultobj;
12350 fail:
12351   return NULL;
12352 }
12353
12354
12355 SWIGINTERN PyObject *_wrap_VectorEdges_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12356   PyObject *resultobj = 0;
12357   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12358   void *argp1 = 0 ;
12359   int res1 = 0 ;
12360   PyObject * obj0 = 0 ;
12361   std::vector< Hex::Edge * >::size_type result;
12362
12363   if (!PyArg_ParseTuple(args,(char *)"O:VectorEdges_capacity",&obj0)) SWIG_fail;
12364   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0 |  0 );
12365   if (!SWIG_IsOK(res1)) {
12366     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorEdges_capacity" "', argument " "1"" of type '" "std::vector< Hex::Edge * > const *""'");
12367   }
12368   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12369   result = ((std::vector< Hex::Edge * > const *)arg1)->capacity();
12370   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12371   return resultobj;
12372 fail:
12373   return NULL;
12374 }
12375
12376
12377 SWIGINTERN PyObject *_wrap_delete_VectorEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12378   PyObject *resultobj = 0;
12379   std::vector< Hex::Edge * > *arg1 = (std::vector< Hex::Edge * > *) 0 ;
12380   void *argp1 = 0 ;
12381   int res1 = 0 ;
12382   PyObject * obj0 = 0 ;
12383
12384   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorEdges",&obj0)) SWIG_fail;
12385   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_POINTER_DISOWN |  0 );
12386   if (!SWIG_IsOK(res1)) {
12387     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorEdges" "', argument " "1"" of type '" "std::vector< Hex::Edge * > *""'");
12388   }
12389   arg1 = reinterpret_cast< std::vector< Hex::Edge * > * >(argp1);
12390   delete arg1;
12391   resultobj = SWIG_Py_Void();
12392   return resultobj;
12393 fail:
12394   return NULL;
12395 }
12396
12397
12398 SWIGINTERN PyObject *VectorEdges_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12399   PyObject *obj;
12400   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
12401   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, SWIG_NewClientData(obj));
12402   return SWIG_Py_Void();
12403 }
12404
12405 SWIGINTERN PyObject *_wrap_VectorVertices_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12406   PyObject *resultobj = 0;
12407   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12408   PyObject **arg2 = (PyObject **) 0 ;
12409   void *argp1 = 0 ;
12410   int res1 = 0 ;
12411   PyObject * obj0 = 0 ;
12412   swig::SwigPyIterator *result = 0 ;
12413
12414   arg2 = &obj0;
12415   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_iterator",&obj0)) SWIG_fail;
12416   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12417   if (!SWIG_IsOK(res1)) {
12418     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_iterator" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12419   }
12420   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12421   result = (swig::SwigPyIterator *)std_vector_Sl_Hex_Vertex_Sm__Sg__iterator(arg1,arg2);
12422   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
12423   return resultobj;
12424 fail:
12425   return NULL;
12426 }
12427
12428
12429 SWIGINTERN PyObject *_wrap_VectorVertices___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12430   PyObject *resultobj = 0;
12431   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12432   void *argp1 = 0 ;
12433   int res1 = 0 ;
12434   PyObject * obj0 = 0 ;
12435   bool result;
12436
12437   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___nonzero__",&obj0)) SWIG_fail;
12438   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12439   if (!SWIG_IsOK(res1)) {
12440     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
12441   }
12442   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12443   result = (bool)std_vector_Sl_Hex_Vertex_Sm__Sg____nonzero__((std::vector< Hex::Vertex * > const *)arg1);
12444   resultobj = SWIG_From_bool(static_cast< bool >(result));
12445   return resultobj;
12446 fail:
12447   return NULL;
12448 }
12449
12450
12451 SWIGINTERN PyObject *_wrap_VectorVertices___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12452   PyObject *resultobj = 0;
12453   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12454   void *argp1 = 0 ;
12455   int res1 = 0 ;
12456   PyObject * obj0 = 0 ;
12457   bool result;
12458
12459   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___bool__",&obj0)) SWIG_fail;
12460   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12461   if (!SWIG_IsOK(res1)) {
12462     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___bool__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
12463   }
12464   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12465   result = (bool)std_vector_Sl_Hex_Vertex_Sm__Sg____bool__((std::vector< Hex::Vertex * > const *)arg1);
12466   resultobj = SWIG_From_bool(static_cast< bool >(result));
12467   return resultobj;
12468 fail:
12469   return NULL;
12470 }
12471
12472
12473 SWIGINTERN PyObject *_wrap_VectorVertices___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12474   PyObject *resultobj = 0;
12475   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12476   void *argp1 = 0 ;
12477   int res1 = 0 ;
12478   PyObject * obj0 = 0 ;
12479   std::vector< Hex::Vertex * >::size_type result;
12480
12481   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices___len__",&obj0)) SWIG_fail;
12482   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12483   if (!SWIG_IsOK(res1)) {
12484     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___len__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
12485   }
12486   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12487   result = std_vector_Sl_Hex_Vertex_Sm__Sg____len__((std::vector< Hex::Vertex * > const *)arg1);
12488   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12489   return resultobj;
12490 fail:
12491   return NULL;
12492 }
12493
12494
12495 SWIGINTERN PyObject *_wrap_VectorVertices___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12496   PyObject *resultobj = 0;
12497   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12498   std::vector< Hex::Vertex * >::difference_type arg2 ;
12499   std::vector< Hex::Vertex * >::difference_type arg3 ;
12500   void *argp1 = 0 ;
12501   int res1 = 0 ;
12502   ptrdiff_t val2 ;
12503   int ecode2 = 0 ;
12504   ptrdiff_t val3 ;
12505   int ecode3 = 0 ;
12506   PyObject * obj0 = 0 ;
12507   PyObject * obj1 = 0 ;
12508   PyObject * obj2 = 0 ;
12509   std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *result = 0 ;
12510
12511   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
12512   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12513   if (!SWIG_IsOK(res1)) {
12514     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12515   }
12516   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12517   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12518   if (!SWIG_IsOK(ecode2)) {
12519     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12520   }
12521   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
12522   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12523   if (!SWIG_IsOK(ecode3)) {
12524     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___getslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12525   }
12526   arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
12527   try {
12528     result = (std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *)std_vector_Sl_Hex_Vertex_Sm__Sg____getslice__(arg1,arg2,arg3);
12529   }
12530   catch(std::out_of_range &_e) {
12531     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12532   }
12533   catch(std::invalid_argument &_e) {
12534     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12535   }
12536
12537   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_OWN |  0 );
12538   return resultobj;
12539 fail:
12540   return NULL;
12541 }
12542
12543
12544 SWIGINTERN PyObject *_wrap_VectorVertices___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12545   PyObject *resultobj = 0;
12546   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12547   std::vector< Hex::Vertex * >::difference_type arg2 ;
12548   std::vector< Hex::Vertex * >::difference_type arg3 ;
12549   void *argp1 = 0 ;
12550   int res1 = 0 ;
12551   ptrdiff_t val2 ;
12552   int ecode2 = 0 ;
12553   ptrdiff_t val3 ;
12554   int ecode3 = 0 ;
12555   PyObject * obj0 = 0 ;
12556   PyObject * obj1 = 0 ;
12557   PyObject * obj2 = 0 ;
12558
12559   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
12560   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12561   if (!SWIG_IsOK(res1)) {
12562     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12563   }
12564   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12565   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12566   if (!SWIG_IsOK(ecode2)) {
12567     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12568   }
12569   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
12570   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12571   if (!SWIG_IsOK(ecode3)) {
12572     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12573   }
12574   arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
12575   try {
12576     std_vector_Sl_Hex_Vertex_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
12577   }
12578   catch(std::out_of_range &_e) {
12579     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12580   }
12581   catch(std::invalid_argument &_e) {
12582     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12583   }
12584
12585   resultobj = SWIG_Py_Void();
12586   return resultobj;
12587 fail:
12588   return NULL;
12589 }
12590
12591
12592 SWIGINTERN PyObject *_wrap_VectorVertices___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12593   PyObject *resultobj = 0;
12594   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12595   std::vector< Hex::Vertex * >::difference_type arg2 ;
12596   std::vector< Hex::Vertex * >::difference_type arg3 ;
12597   std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *arg4 = 0 ;
12598   void *argp1 = 0 ;
12599   int res1 = 0 ;
12600   ptrdiff_t val2 ;
12601   int ecode2 = 0 ;
12602   ptrdiff_t val3 ;
12603   int ecode3 = 0 ;
12604   int res4 = SWIG_OLDOBJ ;
12605   PyObject * obj0 = 0 ;
12606   PyObject * obj1 = 0 ;
12607   PyObject * obj2 = 0 ;
12608   PyObject * obj3 = 0 ;
12609
12610   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12611   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12612   if (!SWIG_IsOK(res1)) {
12613     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12614   }
12615   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12616   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12617   if (!SWIG_IsOK(ecode2)) {
12618     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12619   }
12620   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
12621   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12622   if (!SWIG_IsOK(ecode3)) {
12623     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___setslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12624   }
12625   arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
12626   {
12627     std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
12628     res4 = swig::asptr(obj3, &ptr);
12629     if (!SWIG_IsOK(res4)) {
12630       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices___setslice__" "', argument " "4"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
12631     }
12632     if (!ptr) {
12633       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 &""'");
12634     }
12635     arg4 = ptr;
12636   }
12637   try {
12638     std_vector_Sl_Hex_Vertex_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)*arg4);
12639   }
12640   catch(std::out_of_range &_e) {
12641     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12642   }
12643   catch(std::invalid_argument &_e) {
12644     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12645   }
12646
12647   resultobj = SWIG_Py_Void();
12648   if (SWIG_IsNewObj(res4)) delete arg4;
12649   return resultobj;
12650 fail:
12651   if (SWIG_IsNewObj(res4)) delete arg4;
12652   return NULL;
12653 }
12654
12655
12656 SWIGINTERN PyObject *_wrap_VectorVertices___setslice__(PyObject *self, PyObject *args) {
12657   Py_ssize_t argc;
12658   PyObject *argv[5] = {
12659     0
12660   };
12661   Py_ssize_t ii;
12662
12663   if (!PyTuple_Check(args)) SWIG_fail;
12664   argc = args ? PyObject_Length(args) : 0;
12665   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
12666     argv[ii] = PyTuple_GET_ITEM(args,ii);
12667   }
12668   if (argc == 3) {
12669     int _v;
12670     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12671     _v = SWIG_CheckState(res);
12672     if (_v) {
12673       {
12674         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
12675         _v = SWIG_CheckState(res);
12676       }
12677       if (_v) {
12678         {
12679           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
12680           _v = SWIG_CheckState(res);
12681         }
12682         if (_v) {
12683           return _wrap_VectorVertices___setslice____SWIG_0(self, args);
12684         }
12685       }
12686     }
12687   }
12688   if (argc == 4) {
12689     int _v;
12690     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12691     _v = SWIG_CheckState(res);
12692     if (_v) {
12693       {
12694         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
12695         _v = SWIG_CheckState(res);
12696       }
12697       if (_v) {
12698         {
12699           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
12700           _v = SWIG_CheckState(res);
12701         }
12702         if (_v) {
12703           int res = swig::asptr(argv[3], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12704           _v = SWIG_CheckState(res);
12705           if (_v) {
12706             return _wrap_VectorVertices___setslice____SWIG_1(self, args);
12707           }
12708         }
12709       }
12710     }
12711   }
12712
12713 fail:
12714   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices___setslice__'.\n"
12715     "  Possible C/C++ prototypes are:\n"
12716     "    std::vector< Hex::Vertex * >::__setslice__(std::vector< Hex::Vertex * >::difference_type,std::vector< Hex::Vertex * >::difference_type)\n"
12717     "    std::vector< Hex::Vertex * >::__setslice__(std::vector< Hex::Vertex * >::difference_type,std::vector< Hex::Vertex * >::difference_type,std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)\n");
12718   return 0;
12719 }
12720
12721
12722 SWIGINTERN PyObject *_wrap_VectorVertices___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12723   PyObject *resultobj = 0;
12724   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12725   std::vector< Hex::Vertex * >::difference_type arg2 ;
12726   std::vector< Hex::Vertex * >::difference_type arg3 ;
12727   void *argp1 = 0 ;
12728   int res1 = 0 ;
12729   ptrdiff_t val2 ;
12730   int ecode2 = 0 ;
12731   ptrdiff_t val3 ;
12732   int ecode3 = 0 ;
12733   PyObject * obj0 = 0 ;
12734   PyObject * obj1 = 0 ;
12735   PyObject * obj2 = 0 ;
12736
12737   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
12738   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12739   if (!SWIG_IsOK(res1)) {
12740     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delslice__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12741   }
12742   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12743   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12744   if (!SWIG_IsOK(ecode2)) {
12745     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delslice__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12746   }
12747   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
12748   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
12749   if (!SWIG_IsOK(ecode3)) {
12750     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices___delslice__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12751   }
12752   arg3 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val3);
12753   try {
12754     std_vector_Sl_Hex_Vertex_Sm__Sg____delslice__(arg1,arg2,arg3);
12755   }
12756   catch(std::out_of_range &_e) {
12757     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12758   }
12759   catch(std::invalid_argument &_e) {
12760     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12761   }
12762
12763   resultobj = SWIG_Py_Void();
12764   return resultobj;
12765 fail:
12766   return NULL;
12767 }
12768
12769
12770 SWIGINTERN PyObject *_wrap_VectorVertices___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12771   PyObject *resultobj = 0;
12772   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12773   std::vector< Hex::Vertex * >::difference_type arg2 ;
12774   void *argp1 = 0 ;
12775   int res1 = 0 ;
12776   ptrdiff_t val2 ;
12777   int ecode2 = 0 ;
12778   PyObject * obj0 = 0 ;
12779   PyObject * obj1 = 0 ;
12780
12781   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___delitem__",&obj0,&obj1)) SWIG_fail;
12782   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12783   if (!SWIG_IsOK(res1)) {
12784     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12785   }
12786   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12787   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
12788   if (!SWIG_IsOK(ecode2)) {
12789     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___delitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
12790   }
12791   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
12792   try {
12793     std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_0(arg1,arg2);
12794   }
12795   catch(std::out_of_range &_e) {
12796     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12797   }
12798   catch(std::invalid_argument &_e) {
12799     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12800   }
12801
12802   resultobj = SWIG_Py_Void();
12803   return resultobj;
12804 fail:
12805   return NULL;
12806 }
12807
12808
12809 SWIGINTERN PyObject *_wrap_VectorVertices___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12810   PyObject *resultobj = 0;
12811   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12812   PySliceObject *arg2 = (PySliceObject *) 0 ;
12813   void *argp1 = 0 ;
12814   int res1 = 0 ;
12815   PyObject * obj0 = 0 ;
12816   PyObject * obj1 = 0 ;
12817   std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *result = 0 ;
12818
12819   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___getitem__",&obj0,&obj1)) SWIG_fail;
12820   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12821   if (!SWIG_IsOK(res1)) {
12822     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12823   }
12824   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12825   {
12826     if (!PySlice_Check(obj1)) {
12827       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
12828     }
12829     arg2 = (PySliceObject *) obj1;
12830   }
12831   try {
12832     result = (std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *)std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_0(arg1,arg2);
12833   }
12834   catch(std::out_of_range &_e) {
12835     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12836   }
12837   catch(std::invalid_argument &_e) {
12838     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12839   }
12840
12841   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_OWN |  0 );
12842   return resultobj;
12843 fail:
12844   return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *_wrap_VectorVertices___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12849   PyObject *resultobj = 0;
12850   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12851   PySliceObject *arg2 = (PySliceObject *) 0 ;
12852   std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *arg3 = 0 ;
12853   void *argp1 = 0 ;
12854   int res1 = 0 ;
12855   int res3 = SWIG_OLDOBJ ;
12856   PyObject * obj0 = 0 ;
12857   PyObject * obj1 = 0 ;
12858   PyObject * obj2 = 0 ;
12859
12860   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
12861   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12862   if (!SWIG_IsOK(res1)) {
12863     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12864   }
12865   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12866   {
12867     if (!PySlice_Check(obj1)) {
12868       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
12869     }
12870     arg2 = (PySliceObject *) obj1;
12871   }
12872   {
12873     std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
12874     res3 = swig::asptr(obj2, &ptr);
12875     if (!SWIG_IsOK(res3)) {
12876       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
12877     }
12878     if (!ptr) {
12879       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &""'");
12880     }
12881     arg3 = ptr;
12882   }
12883   try {
12884     std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)*arg3);
12885   }
12886   catch(std::out_of_range &_e) {
12887     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12888   }
12889   catch(std::invalid_argument &_e) {
12890     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12891   }
12892
12893   resultobj = SWIG_Py_Void();
12894   if (SWIG_IsNewObj(res3)) delete arg3;
12895   return resultobj;
12896 fail:
12897   if (SWIG_IsNewObj(res3)) delete arg3;
12898   return NULL;
12899 }
12900
12901
12902 SWIGINTERN PyObject *_wrap_VectorVertices___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12903   PyObject *resultobj = 0;
12904   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12905   PySliceObject *arg2 = (PySliceObject *) 0 ;
12906   void *argp1 = 0 ;
12907   int res1 = 0 ;
12908   PyObject * obj0 = 0 ;
12909   PyObject * obj1 = 0 ;
12910
12911   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___setitem__",&obj0,&obj1)) SWIG_fail;
12912   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12913   if (!SWIG_IsOK(res1)) {
12914     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12915   }
12916   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12917   {
12918     if (!PySlice_Check(obj1)) {
12919       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
12920     }
12921     arg2 = (PySliceObject *) obj1;
12922   }
12923   try {
12924     std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_1(arg1,arg2);
12925   }
12926   catch(std::out_of_range &_e) {
12927     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12928   }
12929   catch(std::invalid_argument &_e) {
12930     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12931   }
12932
12933   resultobj = SWIG_Py_Void();
12934   return resultobj;
12935 fail:
12936   return NULL;
12937 }
12938
12939
12940 SWIGINTERN PyObject *_wrap_VectorVertices___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12941   PyObject *resultobj = 0;
12942   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
12943   PySliceObject *arg2 = (PySliceObject *) 0 ;
12944   void *argp1 = 0 ;
12945   int res1 = 0 ;
12946   PyObject * obj0 = 0 ;
12947   PyObject * obj1 = 0 ;
12948
12949   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___delitem__",&obj0,&obj1)) SWIG_fail;
12950   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
12951   if (!SWIG_IsOK(res1)) {
12952     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___delitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
12953   }
12954   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
12955   {
12956     if (!PySlice_Check(obj1)) {
12957       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
12958     }
12959     arg2 = (PySliceObject *) obj1;
12960   }
12961   try {
12962     std_vector_Sl_Hex_Vertex_Sm__Sg____delitem____SWIG_1(arg1,arg2);
12963   }
12964   catch(std::out_of_range &_e) {
12965     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
12966   }
12967   catch(std::invalid_argument &_e) {
12968     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
12969   }
12970
12971   resultobj = SWIG_Py_Void();
12972   return resultobj;
12973 fail:
12974   return NULL;
12975 }
12976
12977
12978 SWIGINTERN PyObject *_wrap_VectorVertices___delitem__(PyObject *self, PyObject *args) {
12979   Py_ssize_t argc;
12980   PyObject *argv[3] = {
12981     0
12982   };
12983   Py_ssize_t ii;
12984
12985   if (!PyTuple_Check(args)) SWIG_fail;
12986   argc = args ? PyObject_Length(args) : 0;
12987   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
12988     argv[ii] = PyTuple_GET_ITEM(args,ii);
12989   }
12990   if (argc == 2) {
12991     int _v;
12992     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
12993     _v = SWIG_CheckState(res);
12994     if (_v) {
12995       {
12996         _v = PySlice_Check(argv[1]);
12997       }
12998       if (_v) {
12999         return _wrap_VectorVertices___delitem____SWIG_1(self, args);
13000       }
13001     }
13002   }
13003   if (argc == 2) {
13004     int _v;
13005     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13006     _v = SWIG_CheckState(res);
13007     if (_v) {
13008       {
13009         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
13010         _v = SWIG_CheckState(res);
13011       }
13012       if (_v) {
13013         return _wrap_VectorVertices___delitem____SWIG_0(self, args);
13014       }
13015     }
13016   }
13017
13018 fail:
13019   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices___delitem__'.\n"
13020     "  Possible C/C++ prototypes are:\n"
13021     "    std::vector< Hex::Vertex * >::__delitem__(std::vector< Hex::Vertex * >::difference_type)\n"
13022     "    std::vector< Hex::Vertex * >::__delitem__(PySliceObject *)\n");
13023   return 0;
13024 }
13025
13026
13027 SWIGINTERN PyObject *_wrap_VectorVertices___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13028   PyObject *resultobj = 0;
13029   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13030   std::vector< Hex::Vertex * >::difference_type arg2 ;
13031   void *argp1 = 0 ;
13032   int res1 = 0 ;
13033   ptrdiff_t val2 ;
13034   int ecode2 = 0 ;
13035   PyObject * obj0 = 0 ;
13036   PyObject * obj1 = 0 ;
13037   std::vector< Hex::Vertex * >::value_type result;
13038
13039   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices___getitem__",&obj0,&obj1)) SWIG_fail;
13040   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13041   if (!SWIG_IsOK(res1)) {
13042     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___getitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13043   }
13044   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13045   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13046   if (!SWIG_IsOK(ecode2)) {
13047     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___getitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
13048   }
13049   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
13050   try {
13051     result = (std::vector< Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg____getitem____SWIG_1(arg1,arg2);
13052   }
13053   catch(std::out_of_range &_e) {
13054     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13055   }
13056
13057   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
13058   return resultobj;
13059 fail:
13060   return NULL;
13061 }
13062
13063
13064 SWIGINTERN PyObject *_wrap_VectorVertices___getitem__(PyObject *self, PyObject *args) {
13065   Py_ssize_t argc;
13066   PyObject *argv[3] = {
13067     0
13068   };
13069   Py_ssize_t ii;
13070
13071   if (!PyTuple_Check(args)) SWIG_fail;
13072   argc = args ? PyObject_Length(args) : 0;
13073   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
13074     argv[ii] = PyTuple_GET_ITEM(args,ii);
13075   }
13076   if (argc == 2) {
13077     int _v;
13078     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13079     _v = SWIG_CheckState(res);
13080     if (_v) {
13081       {
13082         _v = PySlice_Check(argv[1]);
13083       }
13084       if (_v) {
13085         return _wrap_VectorVertices___getitem____SWIG_0(self, args);
13086       }
13087     }
13088   }
13089   if (argc == 2) {
13090     int _v;
13091     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13092     _v = SWIG_CheckState(res);
13093     if (_v) {
13094       {
13095         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
13096         _v = SWIG_CheckState(res);
13097       }
13098       if (_v) {
13099         return _wrap_VectorVertices___getitem____SWIG_1(self, args);
13100       }
13101     }
13102   }
13103
13104 fail:
13105   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices___getitem__'.\n"
13106     "  Possible C/C++ prototypes are:\n"
13107     "    std::vector< Hex::Vertex * >::__getitem__(PySliceObject *)\n"
13108     "    std::vector< Hex::Vertex * >::__getitem__(std::vector< Hex::Vertex * >::difference_type)\n");
13109   return 0;
13110 }
13111
13112
13113 SWIGINTERN PyObject *_wrap_VectorVertices___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13114   PyObject *resultobj = 0;
13115   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13116   std::vector< Hex::Vertex * >::difference_type arg2 ;
13117   std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13118   void *argp1 = 0 ;
13119   int res1 = 0 ;
13120   ptrdiff_t val2 ;
13121   int ecode2 = 0 ;
13122   void *argp3 = 0 ;
13123   int res3 = 0 ;
13124   PyObject * obj0 = 0 ;
13125   PyObject * obj1 = 0 ;
13126   PyObject * obj2 = 0 ;
13127
13128   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
13129   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13130   if (!SWIG_IsOK(res1)) {
13131     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices___setitem__" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13132   }
13133   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13134   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
13135   if (!SWIG_IsOK(ecode2)) {
13136     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices___setitem__" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::difference_type""'");
13137   }
13138   arg2 = static_cast< std::vector< Hex::Vertex * >::difference_type >(val2);
13139   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
13140   if (!SWIG_IsOK(res3)) {
13141     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices___setitem__" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13142   }
13143   arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
13144   try {
13145     std_vector_Sl_Hex_Vertex_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
13146   }
13147   catch(std::out_of_range &_e) {
13148     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13149   }
13150
13151   resultobj = SWIG_Py_Void();
13152   return resultobj;
13153 fail:
13154   return NULL;
13155 }
13156
13157
13158 SWIGINTERN PyObject *_wrap_VectorVertices___setitem__(PyObject *self, PyObject *args) {
13159   Py_ssize_t argc;
13160   PyObject *argv[4] = {
13161     0
13162   };
13163   Py_ssize_t ii;
13164
13165   if (!PyTuple_Check(args)) SWIG_fail;
13166   argc = args ? PyObject_Length(args) : 0;
13167   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
13168     argv[ii] = PyTuple_GET_ITEM(args,ii);
13169   }
13170   if (argc == 2) {
13171     int _v;
13172     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13173     _v = SWIG_CheckState(res);
13174     if (_v) {
13175       {
13176         _v = PySlice_Check(argv[1]);
13177       }
13178       if (_v) {
13179         return _wrap_VectorVertices___setitem____SWIG_1(self, args);
13180       }
13181     }
13182   }
13183   if (argc == 3) {
13184     int _v;
13185     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13186     _v = SWIG_CheckState(res);
13187     if (_v) {
13188       {
13189         _v = PySlice_Check(argv[1]);
13190       }
13191       if (_v) {
13192         int res = swig::asptr(argv[2], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13193         _v = SWIG_CheckState(res);
13194         if (_v) {
13195           return _wrap_VectorVertices___setitem____SWIG_0(self, args);
13196         }
13197       }
13198     }
13199   }
13200   if (argc == 3) {
13201     int _v;
13202     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13203     _v = SWIG_CheckState(res);
13204     if (_v) {
13205       {
13206         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
13207         _v = SWIG_CheckState(res);
13208       }
13209       if (_v) {
13210         void *vptr = 0;
13211         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
13212         _v = SWIG_CheckState(res);
13213         if (_v) {
13214           return _wrap_VectorVertices___setitem____SWIG_2(self, args);
13215         }
13216       }
13217     }
13218   }
13219
13220 fail:
13221   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices___setitem__'.\n"
13222     "  Possible C/C++ prototypes are:\n"
13223     "    std::vector< Hex::Vertex * >::__setitem__(PySliceObject *,std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > const &)\n"
13224     "    std::vector< Hex::Vertex * >::__setitem__(PySliceObject *)\n"
13225     "    std::vector< Hex::Vertex * >::__setitem__(std::vector< Hex::Vertex * >::difference_type,std::vector< Hex::Vertex * >::value_type)\n");
13226   return 0;
13227 }
13228
13229
13230 SWIGINTERN PyObject *_wrap_VectorVertices_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13231   PyObject *resultobj = 0;
13232   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13233   void *argp1 = 0 ;
13234   int res1 = 0 ;
13235   PyObject * obj0 = 0 ;
13236   std::vector< Hex::Vertex * >::value_type result;
13237
13238   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop",&obj0)) SWIG_fail;
13239   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13240   if (!SWIG_IsOK(res1)) {
13241     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13242   }
13243   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13244   try {
13245     result = (std::vector< Hex::Vertex * >::value_type)std_vector_Sl_Hex_Vertex_Sm__Sg__pop(arg1);
13246   }
13247   catch(std::out_of_range &_e) {
13248     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
13249   }
13250
13251   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
13252   return resultobj;
13253 fail:
13254   return NULL;
13255 }
13256
13257
13258 SWIGINTERN PyObject *_wrap_VectorVertices_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13259   PyObject *resultobj = 0;
13260   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13261   std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13262   void *argp1 = 0 ;
13263   int res1 = 0 ;
13264   void *argp2 = 0 ;
13265   int res2 = 0 ;
13266   PyObject * obj0 = 0 ;
13267   PyObject * obj1 = 0 ;
13268
13269   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_append",&obj0,&obj1)) SWIG_fail;
13270   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13271   if (!SWIG_IsOK(res1)) {
13272     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_append" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13273   }
13274   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13275   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
13276   if (!SWIG_IsOK(res2)) {
13277     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_append" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13278   }
13279   arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
13280   std_vector_Sl_Hex_Vertex_Sm__Sg__append(arg1,arg2);
13281   resultobj = SWIG_Py_Void();
13282   return resultobj;
13283 fail:
13284   return NULL;
13285 }
13286
13287
13288 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13289   PyObject *resultobj = 0;
13290   std::vector< Hex::Vertex * > *result = 0 ;
13291
13292   if (!PyArg_ParseTuple(args,(char *)":new_VectorVertices")) SWIG_fail;
13293   result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >();
13294   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
13295   return resultobj;
13296 fail:
13297   return NULL;
13298 }
13299
13300
13301 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13302   PyObject *resultobj = 0;
13303   std::vector< Hex::Vertex * > *arg1 = 0 ;
13304   int res1 = SWIG_OLDOBJ ;
13305   PyObject * obj0 = 0 ;
13306   std::vector< Hex::Vertex * > *result = 0 ;
13307
13308   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
13309   {
13310     std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *ptr = (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > > *)0;
13311     res1 = swig::asptr(obj0, &ptr);
13312     if (!SWIG_IsOK(res1)) {
13313       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const &""'");
13314     }
13315     if (!ptr) {
13316       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const &""'");
13317     }
13318     arg1 = ptr;
13319   }
13320   result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >((std::vector< Hex::Vertex * > const &)*arg1);
13321   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
13322   if (SWIG_IsNewObj(res1)) delete arg1;
13323   return resultobj;
13324 fail:
13325   if (SWIG_IsNewObj(res1)) delete arg1;
13326   return NULL;
13327 }
13328
13329
13330 SWIGINTERN PyObject *_wrap_VectorVertices_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13331   PyObject *resultobj = 0;
13332   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13333   void *argp1 = 0 ;
13334   int res1 = 0 ;
13335   PyObject * obj0 = 0 ;
13336   bool result;
13337
13338   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_empty",&obj0)) SWIG_fail;
13339   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13340   if (!SWIG_IsOK(res1)) {
13341     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_empty" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
13342   }
13343   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13344   result = (bool)((std::vector< Hex::Vertex * > const *)arg1)->empty();
13345   resultobj = SWIG_From_bool(static_cast< bool >(result));
13346   return resultobj;
13347 fail:
13348   return NULL;
13349 }
13350
13351
13352 SWIGINTERN PyObject *_wrap_VectorVertices_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13353   PyObject *resultobj = 0;
13354   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13355   void *argp1 = 0 ;
13356   int res1 = 0 ;
13357   PyObject * obj0 = 0 ;
13358   std::vector< Hex::Vertex * >::size_type result;
13359
13360   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_size",&obj0)) SWIG_fail;
13361   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13362   if (!SWIG_IsOK(res1)) {
13363     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_size" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
13364   }
13365   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13366   result = ((std::vector< Hex::Vertex * > const *)arg1)->size();
13367   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
13368   return resultobj;
13369 fail:
13370   return NULL;
13371 }
13372
13373
13374 SWIGINTERN PyObject *_wrap_VectorVertices_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13375   PyObject *resultobj = 0;
13376   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13377   std::vector< Hex::Vertex * > *arg2 = 0 ;
13378   void *argp1 = 0 ;
13379   int res1 = 0 ;
13380   void *argp2 = 0 ;
13381   int res2 = 0 ;
13382   PyObject * obj0 = 0 ;
13383   PyObject * obj1 = 0 ;
13384
13385   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_swap",&obj0,&obj1)) SWIG_fail;
13386   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13387   if (!SWIG_IsOK(res1)) {
13388     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_swap" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13389   }
13390   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13391   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t,  0 );
13392   if (!SWIG_IsOK(res2)) {
13393     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector< Hex::Vertex * > &""'");
13394   }
13395   if (!argp2) {
13396     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorVertices_swap" "', argument " "2"" of type '" "std::vector< Hex::Vertex * > &""'");
13397   }
13398   arg2 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp2);
13399   (arg1)->swap(*arg2);
13400   resultobj = SWIG_Py_Void();
13401   return resultobj;
13402 fail:
13403   return NULL;
13404 }
13405
13406
13407 SWIGINTERN PyObject *_wrap_VectorVertices_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13408   PyObject *resultobj = 0;
13409   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13410   void *argp1 = 0 ;
13411   int res1 = 0 ;
13412   PyObject * obj0 = 0 ;
13413   std::vector< Hex::Vertex * >::iterator result;
13414
13415   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_begin",&obj0)) SWIG_fail;
13416   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13417   if (!SWIG_IsOK(res1)) {
13418     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_begin" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13419   }
13420   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13421   result = (arg1)->begin();
13422   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
13423     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13424   return resultobj;
13425 fail:
13426   return NULL;
13427 }
13428
13429
13430 SWIGINTERN PyObject *_wrap_VectorVertices_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13431   PyObject *resultobj = 0;
13432   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13433   void *argp1 = 0 ;
13434   int res1 = 0 ;
13435   PyObject * obj0 = 0 ;
13436   std::vector< Hex::Vertex * >::iterator result;
13437
13438   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_end",&obj0)) SWIG_fail;
13439   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13440   if (!SWIG_IsOK(res1)) {
13441     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_end" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13442   }
13443   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13444   result = (arg1)->end();
13445   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
13446     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13447   return resultobj;
13448 fail:
13449   return NULL;
13450 }
13451
13452
13453 SWIGINTERN PyObject *_wrap_VectorVertices_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13454   PyObject *resultobj = 0;
13455   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13456   void *argp1 = 0 ;
13457   int res1 = 0 ;
13458   PyObject * obj0 = 0 ;
13459   std::vector< Hex::Vertex * >::reverse_iterator result;
13460
13461   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rbegin",&obj0)) SWIG_fail;
13462   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13463   if (!SWIG_IsOK(res1)) {
13464     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rbegin" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13465   }
13466   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13467   result = (arg1)->rbegin();
13468   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::reverse_iterator & >(result)),
13469     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13470   return resultobj;
13471 fail:
13472   return NULL;
13473 }
13474
13475
13476 SWIGINTERN PyObject *_wrap_VectorVertices_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13477   PyObject *resultobj = 0;
13478   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13479   void *argp1 = 0 ;
13480   int res1 = 0 ;
13481   PyObject * obj0 = 0 ;
13482   std::vector< Hex::Vertex * >::reverse_iterator result;
13483
13484   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_rend",&obj0)) SWIG_fail;
13485   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13486   if (!SWIG_IsOK(res1)) {
13487     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_rend" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13488   }
13489   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13490   result = (arg1)->rend();
13491   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::reverse_iterator & >(result)),
13492     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13493   return resultobj;
13494 fail:
13495   return NULL;
13496 }
13497
13498
13499 SWIGINTERN PyObject *_wrap_VectorVertices_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13500   PyObject *resultobj = 0;
13501   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13502   void *argp1 = 0 ;
13503   int res1 = 0 ;
13504   PyObject * obj0 = 0 ;
13505
13506   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_clear",&obj0)) SWIG_fail;
13507   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13508   if (!SWIG_IsOK(res1)) {
13509     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_clear" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13510   }
13511   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13512   (arg1)->clear();
13513   resultobj = SWIG_Py_Void();
13514   return resultobj;
13515 fail:
13516   return NULL;
13517 }
13518
13519
13520 SWIGINTERN PyObject *_wrap_VectorVertices_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13521   PyObject *resultobj = 0;
13522   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13523   void *argp1 = 0 ;
13524   int res1 = 0 ;
13525   PyObject * obj0 = 0 ;
13526   SwigValueWrapper< std::allocator< Hex::Vertex * > > result;
13527
13528   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_get_allocator",&obj0)) SWIG_fail;
13529   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13530   if (!SWIG_IsOK(res1)) {
13531     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
13532   }
13533   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13534   result = ((std::vector< Hex::Vertex * > const *)arg1)->get_allocator();
13535   resultobj = SWIG_NewPointerObj((new std::vector< Hex::Vertex * >::allocator_type(static_cast< const std::vector< Hex::Vertex * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Hex__Vertex_p_t, SWIG_POINTER_OWN |  0 );
13536   return resultobj;
13537 fail:
13538   return NULL;
13539 }
13540
13541
13542 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13543   PyObject *resultobj = 0;
13544   std::vector< Hex::Vertex * >::size_type arg1 ;
13545   size_t val1 ;
13546   int ecode1 = 0 ;
13547   PyObject * obj0 = 0 ;
13548   std::vector< Hex::Vertex * > *result = 0 ;
13549
13550   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorVertices",&obj0)) SWIG_fail;
13551   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
13552   if (!SWIG_IsOK(ecode1)) {
13553     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
13554   }
13555   arg1 = static_cast< std::vector< Hex::Vertex * >::size_type >(val1);
13556   result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >(arg1);
13557   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
13558   return resultobj;
13559 fail:
13560   return NULL;
13561 }
13562
13563
13564 SWIGINTERN PyObject *_wrap_VectorVertices_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13565   PyObject *resultobj = 0;
13566   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13567   void *argp1 = 0 ;
13568   int res1 = 0 ;
13569   PyObject * obj0 = 0 ;
13570
13571   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_pop_back",&obj0)) SWIG_fail;
13572   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13573   if (!SWIG_IsOK(res1)) {
13574     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_pop_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13575   }
13576   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13577   (arg1)->pop_back();
13578   resultobj = SWIG_Py_Void();
13579   return resultobj;
13580 fail:
13581   return NULL;
13582 }
13583
13584
13585 SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13586   PyObject *resultobj = 0;
13587   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13588   std::vector< Hex::Vertex * >::size_type arg2 ;
13589   void *argp1 = 0 ;
13590   int res1 = 0 ;
13591   size_t val2 ;
13592   int ecode2 = 0 ;
13593   PyObject * obj0 = 0 ;
13594   PyObject * obj1 = 0 ;
13595
13596   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_resize",&obj0,&obj1)) SWIG_fail;
13597   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13598   if (!SWIG_IsOK(res1)) {
13599     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13600   }
13601   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13602   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13603   if (!SWIG_IsOK(ecode2)) {
13604     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
13605   }
13606   arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
13607   (arg1)->resize(arg2);
13608   resultobj = SWIG_Py_Void();
13609   return resultobj;
13610 fail:
13611   return NULL;
13612 }
13613
13614
13615 SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13616   PyObject *resultobj = 0;
13617   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13618   std::vector< Hex::Vertex * >::iterator arg2 ;
13619   void *argp1 = 0 ;
13620   int res1 = 0 ;
13621   swig::SwigPyIterator *iter2 = 0 ;
13622   int res2 ;
13623   PyObject * obj0 = 0 ;
13624   PyObject * obj1 = 0 ;
13625   std::vector< Hex::Vertex * >::iterator result;
13626
13627   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_erase",&obj0,&obj1)) SWIG_fail;
13628   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13629   if (!SWIG_IsOK(res1)) {
13630     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13631   }
13632   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13633   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
13634   if (!SWIG_IsOK(res2) || !iter2) {
13635     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13636   } else {
13637     swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
13638     if (iter_t) {
13639       arg2 = iter_t->get_current();
13640     } else {
13641       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13642     }
13643   }
13644   result = std_vector_Sl_Hex_Vertex_Sm__Sg__erase__SWIG_0(arg1,arg2);
13645   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
13646     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13647   return resultobj;
13648 fail:
13649   return NULL;
13650 }
13651
13652
13653 SWIGINTERN PyObject *_wrap_VectorVertices_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13654   PyObject *resultobj = 0;
13655   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13656   std::vector< Hex::Vertex * >::iterator arg2 ;
13657   std::vector< Hex::Vertex * >::iterator arg3 ;
13658   void *argp1 = 0 ;
13659   int res1 = 0 ;
13660   swig::SwigPyIterator *iter2 = 0 ;
13661   int res2 ;
13662   swig::SwigPyIterator *iter3 = 0 ;
13663   int res3 ;
13664   PyObject * obj0 = 0 ;
13665   PyObject * obj1 = 0 ;
13666   PyObject * obj2 = 0 ;
13667   std::vector< Hex::Vertex * >::iterator result;
13668
13669   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_erase",&obj0,&obj1,&obj2)) SWIG_fail;
13670   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13671   if (!SWIG_IsOK(res1)) {
13672     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_erase" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13673   }
13674   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13675   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
13676   if (!SWIG_IsOK(res2) || !iter2) {
13677     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13678   } else {
13679     swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
13680     if (iter_t) {
13681       arg2 = iter_t->get_current();
13682     } else {
13683       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13684     }
13685   }
13686   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
13687   if (!SWIG_IsOK(res3) || !iter3) {
13688     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13689   } else {
13690     swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter3);
13691     if (iter_t) {
13692       arg3 = iter_t->get_current();
13693     } else {
13694       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_erase" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
13695     }
13696   }
13697   result = std_vector_Sl_Hex_Vertex_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
13698   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
13699     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
13700   return resultobj;
13701 fail:
13702   return NULL;
13703 }
13704
13705
13706 SWIGINTERN PyObject *_wrap_VectorVertices_erase(PyObject *self, PyObject *args) {
13707   Py_ssize_t argc;
13708   PyObject *argv[4] = {
13709     0
13710   };
13711   Py_ssize_t ii;
13712
13713   if (!PyTuple_Check(args)) SWIG_fail;
13714   argc = args ? PyObject_Length(args) : 0;
13715   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
13716     argv[ii] = PyTuple_GET_ITEM(args,ii);
13717   }
13718   if (argc == 2) {
13719     int _v;
13720     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13721     _v = SWIG_CheckState(res);
13722     if (_v) {
13723       swig::SwigPyIterator *iter = 0;
13724       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
13725       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
13726       if (_v) {
13727         return _wrap_VectorVertices_erase__SWIG_0(self, args);
13728       }
13729     }
13730   }
13731   if (argc == 3) {
13732     int _v;
13733     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13734     _v = SWIG_CheckState(res);
13735     if (_v) {
13736       swig::SwigPyIterator *iter = 0;
13737       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
13738       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
13739       if (_v) {
13740         swig::SwigPyIterator *iter = 0;
13741         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
13742         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
13743         if (_v) {
13744           return _wrap_VectorVertices_erase__SWIG_1(self, args);
13745         }
13746       }
13747     }
13748   }
13749
13750 fail:
13751   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices_erase'.\n"
13752     "  Possible C/C++ prototypes are:\n"
13753     "    std::vector< Hex::Vertex * >::erase(std::vector< Hex::Vertex * >::iterator)\n"
13754     "    std::vector< Hex::Vertex * >::erase(std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::iterator)\n");
13755   return 0;
13756 }
13757
13758
13759 SWIGINTERN PyObject *_wrap_new_VectorVertices__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13760   PyObject *resultobj = 0;
13761   std::vector< Hex::Vertex * >::size_type arg1 ;
13762   std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13763   size_t val1 ;
13764   int ecode1 = 0 ;
13765   void *argp2 = 0 ;
13766   int res2 = 0 ;
13767   PyObject * obj0 = 0 ;
13768   PyObject * obj1 = 0 ;
13769   std::vector< Hex::Vertex * > *result = 0 ;
13770
13771   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorVertices",&obj0,&obj1)) SWIG_fail;
13772   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
13773   if (!SWIG_IsOK(ecode1)) {
13774     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
13775   }
13776   arg1 = static_cast< std::vector< Hex::Vertex * >::size_type >(val1);
13777   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
13778   if (!SWIG_IsOK(res2)) {
13779     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorVertices" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13780   }
13781   arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
13782   result = (std::vector< Hex::Vertex * > *)new std::vector< Hex::Vertex * >(arg1,arg2);
13783   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_NEW |  0 );
13784   return resultobj;
13785 fail:
13786   return NULL;
13787 }
13788
13789
13790 SWIGINTERN PyObject *_wrap_new_VectorVertices(PyObject *self, PyObject *args) {
13791   Py_ssize_t argc;
13792   PyObject *argv[3] = {
13793     0
13794   };
13795   Py_ssize_t ii;
13796
13797   if (!PyTuple_Check(args)) SWIG_fail;
13798   argc = args ? PyObject_Length(args) : 0;
13799   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
13800     argv[ii] = PyTuple_GET_ITEM(args,ii);
13801   }
13802   if (argc == 0) {
13803     return _wrap_new_VectorVertices__SWIG_0(self, args);
13804   }
13805   if (argc == 1) {
13806     int _v;
13807     {
13808       int res = SWIG_AsVal_size_t(argv[0], NULL);
13809       _v = SWIG_CheckState(res);
13810     }
13811     if (_v) {
13812       return _wrap_new_VectorVertices__SWIG_2(self, args);
13813     }
13814   }
13815   if (argc == 1) {
13816     int _v;
13817     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
13818     _v = SWIG_CheckState(res);
13819     if (_v) {
13820       return _wrap_new_VectorVertices__SWIG_1(self, args);
13821     }
13822   }
13823   if (argc == 2) {
13824     int _v;
13825     {
13826       int res = SWIG_AsVal_size_t(argv[0], NULL);
13827       _v = SWIG_CheckState(res);
13828     }
13829     if (_v) {
13830       void *vptr = 0;
13831       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
13832       _v = SWIG_CheckState(res);
13833       if (_v) {
13834         return _wrap_new_VectorVertices__SWIG_3(self, args);
13835       }
13836     }
13837   }
13838
13839 fail:
13840   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorVertices'.\n"
13841     "  Possible C/C++ prototypes are:\n"
13842     "    std::vector< Hex::Vertex * >::vector()\n"
13843     "    std::vector< Hex::Vertex * >::vector(std::vector< Hex::Vertex * > const &)\n"
13844     "    std::vector< Hex::Vertex * >::vector(std::vector< Hex::Vertex * >::size_type)\n"
13845     "    std::vector< Hex::Vertex * >::vector(std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
13846   return 0;
13847 }
13848
13849
13850 SWIGINTERN PyObject *_wrap_VectorVertices_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13851   PyObject *resultobj = 0;
13852   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13853   std::vector< Hex::Vertex * >::value_type arg2 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13854   void *argp1 = 0 ;
13855   int res1 = 0 ;
13856   void *argp2 = 0 ;
13857   int res2 = 0 ;
13858   PyObject * obj0 = 0 ;
13859   PyObject * obj1 = 0 ;
13860
13861   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_push_back",&obj0,&obj1)) SWIG_fail;
13862   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13863   if (!SWIG_IsOK(res1)) {
13864     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_push_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13865   }
13866   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13867   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
13868   if (!SWIG_IsOK(res2)) {
13869     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorVertices_push_back" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13870   }
13871   arg2 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp2);
13872   (arg1)->push_back(arg2);
13873   resultobj = SWIG_Py_Void();
13874   return resultobj;
13875 fail:
13876   return NULL;
13877 }
13878
13879
13880 SWIGINTERN PyObject *_wrap_VectorVertices_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13881   PyObject *resultobj = 0;
13882   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13883   void *argp1 = 0 ;
13884   int res1 = 0 ;
13885   PyObject * obj0 = 0 ;
13886   std::vector< Hex::Vertex * >::value_type result;
13887
13888   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_front",&obj0)) SWIG_fail;
13889   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13890   if (!SWIG_IsOK(res1)) {
13891     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_front" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
13892   }
13893   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13894   result = (std::vector< Hex::Vertex * >::value_type)((std::vector< Hex::Vertex * > const *)arg1)->front();
13895   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
13896   return resultobj;
13897 fail:
13898   return NULL;
13899 }
13900
13901
13902 SWIGINTERN PyObject *_wrap_VectorVertices_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13903   PyObject *resultobj = 0;
13904   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13905   void *argp1 = 0 ;
13906   int res1 = 0 ;
13907   PyObject * obj0 = 0 ;
13908   std::vector< Hex::Vertex * >::value_type result;
13909
13910   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_back",&obj0)) SWIG_fail;
13911   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13912   if (!SWIG_IsOK(res1)) {
13913     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_back" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
13914   }
13915   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13916   result = (std::vector< Hex::Vertex * >::value_type)((std::vector< Hex::Vertex * > const *)arg1)->back();
13917   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
13918   return resultobj;
13919 fail:
13920   return NULL;
13921 }
13922
13923
13924 SWIGINTERN PyObject *_wrap_VectorVertices_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13925   PyObject *resultobj = 0;
13926   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13927   std::vector< Hex::Vertex * >::size_type arg2 ;
13928   std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13929   void *argp1 = 0 ;
13930   int res1 = 0 ;
13931   size_t val2 ;
13932   int ecode2 = 0 ;
13933   void *argp3 = 0 ;
13934   int res3 = 0 ;
13935   PyObject * obj0 = 0 ;
13936   PyObject * obj1 = 0 ;
13937   PyObject * obj2 = 0 ;
13938
13939   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_assign",&obj0,&obj1,&obj2)) SWIG_fail;
13940   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13941   if (!SWIG_IsOK(res1)) {
13942     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_assign" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13943   }
13944   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13945   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13946   if (!SWIG_IsOK(ecode2)) {
13947     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_assign" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
13948   }
13949   arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
13950   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
13951   if (!SWIG_IsOK(res3)) {
13952     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_assign" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13953   }
13954   arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
13955   (arg1)->assign(arg2,arg3);
13956   resultobj = SWIG_Py_Void();
13957   return resultobj;
13958 fail:
13959   return NULL;
13960 }
13961
13962
13963 SWIGINTERN PyObject *_wrap_VectorVertices_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13964   PyObject *resultobj = 0;
13965   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
13966   std::vector< Hex::Vertex * >::size_type arg2 ;
13967   std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
13968   void *argp1 = 0 ;
13969   int res1 = 0 ;
13970   size_t val2 ;
13971   int ecode2 = 0 ;
13972   void *argp3 = 0 ;
13973   int res3 = 0 ;
13974   PyObject * obj0 = 0 ;
13975   PyObject * obj1 = 0 ;
13976   PyObject * obj2 = 0 ;
13977
13978   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_resize",&obj0,&obj1,&obj2)) SWIG_fail;
13979   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
13980   if (!SWIG_IsOK(res1)) {
13981     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_resize" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
13982   }
13983   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
13984   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13985   if (!SWIG_IsOK(ecode2)) {
13986     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_resize" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
13987   }
13988   arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
13989   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
13990   if (!SWIG_IsOK(res3)) {
13991     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_resize" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
13992   }
13993   arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
13994   (arg1)->resize(arg2,arg3);
13995   resultobj = SWIG_Py_Void();
13996   return resultobj;
13997 fail:
13998   return NULL;
13999 }
14000
14001
14002 SWIGINTERN PyObject *_wrap_VectorVertices_resize(PyObject *self, PyObject *args) {
14003   Py_ssize_t argc;
14004   PyObject *argv[4] = {
14005     0
14006   };
14007   Py_ssize_t ii;
14008
14009   if (!PyTuple_Check(args)) SWIG_fail;
14010   argc = args ? PyObject_Length(args) : 0;
14011   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
14012     argv[ii] = PyTuple_GET_ITEM(args,ii);
14013   }
14014   if (argc == 2) {
14015     int _v;
14016     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
14017     _v = SWIG_CheckState(res);
14018     if (_v) {
14019       {
14020         int res = SWIG_AsVal_size_t(argv[1], NULL);
14021         _v = SWIG_CheckState(res);
14022       }
14023       if (_v) {
14024         return _wrap_VectorVertices_resize__SWIG_0(self, args);
14025       }
14026     }
14027   }
14028   if (argc == 3) {
14029     int _v;
14030     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
14031     _v = SWIG_CheckState(res);
14032     if (_v) {
14033       {
14034         int res = SWIG_AsVal_size_t(argv[1], NULL);
14035         _v = SWIG_CheckState(res);
14036       }
14037       if (_v) {
14038         void *vptr = 0;
14039         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
14040         _v = SWIG_CheckState(res);
14041         if (_v) {
14042           return _wrap_VectorVertices_resize__SWIG_1(self, args);
14043         }
14044       }
14045     }
14046   }
14047
14048 fail:
14049   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices_resize'.\n"
14050     "  Possible C/C++ prototypes are:\n"
14051     "    std::vector< Hex::Vertex * >::resize(std::vector< Hex::Vertex * >::size_type)\n"
14052     "    std::vector< Hex::Vertex * >::resize(std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
14053   return 0;
14054 }
14055
14056
14057 SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14058   PyObject *resultobj = 0;
14059   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
14060   std::vector< Hex::Vertex * >::iterator arg2 ;
14061   std::vector< Hex::Vertex * >::value_type arg3 = (std::vector< Hex::Vertex * >::value_type) 0 ;
14062   void *argp1 = 0 ;
14063   int res1 = 0 ;
14064   swig::SwigPyIterator *iter2 = 0 ;
14065   int res2 ;
14066   void *argp3 = 0 ;
14067   int res3 = 0 ;
14068   PyObject * obj0 = 0 ;
14069   PyObject * obj1 = 0 ;
14070   PyObject * obj2 = 0 ;
14071   std::vector< Hex::Vertex * >::iterator result;
14072
14073   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorVertices_insert",&obj0,&obj1,&obj2)) SWIG_fail;
14074   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
14075   if (!SWIG_IsOK(res1)) {
14076     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
14077   }
14078   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
14079   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
14080   if (!SWIG_IsOK(res2) || !iter2) {
14081     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
14082   } else {
14083     swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
14084     if (iter_t) {
14085       arg2 = iter_t->get_current();
14086     } else {
14087       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
14088     }
14089   }
14090   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
14091   if (!SWIG_IsOK(res3)) {
14092     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
14093   }
14094   arg3 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp3);
14095   result = std_vector_Sl_Hex_Vertex_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
14096   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::Vertex * >::iterator & >(result)),
14097     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
14098   return resultobj;
14099 fail:
14100   return NULL;
14101 }
14102
14103
14104 SWIGINTERN PyObject *_wrap_VectorVertices_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14105   PyObject *resultobj = 0;
14106   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
14107   std::vector< Hex::Vertex * >::iterator arg2 ;
14108   std::vector< Hex::Vertex * >::size_type arg3 ;
14109   std::vector< Hex::Vertex * >::value_type arg4 = (std::vector< Hex::Vertex * >::value_type) 0 ;
14110   void *argp1 = 0 ;
14111   int res1 = 0 ;
14112   swig::SwigPyIterator *iter2 = 0 ;
14113   int res2 ;
14114   size_t val3 ;
14115   int ecode3 = 0 ;
14116   void *argp4 = 0 ;
14117   int res4 = 0 ;
14118   PyObject * obj0 = 0 ;
14119   PyObject * obj1 = 0 ;
14120   PyObject * obj2 = 0 ;
14121   PyObject * obj3 = 0 ;
14122
14123   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorVertices_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14124   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
14125   if (!SWIG_IsOK(res1)) {
14126     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_insert" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
14127   }
14128   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
14129   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
14130   if (!SWIG_IsOK(res2) || !iter2) {
14131     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
14132   } else {
14133     swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter2);
14134     if (iter_t) {
14135       arg2 = iter_t->get_current();
14136     } else {
14137       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorVertices_insert" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::iterator""'");
14138     }
14139   }
14140   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14141   if (!SWIG_IsOK(ecode3)) {
14142     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorVertices_insert" "', argument " "3"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
14143   }
14144   arg3 = static_cast< std::vector< Hex::Vertex * >::size_type >(val3);
14145   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
14146   if (!SWIG_IsOK(res4)) {
14147     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorVertices_insert" "', argument " "4"" of type '" "std::vector< Hex::Vertex * >::value_type""'");
14148   }
14149   arg4 = reinterpret_cast< std::vector< Hex::Vertex * >::value_type >(argp4);
14150   std_vector_Sl_Hex_Vertex_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
14151   resultobj = SWIG_Py_Void();
14152   return resultobj;
14153 fail:
14154   return NULL;
14155 }
14156
14157
14158 SWIGINTERN PyObject *_wrap_VectorVertices_insert(PyObject *self, PyObject *args) {
14159   Py_ssize_t argc;
14160   PyObject *argv[5] = {
14161     0
14162   };
14163   Py_ssize_t ii;
14164
14165   if (!PyTuple_Check(args)) SWIG_fail;
14166   argc = args ? PyObject_Length(args) : 0;
14167   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
14168     argv[ii] = PyTuple_GET_ITEM(args,ii);
14169   }
14170   if (argc == 3) {
14171     int _v;
14172     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
14173     _v = SWIG_CheckState(res);
14174     if (_v) {
14175       swig::SwigPyIterator *iter = 0;
14176       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
14177       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
14178       if (_v) {
14179         void *vptr = 0;
14180         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
14181         _v = SWIG_CheckState(res);
14182         if (_v) {
14183           return _wrap_VectorVertices_insert__SWIG_0(self, args);
14184         }
14185       }
14186     }
14187   }
14188   if (argc == 4) {
14189     int _v;
14190     int res = swig::asptr(argv[0], (std::vector< Hex::Vertex*,std::allocator< Hex::Vertex * > >**)(0));
14191     _v = SWIG_CheckState(res);
14192     if (_v) {
14193       swig::SwigPyIterator *iter = 0;
14194       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
14195       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::Vertex * >::iterator > *>(iter) != 0));
14196       if (_v) {
14197         {
14198           int res = SWIG_AsVal_size_t(argv[2], NULL);
14199           _v = SWIG_CheckState(res);
14200         }
14201         if (_v) {
14202           void *vptr = 0;
14203           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
14204           _v = SWIG_CheckState(res);
14205           if (_v) {
14206             return _wrap_VectorVertices_insert__SWIG_1(self, args);
14207           }
14208         }
14209       }
14210     }
14211   }
14212
14213 fail:
14214   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorVertices_insert'.\n"
14215     "  Possible C/C++ prototypes are:\n"
14216     "    std::vector< Hex::Vertex * >::insert(std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::value_type)\n"
14217     "    std::vector< Hex::Vertex * >::insert(std::vector< Hex::Vertex * >::iterator,std::vector< Hex::Vertex * >::size_type,std::vector< Hex::Vertex * >::value_type)\n");
14218   return 0;
14219 }
14220
14221
14222 SWIGINTERN PyObject *_wrap_VectorVertices_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14223   PyObject *resultobj = 0;
14224   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
14225   std::vector< Hex::Vertex * >::size_type arg2 ;
14226   void *argp1 = 0 ;
14227   int res1 = 0 ;
14228   size_t val2 ;
14229   int ecode2 = 0 ;
14230   PyObject * obj0 = 0 ;
14231   PyObject * obj1 = 0 ;
14232
14233   if (!PyArg_ParseTuple(args,(char *)"OO:VectorVertices_reserve",&obj0,&obj1)) SWIG_fail;
14234   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
14235   if (!SWIG_IsOK(res1)) {
14236     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_reserve" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
14237   }
14238   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
14239   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
14240   if (!SWIG_IsOK(ecode2)) {
14241     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorVertices_reserve" "', argument " "2"" of type '" "std::vector< Hex::Vertex * >::size_type""'");
14242   }
14243   arg2 = static_cast< std::vector< Hex::Vertex * >::size_type >(val2);
14244   (arg1)->reserve(arg2);
14245   resultobj = SWIG_Py_Void();
14246   return resultobj;
14247 fail:
14248   return NULL;
14249 }
14250
14251
14252 SWIGINTERN PyObject *_wrap_VectorVertices_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14253   PyObject *resultobj = 0;
14254   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
14255   void *argp1 = 0 ;
14256   int res1 = 0 ;
14257   PyObject * obj0 = 0 ;
14258   std::vector< Hex::Vertex * >::size_type result;
14259
14260   if (!PyArg_ParseTuple(args,(char *)"O:VectorVertices_capacity",&obj0)) SWIG_fail;
14261   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0 |  0 );
14262   if (!SWIG_IsOK(res1)) {
14263     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorVertices_capacity" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > const *""'");
14264   }
14265   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
14266   result = ((std::vector< Hex::Vertex * > const *)arg1)->capacity();
14267   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
14268   return resultobj;
14269 fail:
14270   return NULL;
14271 }
14272
14273
14274 SWIGINTERN PyObject *_wrap_delete_VectorVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14275   PyObject *resultobj = 0;
14276   std::vector< Hex::Vertex * > *arg1 = (std::vector< Hex::Vertex * > *) 0 ;
14277   void *argp1 = 0 ;
14278   int res1 = 0 ;
14279   PyObject * obj0 = 0 ;
14280
14281   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorVertices",&obj0)) SWIG_fail;
14282   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_POINTER_DISOWN |  0 );
14283   if (!SWIG_IsOK(res1)) {
14284     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorVertices" "', argument " "1"" of type '" "std::vector< Hex::Vertex * > *""'");
14285   }
14286   arg1 = reinterpret_cast< std::vector< Hex::Vertex * > * >(argp1);
14287   delete arg1;
14288   resultobj = SWIG_Py_Void();
14289   return resultobj;
14290 fail:
14291   return NULL;
14292 }
14293
14294
14295 SWIGINTERN PyObject *VectorVertices_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14296   PyObject *obj;
14297   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
14298   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, SWIG_NewClientData(obj));
14299   return SWIG_Py_Void();
14300 }
14301
14302 SWIGINTERN PyObject *_wrap_VectorShapes_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14303   PyObject *resultobj = 0;
14304   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14305   PyObject **arg2 = (PyObject **) 0 ;
14306   void *argp1 = 0 ;
14307   int res1 = 0 ;
14308   PyObject * obj0 = 0 ;
14309   swig::SwigPyIterator *result = 0 ;
14310
14311   arg2 = &obj0;
14312   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_iterator",&obj0)) SWIG_fail;
14313   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14314   if (!SWIG_IsOK(res1)) {
14315     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_iterator" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14316   }
14317   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14318   result = (swig::SwigPyIterator *)std_vector_Sl_Hex_NewShape_Sm__Sg__iterator(arg1,arg2);
14319   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
14320   return resultobj;
14321 fail:
14322   return NULL;
14323 }
14324
14325
14326 SWIGINTERN PyObject *_wrap_VectorShapes___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14327   PyObject *resultobj = 0;
14328   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14329   void *argp1 = 0 ;
14330   int res1 = 0 ;
14331   PyObject * obj0 = 0 ;
14332   bool result;
14333
14334   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___nonzero__",&obj0)) SWIG_fail;
14335   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14336   if (!SWIG_IsOK(res1)) {
14337     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___nonzero__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
14338   }
14339   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14340   result = (bool)std_vector_Sl_Hex_NewShape_Sm__Sg____nonzero__((std::vector< Hex::NewShape * > const *)arg1);
14341   resultobj = SWIG_From_bool(static_cast< bool >(result));
14342   return resultobj;
14343 fail:
14344   return NULL;
14345 }
14346
14347
14348 SWIGINTERN PyObject *_wrap_VectorShapes___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14349   PyObject *resultobj = 0;
14350   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14351   void *argp1 = 0 ;
14352   int res1 = 0 ;
14353   PyObject * obj0 = 0 ;
14354   bool result;
14355
14356   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___bool__",&obj0)) SWIG_fail;
14357   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14358   if (!SWIG_IsOK(res1)) {
14359     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___bool__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
14360   }
14361   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14362   result = (bool)std_vector_Sl_Hex_NewShape_Sm__Sg____bool__((std::vector< Hex::NewShape * > const *)arg1);
14363   resultobj = SWIG_From_bool(static_cast< bool >(result));
14364   return resultobj;
14365 fail:
14366   return NULL;
14367 }
14368
14369
14370 SWIGINTERN PyObject *_wrap_VectorShapes___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14371   PyObject *resultobj = 0;
14372   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14373   void *argp1 = 0 ;
14374   int res1 = 0 ;
14375   PyObject * obj0 = 0 ;
14376   std::vector< Hex::NewShape * >::size_type result;
14377
14378   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes___len__",&obj0)) SWIG_fail;
14379   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14380   if (!SWIG_IsOK(res1)) {
14381     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___len__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
14382   }
14383   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14384   result = std_vector_Sl_Hex_NewShape_Sm__Sg____len__((std::vector< Hex::NewShape * > const *)arg1);
14385   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
14386   return resultobj;
14387 fail:
14388   return NULL;
14389 }
14390
14391
14392 SWIGINTERN PyObject *_wrap_VectorShapes___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14393   PyObject *resultobj = 0;
14394   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14395   std::vector< Hex::NewShape * >::difference_type arg2 ;
14396   std::vector< Hex::NewShape * >::difference_type arg3 ;
14397   void *argp1 = 0 ;
14398   int res1 = 0 ;
14399   ptrdiff_t val2 ;
14400   int ecode2 = 0 ;
14401   ptrdiff_t val3 ;
14402   int ecode3 = 0 ;
14403   PyObject * obj0 = 0 ;
14404   PyObject * obj1 = 0 ;
14405   PyObject * obj2 = 0 ;
14406   std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *result = 0 ;
14407
14408   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
14409   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14410   if (!SWIG_IsOK(res1)) {
14411     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14412   }
14413   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14414   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14415   if (!SWIG_IsOK(ecode2)) {
14416     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14417   }
14418   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14419   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
14420   if (!SWIG_IsOK(ecode3)) {
14421     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___getslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14422   }
14423   arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
14424   try {
14425     result = (std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *)std_vector_Sl_Hex_NewShape_Sm__Sg____getslice__(arg1,arg2,arg3);
14426   }
14427   catch(std::out_of_range &_e) {
14428     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14429   }
14430   catch(std::invalid_argument &_e) {
14431     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14432   }
14433
14434   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_OWN |  0 );
14435   return resultobj;
14436 fail:
14437   return NULL;
14438 }
14439
14440
14441 SWIGINTERN PyObject *_wrap_VectorShapes___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14442   PyObject *resultobj = 0;
14443   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14444   std::vector< Hex::NewShape * >::difference_type arg2 ;
14445   std::vector< Hex::NewShape * >::difference_type arg3 ;
14446   void *argp1 = 0 ;
14447   int res1 = 0 ;
14448   ptrdiff_t val2 ;
14449   int ecode2 = 0 ;
14450   ptrdiff_t val3 ;
14451   int ecode3 = 0 ;
14452   PyObject * obj0 = 0 ;
14453   PyObject * obj1 = 0 ;
14454   PyObject * obj2 = 0 ;
14455
14456   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
14457   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14458   if (!SWIG_IsOK(res1)) {
14459     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14460   }
14461   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14462   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14463   if (!SWIG_IsOK(ecode2)) {
14464     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14465   }
14466   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14467   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
14468   if (!SWIG_IsOK(ecode3)) {
14469     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___setslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14470   }
14471   arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
14472   try {
14473     std_vector_Sl_Hex_NewShape_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
14474   }
14475   catch(std::out_of_range &_e) {
14476     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14477   }
14478   catch(std::invalid_argument &_e) {
14479     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14480   }
14481
14482   resultobj = SWIG_Py_Void();
14483   return resultobj;
14484 fail:
14485   return NULL;
14486 }
14487
14488
14489 SWIGINTERN PyObject *_wrap_VectorShapes___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14490   PyObject *resultobj = 0;
14491   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14492   std::vector< Hex::NewShape * >::difference_type arg2 ;
14493   std::vector< Hex::NewShape * >::difference_type arg3 ;
14494   std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *arg4 = 0 ;
14495   void *argp1 = 0 ;
14496   int res1 = 0 ;
14497   ptrdiff_t val2 ;
14498   int ecode2 = 0 ;
14499   ptrdiff_t val3 ;
14500   int ecode3 = 0 ;
14501   int res4 = SWIG_OLDOBJ ;
14502   PyObject * obj0 = 0 ;
14503   PyObject * obj1 = 0 ;
14504   PyObject * obj2 = 0 ;
14505   PyObject * obj3 = 0 ;
14506
14507   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14508   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14509   if (!SWIG_IsOK(res1)) {
14510     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14511   }
14512   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14513   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14514   if (!SWIG_IsOK(ecode2)) {
14515     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14516   }
14517   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14518   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
14519   if (!SWIG_IsOK(ecode3)) {
14520     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___setslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14521   }
14522   arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
14523   {
14524     std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
14525     res4 = swig::asptr(obj3, &ptr);
14526     if (!SWIG_IsOK(res4)) {
14527       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes___setslice__" "', argument " "4"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
14528     }
14529     if (!ptr) {
14530       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 &""'");
14531     }
14532     arg4 = ptr;
14533   }
14534   try {
14535     std_vector_Sl_Hex_NewShape_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)*arg4);
14536   }
14537   catch(std::out_of_range &_e) {
14538     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14539   }
14540   catch(std::invalid_argument &_e) {
14541     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14542   }
14543
14544   resultobj = SWIG_Py_Void();
14545   if (SWIG_IsNewObj(res4)) delete arg4;
14546   return resultobj;
14547 fail:
14548   if (SWIG_IsNewObj(res4)) delete arg4;
14549   return NULL;
14550 }
14551
14552
14553 SWIGINTERN PyObject *_wrap_VectorShapes___setslice__(PyObject *self, PyObject *args) {
14554   Py_ssize_t argc;
14555   PyObject *argv[5] = {
14556     0
14557   };
14558   Py_ssize_t ii;
14559
14560   if (!PyTuple_Check(args)) SWIG_fail;
14561   argc = args ? PyObject_Length(args) : 0;
14562   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
14563     argv[ii] = PyTuple_GET_ITEM(args,ii);
14564   }
14565   if (argc == 3) {
14566     int _v;
14567     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14568     _v = SWIG_CheckState(res);
14569     if (_v) {
14570       {
14571         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
14572         _v = SWIG_CheckState(res);
14573       }
14574       if (_v) {
14575         {
14576           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
14577           _v = SWIG_CheckState(res);
14578         }
14579         if (_v) {
14580           return _wrap_VectorShapes___setslice____SWIG_0(self, args);
14581         }
14582       }
14583     }
14584   }
14585   if (argc == 4) {
14586     int _v;
14587     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14588     _v = SWIG_CheckState(res);
14589     if (_v) {
14590       {
14591         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
14592         _v = SWIG_CheckState(res);
14593       }
14594       if (_v) {
14595         {
14596           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
14597           _v = SWIG_CheckState(res);
14598         }
14599         if (_v) {
14600           int res = swig::asptr(argv[3], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14601           _v = SWIG_CheckState(res);
14602           if (_v) {
14603             return _wrap_VectorShapes___setslice____SWIG_1(self, args);
14604           }
14605         }
14606       }
14607     }
14608   }
14609
14610 fail:
14611   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes___setslice__'.\n"
14612     "  Possible C/C++ prototypes are:\n"
14613     "    std::vector< Hex::NewShape * >::__setslice__(std::vector< Hex::NewShape * >::difference_type,std::vector< Hex::NewShape * >::difference_type)\n"
14614     "    std::vector< Hex::NewShape * >::__setslice__(std::vector< Hex::NewShape * >::difference_type,std::vector< Hex::NewShape * >::difference_type,std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)\n");
14615   return 0;
14616 }
14617
14618
14619 SWIGINTERN PyObject *_wrap_VectorShapes___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14620   PyObject *resultobj = 0;
14621   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14622   std::vector< Hex::NewShape * >::difference_type arg2 ;
14623   std::vector< Hex::NewShape * >::difference_type arg3 ;
14624   void *argp1 = 0 ;
14625   int res1 = 0 ;
14626   ptrdiff_t val2 ;
14627   int ecode2 = 0 ;
14628   ptrdiff_t val3 ;
14629   int ecode3 = 0 ;
14630   PyObject * obj0 = 0 ;
14631   PyObject * obj1 = 0 ;
14632   PyObject * obj2 = 0 ;
14633
14634   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
14635   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14636   if (!SWIG_IsOK(res1)) {
14637     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delslice__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14638   }
14639   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14640   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14641   if (!SWIG_IsOK(ecode2)) {
14642     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delslice__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14643   }
14644   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14645   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
14646   if (!SWIG_IsOK(ecode3)) {
14647     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes___delslice__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14648   }
14649   arg3 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val3);
14650   try {
14651     std_vector_Sl_Hex_NewShape_Sm__Sg____delslice__(arg1,arg2,arg3);
14652   }
14653   catch(std::out_of_range &_e) {
14654     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14655   }
14656   catch(std::invalid_argument &_e) {
14657     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14658   }
14659
14660   resultobj = SWIG_Py_Void();
14661   return resultobj;
14662 fail:
14663   return NULL;
14664 }
14665
14666
14667 SWIGINTERN PyObject *_wrap_VectorShapes___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14668   PyObject *resultobj = 0;
14669   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14670   std::vector< Hex::NewShape * >::difference_type arg2 ;
14671   void *argp1 = 0 ;
14672   int res1 = 0 ;
14673   ptrdiff_t val2 ;
14674   int ecode2 = 0 ;
14675   PyObject * obj0 = 0 ;
14676   PyObject * obj1 = 0 ;
14677
14678   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___delitem__",&obj0,&obj1)) SWIG_fail;
14679   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14680   if (!SWIG_IsOK(res1)) {
14681     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14682   }
14683   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14684   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14685   if (!SWIG_IsOK(ecode2)) {
14686     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___delitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14687   }
14688   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14689   try {
14690     std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_0(arg1,arg2);
14691   }
14692   catch(std::out_of_range &_e) {
14693     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14694   }
14695   catch(std::invalid_argument &_e) {
14696     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14697   }
14698
14699   resultobj = SWIG_Py_Void();
14700   return resultobj;
14701 fail:
14702   return NULL;
14703 }
14704
14705
14706 SWIGINTERN PyObject *_wrap_VectorShapes___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14707   PyObject *resultobj = 0;
14708   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14709   PySliceObject *arg2 = (PySliceObject *) 0 ;
14710   void *argp1 = 0 ;
14711   int res1 = 0 ;
14712   PyObject * obj0 = 0 ;
14713   PyObject * obj1 = 0 ;
14714   std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *result = 0 ;
14715
14716   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___getitem__",&obj0,&obj1)) SWIG_fail;
14717   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14718   if (!SWIG_IsOK(res1)) {
14719     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14720   }
14721   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14722   {
14723     if (!PySlice_Check(obj1)) {
14724       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
14725     }
14726     arg2 = (PySliceObject *) obj1;
14727   }
14728   try {
14729     result = (std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *)std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_0(arg1,arg2);
14730   }
14731   catch(std::out_of_range &_e) {
14732     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14733   }
14734   catch(std::invalid_argument &_e) {
14735     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14736   }
14737
14738   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_OWN |  0 );
14739   return resultobj;
14740 fail:
14741   return NULL;
14742 }
14743
14744
14745 SWIGINTERN PyObject *_wrap_VectorShapes___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14746   PyObject *resultobj = 0;
14747   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14748   PySliceObject *arg2 = (PySliceObject *) 0 ;
14749   std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *arg3 = 0 ;
14750   void *argp1 = 0 ;
14751   int res1 = 0 ;
14752   int res3 = SWIG_OLDOBJ ;
14753   PyObject * obj0 = 0 ;
14754   PyObject * obj1 = 0 ;
14755   PyObject * obj2 = 0 ;
14756
14757   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
14758   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14759   if (!SWIG_IsOK(res1)) {
14760     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14761   }
14762   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14763   {
14764     if (!PySlice_Check(obj1)) {
14765       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
14766     }
14767     arg2 = (PySliceObject *) obj1;
14768   }
14769   {
14770     std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
14771     res3 = swig::asptr(obj2, &ptr);
14772     if (!SWIG_IsOK(res3)) {
14773       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
14774     }
14775     if (!ptr) {
14776       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &""'");
14777     }
14778     arg3 = ptr;
14779   }
14780   try {
14781     std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)*arg3);
14782   }
14783   catch(std::out_of_range &_e) {
14784     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14785   }
14786   catch(std::invalid_argument &_e) {
14787     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14788   }
14789
14790   resultobj = SWIG_Py_Void();
14791   if (SWIG_IsNewObj(res3)) delete arg3;
14792   return resultobj;
14793 fail:
14794   if (SWIG_IsNewObj(res3)) delete arg3;
14795   return NULL;
14796 }
14797
14798
14799 SWIGINTERN PyObject *_wrap_VectorShapes___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14800   PyObject *resultobj = 0;
14801   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14802   PySliceObject *arg2 = (PySliceObject *) 0 ;
14803   void *argp1 = 0 ;
14804   int res1 = 0 ;
14805   PyObject * obj0 = 0 ;
14806   PyObject * obj1 = 0 ;
14807
14808   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___setitem__",&obj0,&obj1)) SWIG_fail;
14809   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14810   if (!SWIG_IsOK(res1)) {
14811     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14812   }
14813   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14814   {
14815     if (!PySlice_Check(obj1)) {
14816       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
14817     }
14818     arg2 = (PySliceObject *) obj1;
14819   }
14820   try {
14821     std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_1(arg1,arg2);
14822   }
14823   catch(std::out_of_range &_e) {
14824     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14825   }
14826   catch(std::invalid_argument &_e) {
14827     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14828   }
14829
14830   resultobj = SWIG_Py_Void();
14831   return resultobj;
14832 fail:
14833   return NULL;
14834 }
14835
14836
14837 SWIGINTERN PyObject *_wrap_VectorShapes___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14838   PyObject *resultobj = 0;
14839   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14840   PySliceObject *arg2 = (PySliceObject *) 0 ;
14841   void *argp1 = 0 ;
14842   int res1 = 0 ;
14843   PyObject * obj0 = 0 ;
14844   PyObject * obj1 = 0 ;
14845
14846   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___delitem__",&obj0,&obj1)) SWIG_fail;
14847   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14848   if (!SWIG_IsOK(res1)) {
14849     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___delitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14850   }
14851   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14852   {
14853     if (!PySlice_Check(obj1)) {
14854       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
14855     }
14856     arg2 = (PySliceObject *) obj1;
14857   }
14858   try {
14859     std_vector_Sl_Hex_NewShape_Sm__Sg____delitem____SWIG_1(arg1,arg2);
14860   }
14861   catch(std::out_of_range &_e) {
14862     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14863   }
14864   catch(std::invalid_argument &_e) {
14865     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
14866   }
14867
14868   resultobj = SWIG_Py_Void();
14869   return resultobj;
14870 fail:
14871   return NULL;
14872 }
14873
14874
14875 SWIGINTERN PyObject *_wrap_VectorShapes___delitem__(PyObject *self, PyObject *args) {
14876   Py_ssize_t argc;
14877   PyObject *argv[3] = {
14878     0
14879   };
14880   Py_ssize_t ii;
14881
14882   if (!PyTuple_Check(args)) SWIG_fail;
14883   argc = args ? PyObject_Length(args) : 0;
14884   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
14885     argv[ii] = PyTuple_GET_ITEM(args,ii);
14886   }
14887   if (argc == 2) {
14888     int _v;
14889     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14890     _v = SWIG_CheckState(res);
14891     if (_v) {
14892       {
14893         _v = PySlice_Check(argv[1]);
14894       }
14895       if (_v) {
14896         return _wrap_VectorShapes___delitem____SWIG_1(self, args);
14897       }
14898     }
14899   }
14900   if (argc == 2) {
14901     int _v;
14902     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14903     _v = SWIG_CheckState(res);
14904     if (_v) {
14905       {
14906         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
14907         _v = SWIG_CheckState(res);
14908       }
14909       if (_v) {
14910         return _wrap_VectorShapes___delitem____SWIG_0(self, args);
14911       }
14912     }
14913   }
14914
14915 fail:
14916   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes___delitem__'.\n"
14917     "  Possible C/C++ prototypes are:\n"
14918     "    std::vector< Hex::NewShape * >::__delitem__(std::vector< Hex::NewShape * >::difference_type)\n"
14919     "    std::vector< Hex::NewShape * >::__delitem__(PySliceObject *)\n");
14920   return 0;
14921 }
14922
14923
14924 SWIGINTERN PyObject *_wrap_VectorShapes___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14925   PyObject *resultobj = 0;
14926   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
14927   std::vector< Hex::NewShape * >::difference_type arg2 ;
14928   void *argp1 = 0 ;
14929   int res1 = 0 ;
14930   ptrdiff_t val2 ;
14931   int ecode2 = 0 ;
14932   PyObject * obj0 = 0 ;
14933   PyObject * obj1 = 0 ;
14934   std::vector< Hex::NewShape * >::value_type result;
14935
14936   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes___getitem__",&obj0,&obj1)) SWIG_fail;
14937   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
14938   if (!SWIG_IsOK(res1)) {
14939     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___getitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
14940   }
14941   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
14942   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
14943   if (!SWIG_IsOK(ecode2)) {
14944     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___getitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
14945   }
14946   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
14947   try {
14948     result = (std::vector< Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg____getitem____SWIG_1(arg1,arg2);
14949   }
14950   catch(std::out_of_range &_e) {
14951     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
14952   }
14953
14954   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 |  0 );
14955   return resultobj;
14956 fail:
14957   return NULL;
14958 }
14959
14960
14961 SWIGINTERN PyObject *_wrap_VectorShapes___getitem__(PyObject *self, PyObject *args) {
14962   Py_ssize_t argc;
14963   PyObject *argv[3] = {
14964     0
14965   };
14966   Py_ssize_t ii;
14967
14968   if (!PyTuple_Check(args)) SWIG_fail;
14969   argc = args ? PyObject_Length(args) : 0;
14970   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
14971     argv[ii] = PyTuple_GET_ITEM(args,ii);
14972   }
14973   if (argc == 2) {
14974     int _v;
14975     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14976     _v = SWIG_CheckState(res);
14977     if (_v) {
14978       {
14979         _v = PySlice_Check(argv[1]);
14980       }
14981       if (_v) {
14982         return _wrap_VectorShapes___getitem____SWIG_0(self, args);
14983       }
14984     }
14985   }
14986   if (argc == 2) {
14987     int _v;
14988     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
14989     _v = SWIG_CheckState(res);
14990     if (_v) {
14991       {
14992         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
14993         _v = SWIG_CheckState(res);
14994       }
14995       if (_v) {
14996         return _wrap_VectorShapes___getitem____SWIG_1(self, args);
14997       }
14998     }
14999   }
15000
15001 fail:
15002   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes___getitem__'.\n"
15003     "  Possible C/C++ prototypes are:\n"
15004     "    std::vector< Hex::NewShape * >::__getitem__(PySliceObject *)\n"
15005     "    std::vector< Hex::NewShape * >::__getitem__(std::vector< Hex::NewShape * >::difference_type)\n");
15006   return 0;
15007 }
15008
15009
15010 SWIGINTERN PyObject *_wrap_VectorShapes___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15011   PyObject *resultobj = 0;
15012   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15013   std::vector< Hex::NewShape * >::difference_type arg2 ;
15014   std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15015   void *argp1 = 0 ;
15016   int res1 = 0 ;
15017   ptrdiff_t val2 ;
15018   int ecode2 = 0 ;
15019   void *argp3 = 0 ;
15020   int res3 = 0 ;
15021   PyObject * obj0 = 0 ;
15022   PyObject * obj1 = 0 ;
15023   PyObject * obj2 = 0 ;
15024
15025   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
15026   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15027   if (!SWIG_IsOK(res1)) {
15028     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes___setitem__" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15029   }
15030   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15031   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
15032   if (!SWIG_IsOK(ecode2)) {
15033     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes___setitem__" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::difference_type""'");
15034   }
15035   arg2 = static_cast< std::vector< Hex::NewShape * >::difference_type >(val2);
15036   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
15037   if (!SWIG_IsOK(res3)) {
15038     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes___setitem__" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15039   }
15040   arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
15041   try {
15042     std_vector_Sl_Hex_NewShape_Sm__Sg____setitem____SWIG_2(arg1,arg2,arg3);
15043   }
15044   catch(std::out_of_range &_e) {
15045     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15046   }
15047
15048   resultobj = SWIG_Py_Void();
15049   return resultobj;
15050 fail:
15051   return NULL;
15052 }
15053
15054
15055 SWIGINTERN PyObject *_wrap_VectorShapes___setitem__(PyObject *self, PyObject *args) {
15056   Py_ssize_t argc;
15057   PyObject *argv[4] = {
15058     0
15059   };
15060   Py_ssize_t ii;
15061
15062   if (!PyTuple_Check(args)) SWIG_fail;
15063   argc = args ? PyObject_Length(args) : 0;
15064   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
15065     argv[ii] = PyTuple_GET_ITEM(args,ii);
15066   }
15067   if (argc == 2) {
15068     int _v;
15069     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15070     _v = SWIG_CheckState(res);
15071     if (_v) {
15072       {
15073         _v = PySlice_Check(argv[1]);
15074       }
15075       if (_v) {
15076         return _wrap_VectorShapes___setitem____SWIG_1(self, args);
15077       }
15078     }
15079   }
15080   if (argc == 3) {
15081     int _v;
15082     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15083     _v = SWIG_CheckState(res);
15084     if (_v) {
15085       {
15086         _v = PySlice_Check(argv[1]);
15087       }
15088       if (_v) {
15089         int res = swig::asptr(argv[2], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15090         _v = SWIG_CheckState(res);
15091         if (_v) {
15092           return _wrap_VectorShapes___setitem____SWIG_0(self, args);
15093         }
15094       }
15095     }
15096   }
15097   if (argc == 3) {
15098     int _v;
15099     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15100     _v = SWIG_CheckState(res);
15101     if (_v) {
15102       {
15103         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
15104         _v = SWIG_CheckState(res);
15105       }
15106       if (_v) {
15107         void *vptr = 0;
15108         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__NewShape, 0);
15109         _v = SWIG_CheckState(res);
15110         if (_v) {
15111           return _wrap_VectorShapes___setitem____SWIG_2(self, args);
15112         }
15113       }
15114     }
15115   }
15116
15117 fail:
15118   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes___setitem__'.\n"
15119     "  Possible C/C++ prototypes are:\n"
15120     "    std::vector< Hex::NewShape * >::__setitem__(PySliceObject *,std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > const &)\n"
15121     "    std::vector< Hex::NewShape * >::__setitem__(PySliceObject *)\n"
15122     "    std::vector< Hex::NewShape * >::__setitem__(std::vector< Hex::NewShape * >::difference_type,std::vector< Hex::NewShape * >::value_type)\n");
15123   return 0;
15124 }
15125
15126
15127 SWIGINTERN PyObject *_wrap_VectorShapes_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15128   PyObject *resultobj = 0;
15129   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15130   void *argp1 = 0 ;
15131   int res1 = 0 ;
15132   PyObject * obj0 = 0 ;
15133   std::vector< Hex::NewShape * >::value_type result;
15134
15135   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop",&obj0)) SWIG_fail;
15136   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15137   if (!SWIG_IsOK(res1)) {
15138     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15139   }
15140   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15141   try {
15142     result = (std::vector< Hex::NewShape * >::value_type)std_vector_Sl_Hex_NewShape_Sm__Sg__pop(arg1);
15143   }
15144   catch(std::out_of_range &_e) {
15145     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
15146   }
15147
15148   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 |  0 );
15149   return resultobj;
15150 fail:
15151   return NULL;
15152 }
15153
15154
15155 SWIGINTERN PyObject *_wrap_VectorShapes_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15156   PyObject *resultobj = 0;
15157   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15158   std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15159   void *argp1 = 0 ;
15160   int res1 = 0 ;
15161   void *argp2 = 0 ;
15162   int res2 = 0 ;
15163   PyObject * obj0 = 0 ;
15164   PyObject * obj1 = 0 ;
15165
15166   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_append",&obj0,&obj1)) SWIG_fail;
15167   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15168   if (!SWIG_IsOK(res1)) {
15169     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_append" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15170   }
15171   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15172   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
15173   if (!SWIG_IsOK(res2)) {
15174     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_append" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15175   }
15176   arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
15177   std_vector_Sl_Hex_NewShape_Sm__Sg__append(arg1,arg2);
15178   resultobj = SWIG_Py_Void();
15179   return resultobj;
15180 fail:
15181   return NULL;
15182 }
15183
15184
15185 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15186   PyObject *resultobj = 0;
15187   std::vector< Hex::NewShape * > *result = 0 ;
15188
15189   if (!PyArg_ParseTuple(args,(char *)":new_VectorShapes")) SWIG_fail;
15190   result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >();
15191   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
15192   return resultobj;
15193 fail:
15194   return NULL;
15195 }
15196
15197
15198 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15199   PyObject *resultobj = 0;
15200   std::vector< Hex::NewShape * > *arg1 = 0 ;
15201   int res1 = SWIG_OLDOBJ ;
15202   PyObject * obj0 = 0 ;
15203   std::vector< Hex::NewShape * > *result = 0 ;
15204
15205   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
15206   {
15207     std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
15208     res1 = swig::asptr(obj0, &ptr);
15209     if (!SWIG_IsOK(res1)) {
15210       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const &""'");
15211     }
15212     if (!ptr) {
15213       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const &""'");
15214     }
15215     arg1 = ptr;
15216   }
15217   result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >((std::vector< Hex::NewShape * > const &)*arg1);
15218   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
15219   if (SWIG_IsNewObj(res1)) delete arg1;
15220   return resultobj;
15221 fail:
15222   if (SWIG_IsNewObj(res1)) delete arg1;
15223   return NULL;
15224 }
15225
15226
15227 SWIGINTERN PyObject *_wrap_VectorShapes_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15228   PyObject *resultobj = 0;
15229   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15230   void *argp1 = 0 ;
15231   int res1 = 0 ;
15232   PyObject * obj0 = 0 ;
15233   bool result;
15234
15235   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_empty",&obj0)) SWIG_fail;
15236   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15237   if (!SWIG_IsOK(res1)) {
15238     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_empty" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
15239   }
15240   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15241   result = (bool)((std::vector< Hex::NewShape * > const *)arg1)->empty();
15242   resultobj = SWIG_From_bool(static_cast< bool >(result));
15243   return resultobj;
15244 fail:
15245   return NULL;
15246 }
15247
15248
15249 SWIGINTERN PyObject *_wrap_VectorShapes_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15250   PyObject *resultobj = 0;
15251   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15252   void *argp1 = 0 ;
15253   int res1 = 0 ;
15254   PyObject * obj0 = 0 ;
15255   std::vector< Hex::NewShape * >::size_type result;
15256
15257   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_size",&obj0)) SWIG_fail;
15258   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15259   if (!SWIG_IsOK(res1)) {
15260     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_size" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
15261   }
15262   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15263   result = ((std::vector< Hex::NewShape * > const *)arg1)->size();
15264   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
15265   return resultobj;
15266 fail:
15267   return NULL;
15268 }
15269
15270
15271 SWIGINTERN PyObject *_wrap_VectorShapes_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15272   PyObject *resultobj = 0;
15273   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15274   std::vector< Hex::NewShape * > *arg2 = 0 ;
15275   void *argp1 = 0 ;
15276   int res1 = 0 ;
15277   void *argp2 = 0 ;
15278   int res2 = 0 ;
15279   PyObject * obj0 = 0 ;
15280   PyObject * obj1 = 0 ;
15281
15282   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_swap",&obj0,&obj1)) SWIG_fail;
15283   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15284   if (!SWIG_IsOK(res1)) {
15285     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_swap" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15286   }
15287   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15288   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t,  0 );
15289   if (!SWIG_IsOK(res2)) {
15290     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector< Hex::NewShape * > &""'");
15291   }
15292   if (!argp2) {
15293     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorShapes_swap" "', argument " "2"" of type '" "std::vector< Hex::NewShape * > &""'");
15294   }
15295   arg2 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp2);
15296   (arg1)->swap(*arg2);
15297   resultobj = SWIG_Py_Void();
15298   return resultobj;
15299 fail:
15300   return NULL;
15301 }
15302
15303
15304 SWIGINTERN PyObject *_wrap_VectorShapes_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15305   PyObject *resultobj = 0;
15306   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15307   void *argp1 = 0 ;
15308   int res1 = 0 ;
15309   PyObject * obj0 = 0 ;
15310   std::vector< Hex::NewShape * >::iterator result;
15311
15312   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_begin",&obj0)) SWIG_fail;
15313   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15314   if (!SWIG_IsOK(res1)) {
15315     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_begin" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15316   }
15317   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15318   result = (arg1)->begin();
15319   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
15320     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15321   return resultobj;
15322 fail:
15323   return NULL;
15324 }
15325
15326
15327 SWIGINTERN PyObject *_wrap_VectorShapes_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15328   PyObject *resultobj = 0;
15329   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15330   void *argp1 = 0 ;
15331   int res1 = 0 ;
15332   PyObject * obj0 = 0 ;
15333   std::vector< Hex::NewShape * >::iterator result;
15334
15335   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_end",&obj0)) SWIG_fail;
15336   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15337   if (!SWIG_IsOK(res1)) {
15338     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_end" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15339   }
15340   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15341   result = (arg1)->end();
15342   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
15343     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15344   return resultobj;
15345 fail:
15346   return NULL;
15347 }
15348
15349
15350 SWIGINTERN PyObject *_wrap_VectorShapes_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15351   PyObject *resultobj = 0;
15352   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15353   void *argp1 = 0 ;
15354   int res1 = 0 ;
15355   PyObject * obj0 = 0 ;
15356   std::vector< Hex::NewShape * >::reverse_iterator result;
15357
15358   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rbegin",&obj0)) SWIG_fail;
15359   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15360   if (!SWIG_IsOK(res1)) {
15361     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rbegin" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15362   }
15363   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15364   result = (arg1)->rbegin();
15365   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::reverse_iterator & >(result)),
15366     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15367   return resultobj;
15368 fail:
15369   return NULL;
15370 }
15371
15372
15373 SWIGINTERN PyObject *_wrap_VectorShapes_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15374   PyObject *resultobj = 0;
15375   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15376   void *argp1 = 0 ;
15377   int res1 = 0 ;
15378   PyObject * obj0 = 0 ;
15379   std::vector< Hex::NewShape * >::reverse_iterator result;
15380
15381   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_rend",&obj0)) SWIG_fail;
15382   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15383   if (!SWIG_IsOK(res1)) {
15384     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_rend" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15385   }
15386   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15387   result = (arg1)->rend();
15388   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::reverse_iterator & >(result)),
15389     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15390   return resultobj;
15391 fail:
15392   return NULL;
15393 }
15394
15395
15396 SWIGINTERN PyObject *_wrap_VectorShapes_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15397   PyObject *resultobj = 0;
15398   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15399   void *argp1 = 0 ;
15400   int res1 = 0 ;
15401   PyObject * obj0 = 0 ;
15402
15403   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_clear",&obj0)) SWIG_fail;
15404   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15405   if (!SWIG_IsOK(res1)) {
15406     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_clear" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15407   }
15408   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15409   (arg1)->clear();
15410   resultobj = SWIG_Py_Void();
15411   return resultobj;
15412 fail:
15413   return NULL;
15414 }
15415
15416
15417 SWIGINTERN PyObject *_wrap_VectorShapes_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15418   PyObject *resultobj = 0;
15419   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15420   void *argp1 = 0 ;
15421   int res1 = 0 ;
15422   PyObject * obj0 = 0 ;
15423   SwigValueWrapper< std::allocator< Hex::NewShape * > > result;
15424
15425   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_get_allocator",&obj0)) SWIG_fail;
15426   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15427   if (!SWIG_IsOK(res1)) {
15428     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_get_allocator" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
15429   }
15430   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15431   result = ((std::vector< Hex::NewShape * > const *)arg1)->get_allocator();
15432   resultobj = SWIG_NewPointerObj((new std::vector< Hex::NewShape * >::allocator_type(static_cast< const std::vector< Hex::NewShape * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Hex__NewShape_p_t, SWIG_POINTER_OWN |  0 );
15433   return resultobj;
15434 fail:
15435   return NULL;
15436 }
15437
15438
15439 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15440   PyObject *resultobj = 0;
15441   std::vector< Hex::NewShape * >::size_type arg1 ;
15442   size_t val1 ;
15443   int ecode1 = 0 ;
15444   PyObject * obj0 = 0 ;
15445   std::vector< Hex::NewShape * > *result = 0 ;
15446
15447   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorShapes",&obj0)) SWIG_fail;
15448   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
15449   if (!SWIG_IsOK(ecode1)) {
15450     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
15451   }
15452   arg1 = static_cast< std::vector< Hex::NewShape * >::size_type >(val1);
15453   result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >(arg1);
15454   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
15455   return resultobj;
15456 fail:
15457   return NULL;
15458 }
15459
15460
15461 SWIGINTERN PyObject *_wrap_VectorShapes_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15462   PyObject *resultobj = 0;
15463   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15464   void *argp1 = 0 ;
15465   int res1 = 0 ;
15466   PyObject * obj0 = 0 ;
15467
15468   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_pop_back",&obj0)) SWIG_fail;
15469   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15470   if (!SWIG_IsOK(res1)) {
15471     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_pop_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15472   }
15473   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15474   (arg1)->pop_back();
15475   resultobj = SWIG_Py_Void();
15476   return resultobj;
15477 fail:
15478   return NULL;
15479 }
15480
15481
15482 SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15483   PyObject *resultobj = 0;
15484   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15485   std::vector< Hex::NewShape * >::size_type arg2 ;
15486   void *argp1 = 0 ;
15487   int res1 = 0 ;
15488   size_t val2 ;
15489   int ecode2 = 0 ;
15490   PyObject * obj0 = 0 ;
15491   PyObject * obj1 = 0 ;
15492
15493   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_resize",&obj0,&obj1)) SWIG_fail;
15494   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15495   if (!SWIG_IsOK(res1)) {
15496     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15497   }
15498   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15499   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15500   if (!SWIG_IsOK(ecode2)) {
15501     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
15502   }
15503   arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
15504   (arg1)->resize(arg2);
15505   resultobj = SWIG_Py_Void();
15506   return resultobj;
15507 fail:
15508   return NULL;
15509 }
15510
15511
15512 SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15513   PyObject *resultobj = 0;
15514   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15515   std::vector< Hex::NewShape * >::iterator arg2 ;
15516   void *argp1 = 0 ;
15517   int res1 = 0 ;
15518   swig::SwigPyIterator *iter2 = 0 ;
15519   int res2 ;
15520   PyObject * obj0 = 0 ;
15521   PyObject * obj1 = 0 ;
15522   std::vector< Hex::NewShape * >::iterator result;
15523
15524   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_erase",&obj0,&obj1)) SWIG_fail;
15525   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15526   if (!SWIG_IsOK(res1)) {
15527     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15528   }
15529   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15530   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
15531   if (!SWIG_IsOK(res2) || !iter2) {
15532     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15533   } else {
15534     swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
15535     if (iter_t) {
15536       arg2 = iter_t->get_current();
15537     } else {
15538       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15539     }
15540   }
15541   result = std_vector_Sl_Hex_NewShape_Sm__Sg__erase__SWIG_0(arg1,arg2);
15542   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
15543     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15544   return resultobj;
15545 fail:
15546   return NULL;
15547 }
15548
15549
15550 SWIGINTERN PyObject *_wrap_VectorShapes_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15551   PyObject *resultobj = 0;
15552   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15553   std::vector< Hex::NewShape * >::iterator arg2 ;
15554   std::vector< Hex::NewShape * >::iterator arg3 ;
15555   void *argp1 = 0 ;
15556   int res1 = 0 ;
15557   swig::SwigPyIterator *iter2 = 0 ;
15558   int res2 ;
15559   swig::SwigPyIterator *iter3 = 0 ;
15560   int res3 ;
15561   PyObject * obj0 = 0 ;
15562   PyObject * obj1 = 0 ;
15563   PyObject * obj2 = 0 ;
15564   std::vector< Hex::NewShape * >::iterator result;
15565
15566   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_erase",&obj0,&obj1,&obj2)) SWIG_fail;
15567   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15568   if (!SWIG_IsOK(res1)) {
15569     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_erase" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15570   }
15571   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15572   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
15573   if (!SWIG_IsOK(res2) || !iter2) {
15574     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15575   } else {
15576     swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
15577     if (iter_t) {
15578       arg2 = iter_t->get_current();
15579     } else {
15580       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15581     }
15582   }
15583   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
15584   if (!SWIG_IsOK(res3) || !iter3) {
15585     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15586   } else {
15587     swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter3);
15588     if (iter_t) {
15589       arg3 = iter_t->get_current();
15590     } else {
15591       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_erase" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15592     }
15593   }
15594   result = std_vector_Sl_Hex_NewShape_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
15595   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
15596     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15597   return resultobj;
15598 fail:
15599   return NULL;
15600 }
15601
15602
15603 SWIGINTERN PyObject *_wrap_VectorShapes_erase(PyObject *self, PyObject *args) {
15604   Py_ssize_t argc;
15605   PyObject *argv[4] = {
15606     0
15607   };
15608   Py_ssize_t ii;
15609
15610   if (!PyTuple_Check(args)) SWIG_fail;
15611   argc = args ? PyObject_Length(args) : 0;
15612   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
15613     argv[ii] = PyTuple_GET_ITEM(args,ii);
15614   }
15615   if (argc == 2) {
15616     int _v;
15617     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15618     _v = SWIG_CheckState(res);
15619     if (_v) {
15620       swig::SwigPyIterator *iter = 0;
15621       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
15622       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
15623       if (_v) {
15624         return _wrap_VectorShapes_erase__SWIG_0(self, args);
15625       }
15626     }
15627   }
15628   if (argc == 3) {
15629     int _v;
15630     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15631     _v = SWIG_CheckState(res);
15632     if (_v) {
15633       swig::SwigPyIterator *iter = 0;
15634       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
15635       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
15636       if (_v) {
15637         swig::SwigPyIterator *iter = 0;
15638         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
15639         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
15640         if (_v) {
15641           return _wrap_VectorShapes_erase__SWIG_1(self, args);
15642         }
15643       }
15644     }
15645   }
15646
15647 fail:
15648   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes_erase'.\n"
15649     "  Possible C/C++ prototypes are:\n"
15650     "    std::vector< Hex::NewShape * >::erase(std::vector< Hex::NewShape * >::iterator)\n"
15651     "    std::vector< Hex::NewShape * >::erase(std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::iterator)\n");
15652   return 0;
15653 }
15654
15655
15656 SWIGINTERN PyObject *_wrap_new_VectorShapes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15657   PyObject *resultobj = 0;
15658   std::vector< Hex::NewShape * >::size_type arg1 ;
15659   std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15660   size_t val1 ;
15661   int ecode1 = 0 ;
15662   void *argp2 = 0 ;
15663   int res2 = 0 ;
15664   PyObject * obj0 = 0 ;
15665   PyObject * obj1 = 0 ;
15666   std::vector< Hex::NewShape * > *result = 0 ;
15667
15668   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorShapes",&obj0,&obj1)) SWIG_fail;
15669   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
15670   if (!SWIG_IsOK(ecode1)) {
15671     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
15672   }
15673   arg1 = static_cast< std::vector< Hex::NewShape * >::size_type >(val1);
15674   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
15675   if (!SWIG_IsOK(res2)) {
15676     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorShapes" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15677   }
15678   arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
15679   result = (std::vector< Hex::NewShape * > *)new std::vector< Hex::NewShape * >(arg1,arg2);
15680   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_NEW |  0 );
15681   return resultobj;
15682 fail:
15683   return NULL;
15684 }
15685
15686
15687 SWIGINTERN PyObject *_wrap_new_VectorShapes(PyObject *self, PyObject *args) {
15688   Py_ssize_t argc;
15689   PyObject *argv[3] = {
15690     0
15691   };
15692   Py_ssize_t ii;
15693
15694   if (!PyTuple_Check(args)) SWIG_fail;
15695   argc = args ? PyObject_Length(args) : 0;
15696   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
15697     argv[ii] = PyTuple_GET_ITEM(args,ii);
15698   }
15699   if (argc == 0) {
15700     return _wrap_new_VectorShapes__SWIG_0(self, args);
15701   }
15702   if (argc == 1) {
15703     int _v;
15704     {
15705       int res = SWIG_AsVal_size_t(argv[0], NULL);
15706       _v = SWIG_CheckState(res);
15707     }
15708     if (_v) {
15709       return _wrap_new_VectorShapes__SWIG_2(self, args);
15710     }
15711   }
15712   if (argc == 1) {
15713     int _v;
15714     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15715     _v = SWIG_CheckState(res);
15716     if (_v) {
15717       return _wrap_new_VectorShapes__SWIG_1(self, args);
15718     }
15719   }
15720   if (argc == 2) {
15721     int _v;
15722     {
15723       int res = SWIG_AsVal_size_t(argv[0], NULL);
15724       _v = SWIG_CheckState(res);
15725     }
15726     if (_v) {
15727       void *vptr = 0;
15728       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__NewShape, 0);
15729       _v = SWIG_CheckState(res);
15730       if (_v) {
15731         return _wrap_new_VectorShapes__SWIG_3(self, args);
15732       }
15733     }
15734   }
15735
15736 fail:
15737   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorShapes'.\n"
15738     "  Possible C/C++ prototypes are:\n"
15739     "    std::vector< Hex::NewShape * >::vector()\n"
15740     "    std::vector< Hex::NewShape * >::vector(std::vector< Hex::NewShape * > const &)\n"
15741     "    std::vector< Hex::NewShape * >::vector(std::vector< Hex::NewShape * >::size_type)\n"
15742     "    std::vector< Hex::NewShape * >::vector(std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
15743   return 0;
15744 }
15745
15746
15747 SWIGINTERN PyObject *_wrap_VectorShapes_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15748   PyObject *resultobj = 0;
15749   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15750   std::vector< Hex::NewShape * >::value_type arg2 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15751   void *argp1 = 0 ;
15752   int res1 = 0 ;
15753   void *argp2 = 0 ;
15754   int res2 = 0 ;
15755   PyObject * obj0 = 0 ;
15756   PyObject * obj1 = 0 ;
15757
15758   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_push_back",&obj0,&obj1)) SWIG_fail;
15759   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15760   if (!SWIG_IsOK(res1)) {
15761     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_push_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15762   }
15763   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15764   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
15765   if (!SWIG_IsOK(res2)) {
15766     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorShapes_push_back" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15767   }
15768   arg2 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp2);
15769   (arg1)->push_back(arg2);
15770   resultobj = SWIG_Py_Void();
15771   return resultobj;
15772 fail:
15773   return NULL;
15774 }
15775
15776
15777 SWIGINTERN PyObject *_wrap_VectorShapes_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15778   PyObject *resultobj = 0;
15779   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15780   void *argp1 = 0 ;
15781   int res1 = 0 ;
15782   PyObject * obj0 = 0 ;
15783   std::vector< Hex::NewShape * >::value_type result;
15784
15785   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_front",&obj0)) SWIG_fail;
15786   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15787   if (!SWIG_IsOK(res1)) {
15788     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_front" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
15789   }
15790   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15791   result = (std::vector< Hex::NewShape * >::value_type)((std::vector< Hex::NewShape * > const *)arg1)->front();
15792   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 |  0 );
15793   return resultobj;
15794 fail:
15795   return NULL;
15796 }
15797
15798
15799 SWIGINTERN PyObject *_wrap_VectorShapes_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15800   PyObject *resultobj = 0;
15801   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15802   void *argp1 = 0 ;
15803   int res1 = 0 ;
15804   PyObject * obj0 = 0 ;
15805   std::vector< Hex::NewShape * >::value_type result;
15806
15807   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_back",&obj0)) SWIG_fail;
15808   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15809   if (!SWIG_IsOK(res1)) {
15810     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_back" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
15811   }
15812   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15813   result = (std::vector< Hex::NewShape * >::value_type)((std::vector< Hex::NewShape * > const *)arg1)->back();
15814   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 |  0 );
15815   return resultobj;
15816 fail:
15817   return NULL;
15818 }
15819
15820
15821 SWIGINTERN PyObject *_wrap_VectorShapes_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822   PyObject *resultobj = 0;
15823   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15824   std::vector< Hex::NewShape * >::size_type arg2 ;
15825   std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15826   void *argp1 = 0 ;
15827   int res1 = 0 ;
15828   size_t val2 ;
15829   int ecode2 = 0 ;
15830   void *argp3 = 0 ;
15831   int res3 = 0 ;
15832   PyObject * obj0 = 0 ;
15833   PyObject * obj1 = 0 ;
15834   PyObject * obj2 = 0 ;
15835
15836   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_assign",&obj0,&obj1,&obj2)) SWIG_fail;
15837   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15838   if (!SWIG_IsOK(res1)) {
15839     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_assign" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15840   }
15841   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15842   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15843   if (!SWIG_IsOK(ecode2)) {
15844     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_assign" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
15845   }
15846   arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
15847   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
15848   if (!SWIG_IsOK(res3)) {
15849     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_assign" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15850   }
15851   arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
15852   (arg1)->assign(arg2,arg3);
15853   resultobj = SWIG_Py_Void();
15854   return resultobj;
15855 fail:
15856   return NULL;
15857 }
15858
15859
15860 SWIGINTERN PyObject *_wrap_VectorShapes_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15861   PyObject *resultobj = 0;
15862   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15863   std::vector< Hex::NewShape * >::size_type arg2 ;
15864   std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15865   void *argp1 = 0 ;
15866   int res1 = 0 ;
15867   size_t val2 ;
15868   int ecode2 = 0 ;
15869   void *argp3 = 0 ;
15870   int res3 = 0 ;
15871   PyObject * obj0 = 0 ;
15872   PyObject * obj1 = 0 ;
15873   PyObject * obj2 = 0 ;
15874
15875   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_resize",&obj0,&obj1,&obj2)) SWIG_fail;
15876   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15877   if (!SWIG_IsOK(res1)) {
15878     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_resize" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15879   }
15880   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15881   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15882   if (!SWIG_IsOK(ecode2)) {
15883     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_resize" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
15884   }
15885   arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
15886   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
15887   if (!SWIG_IsOK(res3)) {
15888     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_resize" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15889   }
15890   arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
15891   (arg1)->resize(arg2,arg3);
15892   resultobj = SWIG_Py_Void();
15893   return resultobj;
15894 fail:
15895   return NULL;
15896 }
15897
15898
15899 SWIGINTERN PyObject *_wrap_VectorShapes_resize(PyObject *self, PyObject *args) {
15900   Py_ssize_t argc;
15901   PyObject *argv[4] = {
15902     0
15903   };
15904   Py_ssize_t ii;
15905
15906   if (!PyTuple_Check(args)) SWIG_fail;
15907   argc = args ? PyObject_Length(args) : 0;
15908   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
15909     argv[ii] = PyTuple_GET_ITEM(args,ii);
15910   }
15911   if (argc == 2) {
15912     int _v;
15913     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15914     _v = SWIG_CheckState(res);
15915     if (_v) {
15916       {
15917         int res = SWIG_AsVal_size_t(argv[1], NULL);
15918         _v = SWIG_CheckState(res);
15919       }
15920       if (_v) {
15921         return _wrap_VectorShapes_resize__SWIG_0(self, args);
15922       }
15923     }
15924   }
15925   if (argc == 3) {
15926     int _v;
15927     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
15928     _v = SWIG_CheckState(res);
15929     if (_v) {
15930       {
15931         int res = SWIG_AsVal_size_t(argv[1], NULL);
15932         _v = SWIG_CheckState(res);
15933       }
15934       if (_v) {
15935         void *vptr = 0;
15936         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__NewShape, 0);
15937         _v = SWIG_CheckState(res);
15938         if (_v) {
15939           return _wrap_VectorShapes_resize__SWIG_1(self, args);
15940         }
15941       }
15942     }
15943   }
15944
15945 fail:
15946   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes_resize'.\n"
15947     "  Possible C/C++ prototypes are:\n"
15948     "    std::vector< Hex::NewShape * >::resize(std::vector< Hex::NewShape * >::size_type)\n"
15949     "    std::vector< Hex::NewShape * >::resize(std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
15950   return 0;
15951 }
15952
15953
15954 SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15955   PyObject *resultobj = 0;
15956   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
15957   std::vector< Hex::NewShape * >::iterator arg2 ;
15958   std::vector< Hex::NewShape * >::value_type arg3 = (std::vector< Hex::NewShape * >::value_type) 0 ;
15959   void *argp1 = 0 ;
15960   int res1 = 0 ;
15961   swig::SwigPyIterator *iter2 = 0 ;
15962   int res2 ;
15963   void *argp3 = 0 ;
15964   int res3 = 0 ;
15965   PyObject * obj0 = 0 ;
15966   PyObject * obj1 = 0 ;
15967   PyObject * obj2 = 0 ;
15968   std::vector< Hex::NewShape * >::iterator result;
15969
15970   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorShapes_insert",&obj0,&obj1,&obj2)) SWIG_fail;
15971   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
15972   if (!SWIG_IsOK(res1)) {
15973     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
15974   }
15975   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
15976   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
15977   if (!SWIG_IsOK(res2) || !iter2) {
15978     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15979   } else {
15980     swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
15981     if (iter_t) {
15982       arg2 = iter_t->get_current();
15983     } else {
15984       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
15985     }
15986   }
15987   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
15988   if (!SWIG_IsOK(res3)) {
15989     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
15990   }
15991   arg3 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp3);
15992   result = std_vector_Sl_Hex_NewShape_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
15993   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< Hex::NewShape * >::iterator & >(result)),
15994     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
15995   return resultobj;
15996 fail:
15997   return NULL;
15998 }
15999
16000
16001 SWIGINTERN PyObject *_wrap_VectorShapes_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16002   PyObject *resultobj = 0;
16003   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
16004   std::vector< Hex::NewShape * >::iterator arg2 ;
16005   std::vector< Hex::NewShape * >::size_type arg3 ;
16006   std::vector< Hex::NewShape * >::value_type arg4 = (std::vector< Hex::NewShape * >::value_type) 0 ;
16007   void *argp1 = 0 ;
16008   int res1 = 0 ;
16009   swig::SwigPyIterator *iter2 = 0 ;
16010   int res2 ;
16011   size_t val3 ;
16012   int ecode3 = 0 ;
16013   void *argp4 = 0 ;
16014   int res4 = 0 ;
16015   PyObject * obj0 = 0 ;
16016   PyObject * obj1 = 0 ;
16017   PyObject * obj2 = 0 ;
16018   PyObject * obj3 = 0 ;
16019
16020   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorShapes_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16021   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
16022   if (!SWIG_IsOK(res1)) {
16023     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_insert" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
16024   }
16025   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
16026   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
16027   if (!SWIG_IsOK(res2) || !iter2) {
16028     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
16029   } else {
16030     swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter2);
16031     if (iter_t) {
16032       arg2 = iter_t->get_current();
16033     } else {
16034       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorShapes_insert" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::iterator""'");
16035     }
16036   }
16037   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16038   if (!SWIG_IsOK(ecode3)) {
16039     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorShapes_insert" "', argument " "3"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
16040   }
16041   arg3 = static_cast< std::vector< Hex::NewShape * >::size_type >(val3);
16042   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
16043   if (!SWIG_IsOK(res4)) {
16044     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorShapes_insert" "', argument " "4"" of type '" "std::vector< Hex::NewShape * >::value_type""'");
16045   }
16046   arg4 = reinterpret_cast< std::vector< Hex::NewShape * >::value_type >(argp4);
16047   std_vector_Sl_Hex_NewShape_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
16048   resultobj = SWIG_Py_Void();
16049   return resultobj;
16050 fail:
16051   return NULL;
16052 }
16053
16054
16055 SWIGINTERN PyObject *_wrap_VectorShapes_insert(PyObject *self, PyObject *args) {
16056   Py_ssize_t argc;
16057   PyObject *argv[5] = {
16058     0
16059   };
16060   Py_ssize_t ii;
16061
16062   if (!PyTuple_Check(args)) SWIG_fail;
16063   argc = args ? PyObject_Length(args) : 0;
16064   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
16065     argv[ii] = PyTuple_GET_ITEM(args,ii);
16066   }
16067   if (argc == 3) {
16068     int _v;
16069     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
16070     _v = SWIG_CheckState(res);
16071     if (_v) {
16072       swig::SwigPyIterator *iter = 0;
16073       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
16074       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
16075       if (_v) {
16076         void *vptr = 0;
16077         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__NewShape, 0);
16078         _v = SWIG_CheckState(res);
16079         if (_v) {
16080           return _wrap_VectorShapes_insert__SWIG_0(self, args);
16081         }
16082       }
16083     }
16084   }
16085   if (argc == 4) {
16086     int _v;
16087     int res = swig::asptr(argv[0], (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > >**)(0));
16088     _v = SWIG_CheckState(res);
16089     if (_v) {
16090       swig::SwigPyIterator *iter = 0;
16091       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
16092       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< Hex::NewShape * >::iterator > *>(iter) != 0));
16093       if (_v) {
16094         {
16095           int res = SWIG_AsVal_size_t(argv[2], NULL);
16096           _v = SWIG_CheckState(res);
16097         }
16098         if (_v) {
16099           void *vptr = 0;
16100           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__NewShape, 0);
16101           _v = SWIG_CheckState(res);
16102           if (_v) {
16103             return _wrap_VectorShapes_insert__SWIG_1(self, args);
16104           }
16105         }
16106       }
16107     }
16108   }
16109
16110 fail:
16111   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorShapes_insert'.\n"
16112     "  Possible C/C++ prototypes are:\n"
16113     "    std::vector< Hex::NewShape * >::insert(std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::value_type)\n"
16114     "    std::vector< Hex::NewShape * >::insert(std::vector< Hex::NewShape * >::iterator,std::vector< Hex::NewShape * >::size_type,std::vector< Hex::NewShape * >::value_type)\n");
16115   return 0;
16116 }
16117
16118
16119 SWIGINTERN PyObject *_wrap_VectorShapes_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16120   PyObject *resultobj = 0;
16121   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
16122   std::vector< Hex::NewShape * >::size_type arg2 ;
16123   void *argp1 = 0 ;
16124   int res1 = 0 ;
16125   size_t val2 ;
16126   int ecode2 = 0 ;
16127   PyObject * obj0 = 0 ;
16128   PyObject * obj1 = 0 ;
16129
16130   if (!PyArg_ParseTuple(args,(char *)"OO:VectorShapes_reserve",&obj0,&obj1)) SWIG_fail;
16131   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
16132   if (!SWIG_IsOK(res1)) {
16133     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_reserve" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
16134   }
16135   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
16136   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16137   if (!SWIG_IsOK(ecode2)) {
16138     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorShapes_reserve" "', argument " "2"" of type '" "std::vector< Hex::NewShape * >::size_type""'");
16139   }
16140   arg2 = static_cast< std::vector< Hex::NewShape * >::size_type >(val2);
16141   (arg1)->reserve(arg2);
16142   resultobj = SWIG_Py_Void();
16143   return resultobj;
16144 fail:
16145   return NULL;
16146 }
16147
16148
16149 SWIGINTERN PyObject *_wrap_VectorShapes_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16150   PyObject *resultobj = 0;
16151   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
16152   void *argp1 = 0 ;
16153   int res1 = 0 ;
16154   PyObject * obj0 = 0 ;
16155   std::vector< Hex::NewShape * >::size_type result;
16156
16157   if (!PyArg_ParseTuple(args,(char *)"O:VectorShapes_capacity",&obj0)) SWIG_fail;
16158   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0 |  0 );
16159   if (!SWIG_IsOK(res1)) {
16160     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorShapes_capacity" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > const *""'");
16161   }
16162   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
16163   result = ((std::vector< Hex::NewShape * > const *)arg1)->capacity();
16164   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16165   return resultobj;
16166 fail:
16167   return NULL;
16168 }
16169
16170
16171 SWIGINTERN PyObject *_wrap_delete_VectorShapes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16172   PyObject *resultobj = 0;
16173   std::vector< Hex::NewShape * > *arg1 = (std::vector< Hex::NewShape * > *) 0 ;
16174   void *argp1 = 0 ;
16175   int res1 = 0 ;
16176   PyObject * obj0 = 0 ;
16177
16178   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorShapes",&obj0)) SWIG_fail;
16179   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_POINTER_DISOWN |  0 );
16180   if (!SWIG_IsOK(res1)) {
16181     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorShapes" "', argument " "1"" of type '" "std::vector< Hex::NewShape * > *""'");
16182   }
16183   arg1 = reinterpret_cast< std::vector< Hex::NewShape * > * >(argp1);
16184   delete arg1;
16185   resultobj = SWIG_Py_Void();
16186   return resultobj;
16187 fail:
16188   return NULL;
16189 }
16190
16191
16192 SWIGINTERN PyObject *VectorShapes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16193   PyObject *obj;
16194   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
16195   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, SWIG_NewClientData(obj));
16196   return SWIG_Py_Void();
16197 }
16198
16199 SWIGINTERN PyObject *_wrap_VectorReal_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16200   PyObject *resultobj = 0;
16201   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16202   PyObject **arg2 = (PyObject **) 0 ;
16203   void *argp1 = 0 ;
16204   int res1 = 0 ;
16205   PyObject * obj0 = 0 ;
16206   swig::SwigPyIterator *result = 0 ;
16207
16208   arg2 = &obj0;
16209   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_iterator",&obj0)) SWIG_fail;
16210   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16211   if (!SWIG_IsOK(res1)) {
16212     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_iterator" "', argument " "1"" of type '" "std::vector< double > *""'");
16213   }
16214   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16215   result = (swig::SwigPyIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
16216   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
16217   return resultobj;
16218 fail:
16219   return NULL;
16220 }
16221
16222
16223 SWIGINTERN PyObject *_wrap_VectorReal___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16224   PyObject *resultobj = 0;
16225   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16226   void *argp1 = 0 ;
16227   int res1 = 0 ;
16228   PyObject * obj0 = 0 ;
16229   bool result;
16230
16231   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___nonzero__",&obj0)) SWIG_fail;
16232   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16233   if (!SWIG_IsOK(res1)) {
16234     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'");
16235   }
16236   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16237   result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
16238   resultobj = SWIG_From_bool(static_cast< bool >(result));
16239   return resultobj;
16240 fail:
16241   return NULL;
16242 }
16243
16244
16245 SWIGINTERN PyObject *_wrap_VectorReal___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16246   PyObject *resultobj = 0;
16247   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16248   void *argp1 = 0 ;
16249   int res1 = 0 ;
16250   PyObject * obj0 = 0 ;
16251   bool result;
16252
16253   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___bool__",&obj0)) SWIG_fail;
16254   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16255   if (!SWIG_IsOK(res1)) {
16256     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___bool__" "', argument " "1"" of type '" "std::vector< double > const *""'");
16257   }
16258   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16259   result = (bool)std_vector_Sl_double_Sg____bool__((std::vector< double > const *)arg1);
16260   resultobj = SWIG_From_bool(static_cast< bool >(result));
16261   return resultobj;
16262 fail:
16263   return NULL;
16264 }
16265
16266
16267 SWIGINTERN PyObject *_wrap_VectorReal___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16268   PyObject *resultobj = 0;
16269   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16270   void *argp1 = 0 ;
16271   int res1 = 0 ;
16272   PyObject * obj0 = 0 ;
16273   std::vector< double >::size_type result;
16274
16275   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal___len__",&obj0)) SWIG_fail;
16276   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16277   if (!SWIG_IsOK(res1)) {
16278     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___len__" "', argument " "1"" of type '" "std::vector< double > const *""'");
16279   }
16280   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16281   result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
16282   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16283   return resultobj;
16284 fail:
16285   return NULL;
16286 }
16287
16288
16289 SWIGINTERN PyObject *_wrap_VectorReal___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16290   PyObject *resultobj = 0;
16291   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16292   std::vector< double >::difference_type arg2 ;
16293   std::vector< double >::difference_type arg3 ;
16294   void *argp1 = 0 ;
16295   int res1 = 0 ;
16296   ptrdiff_t val2 ;
16297   int ecode2 = 0 ;
16298   ptrdiff_t val3 ;
16299   int ecode3 = 0 ;
16300   PyObject * obj0 = 0 ;
16301   PyObject * obj1 = 0 ;
16302   PyObject * obj2 = 0 ;
16303   std::vector< double,std::allocator< double > > *result = 0 ;
16304
16305   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
16306   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16307   if (!SWIG_IsOK(res1)) {
16308     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
16309   }
16310   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16311   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16312   if (!SWIG_IsOK(ecode2)) {
16313     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16314   }
16315   arg2 = static_cast< std::vector< double >::difference_type >(val2);
16316   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
16317   if (!SWIG_IsOK(ecode3)) {
16318     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
16319   }
16320   arg3 = static_cast< std::vector< double >::difference_type >(val3);
16321   try {
16322     result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
16323   }
16324   catch(std::out_of_range &_e) {
16325     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16326   }
16327   catch(std::invalid_argument &_e) {
16328     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16329   }
16330
16331   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
16332   return resultobj;
16333 fail:
16334   return NULL;
16335 }
16336
16337
16338 SWIGINTERN PyObject *_wrap_VectorReal___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16339   PyObject *resultobj = 0;
16340   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16341   std::vector< double >::difference_type arg2 ;
16342   std::vector< double >::difference_type arg3 ;
16343   void *argp1 = 0 ;
16344   int res1 = 0 ;
16345   ptrdiff_t val2 ;
16346   int ecode2 = 0 ;
16347   ptrdiff_t val3 ;
16348   int ecode3 = 0 ;
16349   PyObject * obj0 = 0 ;
16350   PyObject * obj1 = 0 ;
16351   PyObject * obj2 = 0 ;
16352
16353   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
16354   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16355   if (!SWIG_IsOK(res1)) {
16356     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
16357   }
16358   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16359   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16360   if (!SWIG_IsOK(ecode2)) {
16361     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16362   }
16363   arg2 = static_cast< std::vector< double >::difference_type >(val2);
16364   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
16365   if (!SWIG_IsOK(ecode3)) {
16366     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
16367   }
16368   arg3 = static_cast< std::vector< double >::difference_type >(val3);
16369   try {
16370     std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3);
16371   }
16372   catch(std::out_of_range &_e) {
16373     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16374   }
16375   catch(std::invalid_argument &_e) {
16376     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16377   }
16378
16379   resultobj = SWIG_Py_Void();
16380   return resultobj;
16381 fail:
16382   return NULL;
16383 }
16384
16385
16386 SWIGINTERN PyObject *_wrap_VectorReal___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16387   PyObject *resultobj = 0;
16388   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16389   std::vector< double >::difference_type arg2 ;
16390   std::vector< double >::difference_type arg3 ;
16391   std::vector< double,std::allocator< double > > *arg4 = 0 ;
16392   void *argp1 = 0 ;
16393   int res1 = 0 ;
16394   ptrdiff_t val2 ;
16395   int ecode2 = 0 ;
16396   ptrdiff_t val3 ;
16397   int ecode3 = 0 ;
16398   int res4 = SWIG_OLDOBJ ;
16399   PyObject * obj0 = 0 ;
16400   PyObject * obj1 = 0 ;
16401   PyObject * obj2 = 0 ;
16402   PyObject * obj3 = 0 ;
16403
16404   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16405   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16406   if (!SWIG_IsOK(res1)) {
16407     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
16408   }
16409   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16410   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16411   if (!SWIG_IsOK(ecode2)) {
16412     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16413   }
16414   arg2 = static_cast< std::vector< double >::difference_type >(val2);
16415   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
16416   if (!SWIG_IsOK(ecode3)) {
16417     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
16418   }
16419   arg3 = static_cast< std::vector< double >::difference_type >(val3);
16420   {
16421     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
16422     res4 = swig::asptr(obj3, &ptr);
16423     if (!SWIG_IsOK(res4)) {
16424       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
16425     }
16426     if (!ptr) {
16427       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'");
16428     }
16429     arg4 = ptr;
16430   }
16431   try {
16432     std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
16433   }
16434   catch(std::out_of_range &_e) {
16435     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16436   }
16437   catch(std::invalid_argument &_e) {
16438     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16439   }
16440
16441   resultobj = SWIG_Py_Void();
16442   if (SWIG_IsNewObj(res4)) delete arg4;
16443   return resultobj;
16444 fail:
16445   if (SWIG_IsNewObj(res4)) delete arg4;
16446   return NULL;
16447 }
16448
16449
16450 SWIGINTERN PyObject *_wrap_VectorReal___setslice__(PyObject *self, PyObject *args) {
16451   Py_ssize_t argc;
16452   PyObject *argv[5] = {
16453     0
16454   };
16455   Py_ssize_t ii;
16456
16457   if (!PyTuple_Check(args)) SWIG_fail;
16458   argc = args ? PyObject_Length(args) : 0;
16459   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
16460     argv[ii] = PyTuple_GET_ITEM(args,ii);
16461   }
16462   if (argc == 3) {
16463     int _v;
16464     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16465     _v = SWIG_CheckState(res);
16466     if (_v) {
16467       {
16468         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
16469         _v = SWIG_CheckState(res);
16470       }
16471       if (_v) {
16472         {
16473           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
16474           _v = SWIG_CheckState(res);
16475         }
16476         if (_v) {
16477           return _wrap_VectorReal___setslice____SWIG_0(self, args);
16478         }
16479       }
16480     }
16481   }
16482   if (argc == 4) {
16483     int _v;
16484     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16485     _v = SWIG_CheckState(res);
16486     if (_v) {
16487       {
16488         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
16489         _v = SWIG_CheckState(res);
16490       }
16491       if (_v) {
16492         {
16493           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
16494           _v = SWIG_CheckState(res);
16495         }
16496         if (_v) {
16497           int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
16498           _v = SWIG_CheckState(res);
16499           if (_v) {
16500             return _wrap_VectorReal___setslice____SWIG_1(self, args);
16501           }
16502         }
16503       }
16504     }
16505   }
16506
16507 fail:
16508   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal___setslice__'.\n"
16509     "  Possible C/C++ prototypes are:\n"
16510     "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n"
16511     "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n");
16512   return 0;
16513 }
16514
16515
16516 SWIGINTERN PyObject *_wrap_VectorReal___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16517   PyObject *resultobj = 0;
16518   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16519   std::vector< double >::difference_type arg2 ;
16520   std::vector< double >::difference_type arg3 ;
16521   void *argp1 = 0 ;
16522   int res1 = 0 ;
16523   ptrdiff_t val2 ;
16524   int ecode2 = 0 ;
16525   ptrdiff_t val3 ;
16526   int ecode3 = 0 ;
16527   PyObject * obj0 = 0 ;
16528   PyObject * obj1 = 0 ;
16529   PyObject * obj2 = 0 ;
16530
16531   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
16532   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16533   if (!SWIG_IsOK(res1)) {
16534     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'");
16535   }
16536   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16537   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16538   if (!SWIG_IsOK(ecode2)) {
16539     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16540   }
16541   arg2 = static_cast< std::vector< double >::difference_type >(val2);
16542   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
16543   if (!SWIG_IsOK(ecode3)) {
16544     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
16545   }
16546   arg3 = static_cast< std::vector< double >::difference_type >(val3);
16547   try {
16548     std_vector_Sl_double_Sg____delslice__(arg1,arg2,arg3);
16549   }
16550   catch(std::out_of_range &_e) {
16551     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16552   }
16553   catch(std::invalid_argument &_e) {
16554     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16555   }
16556
16557   resultobj = SWIG_Py_Void();
16558   return resultobj;
16559 fail:
16560   return NULL;
16561 }
16562
16563
16564 SWIGINTERN PyObject *_wrap_VectorReal___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16565   PyObject *resultobj = 0;
16566   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16567   std::vector< double >::difference_type arg2 ;
16568   void *argp1 = 0 ;
16569   int res1 = 0 ;
16570   ptrdiff_t val2 ;
16571   int ecode2 = 0 ;
16572   PyObject * obj0 = 0 ;
16573   PyObject * obj1 = 0 ;
16574
16575   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___delitem__",&obj0,&obj1)) SWIG_fail;
16576   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16577   if (!SWIG_IsOK(res1)) {
16578     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16579   }
16580   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16581   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16582   if (!SWIG_IsOK(ecode2)) {
16583     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16584   }
16585   arg2 = static_cast< std::vector< double >::difference_type >(val2);
16586   try {
16587     std_vector_Sl_double_Sg____delitem____SWIG_0(arg1,arg2);
16588   }
16589   catch(std::out_of_range &_e) {
16590     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16591   }
16592   catch(std::invalid_argument &_e) {
16593     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16594   }
16595
16596   resultobj = SWIG_Py_Void();
16597   return resultobj;
16598 fail:
16599   return NULL;
16600 }
16601
16602
16603 SWIGINTERN PyObject *_wrap_VectorReal___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16604   PyObject *resultobj = 0;
16605   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16606   PySliceObject *arg2 = (PySliceObject *) 0 ;
16607   void *argp1 = 0 ;
16608   int res1 = 0 ;
16609   PyObject * obj0 = 0 ;
16610   PyObject * obj1 = 0 ;
16611   std::vector< double,std::allocator< double > > *result = 0 ;
16612
16613   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___getitem__",&obj0,&obj1)) SWIG_fail;
16614   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16615   if (!SWIG_IsOK(res1)) {
16616     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16617   }
16618   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16619   {
16620     if (!PySlice_Check(obj1)) {
16621       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
16622     }
16623     arg2 = (PySliceObject *) obj1;
16624   }
16625   try {
16626     result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
16627   }
16628   catch(std::out_of_range &_e) {
16629     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16630   }
16631   catch(std::invalid_argument &_e) {
16632     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16633   }
16634
16635   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
16636   return resultobj;
16637 fail:
16638   return NULL;
16639 }
16640
16641
16642 SWIGINTERN PyObject *_wrap_VectorReal___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16643   PyObject *resultobj = 0;
16644   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16645   PySliceObject *arg2 = (PySliceObject *) 0 ;
16646   std::vector< double,std::allocator< double > > *arg3 = 0 ;
16647   void *argp1 = 0 ;
16648   int res1 = 0 ;
16649   int res3 = SWIG_OLDOBJ ;
16650   PyObject * obj0 = 0 ;
16651   PyObject * obj1 = 0 ;
16652   PyObject * obj2 = 0 ;
16653
16654   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
16655   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16656   if (!SWIG_IsOK(res1)) {
16657     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16658   }
16659   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16660   {
16661     if (!PySlice_Check(obj1)) {
16662       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
16663     }
16664     arg2 = (PySliceObject *) obj1;
16665   }
16666   {
16667     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
16668     res3 = swig::asptr(obj2, &ptr);
16669     if (!SWIG_IsOK(res3)) {
16670       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
16671     }
16672     if (!ptr) {
16673       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
16674     }
16675     arg3 = ptr;
16676   }
16677   try {
16678     std_vector_Sl_double_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
16679   }
16680   catch(std::out_of_range &_e) {
16681     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16682   }
16683   catch(std::invalid_argument &_e) {
16684     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16685   }
16686
16687   resultobj = SWIG_Py_Void();
16688   if (SWIG_IsNewObj(res3)) delete arg3;
16689   return resultobj;
16690 fail:
16691   if (SWIG_IsNewObj(res3)) delete arg3;
16692   return NULL;
16693 }
16694
16695
16696 SWIGINTERN PyObject *_wrap_VectorReal___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16697   PyObject *resultobj = 0;
16698   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16699   PySliceObject *arg2 = (PySliceObject *) 0 ;
16700   void *argp1 = 0 ;
16701   int res1 = 0 ;
16702   PyObject * obj0 = 0 ;
16703   PyObject * obj1 = 0 ;
16704
16705   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___setitem__",&obj0,&obj1)) SWIG_fail;
16706   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16707   if (!SWIG_IsOK(res1)) {
16708     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16709   }
16710   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16711   {
16712     if (!PySlice_Check(obj1)) {
16713       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
16714     }
16715     arg2 = (PySliceObject *) obj1;
16716   }
16717   try {
16718     std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
16719   }
16720   catch(std::out_of_range &_e) {
16721     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16722   }
16723   catch(std::invalid_argument &_e) {
16724     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16725   }
16726
16727   resultobj = SWIG_Py_Void();
16728   return resultobj;
16729 fail:
16730   return NULL;
16731 }
16732
16733
16734 SWIGINTERN PyObject *_wrap_VectorReal___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16735   PyObject *resultobj = 0;
16736   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16737   PySliceObject *arg2 = (PySliceObject *) 0 ;
16738   void *argp1 = 0 ;
16739   int res1 = 0 ;
16740   PyObject * obj0 = 0 ;
16741   PyObject * obj1 = 0 ;
16742
16743   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___delitem__",&obj0,&obj1)) SWIG_fail;
16744   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16745   if (!SWIG_IsOK(res1)) {
16746     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16747   }
16748   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16749   {
16750     if (!PySlice_Check(obj1)) {
16751       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
16752     }
16753     arg2 = (PySliceObject *) obj1;
16754   }
16755   try {
16756     std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
16757   }
16758   catch(std::out_of_range &_e) {
16759     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16760   }
16761   catch(std::invalid_argument &_e) {
16762     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
16763   }
16764
16765   resultobj = SWIG_Py_Void();
16766   return resultobj;
16767 fail:
16768   return NULL;
16769 }
16770
16771
16772 SWIGINTERN PyObject *_wrap_VectorReal___delitem__(PyObject *self, PyObject *args) {
16773   Py_ssize_t argc;
16774   PyObject *argv[3] = {
16775     0
16776   };
16777   Py_ssize_t ii;
16778
16779   if (!PyTuple_Check(args)) SWIG_fail;
16780   argc = args ? PyObject_Length(args) : 0;
16781   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
16782     argv[ii] = PyTuple_GET_ITEM(args,ii);
16783   }
16784   if (argc == 2) {
16785     int _v;
16786     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16787     _v = SWIG_CheckState(res);
16788     if (_v) {
16789       {
16790         _v = PySlice_Check(argv[1]);
16791       }
16792       if (_v) {
16793         return _wrap_VectorReal___delitem____SWIG_1(self, args);
16794       }
16795     }
16796   }
16797   if (argc == 2) {
16798     int _v;
16799     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16800     _v = SWIG_CheckState(res);
16801     if (_v) {
16802       {
16803         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
16804         _v = SWIG_CheckState(res);
16805       }
16806       if (_v) {
16807         return _wrap_VectorReal___delitem____SWIG_0(self, args);
16808       }
16809     }
16810   }
16811
16812 fail:
16813   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal___delitem__'.\n"
16814     "  Possible C/C++ prototypes are:\n"
16815     "    std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
16816     "    std::vector< double >::__delitem__(PySliceObject *)\n");
16817   return 0;
16818 }
16819
16820
16821 SWIGINTERN PyObject *_wrap_VectorReal___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16822   PyObject *resultobj = 0;
16823   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16824   std::vector< double >::difference_type arg2 ;
16825   void *argp1 = 0 ;
16826   int res1 = 0 ;
16827   ptrdiff_t val2 ;
16828   int ecode2 = 0 ;
16829   PyObject * obj0 = 0 ;
16830   PyObject * obj1 = 0 ;
16831   std::vector< double >::value_type *result = 0 ;
16832
16833   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal___getitem__",&obj0,&obj1)) SWIG_fail;
16834   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16835   if (!SWIG_IsOK(res1)) {
16836     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'");
16837   }
16838   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16839   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16840   if (!SWIG_IsOK(ecode2)) {
16841     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16842   }
16843   arg2 = static_cast< std::vector< double >::difference_type >(val2);
16844   try {
16845     result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg____getitem____SWIG_1((std::vector< double > const *)arg1,arg2);
16846   }
16847   catch(std::out_of_range &_e) {
16848     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16849   }
16850
16851   resultobj = SWIG_From_double(static_cast< double >(*result));
16852   return resultobj;
16853 fail:
16854   return NULL;
16855 }
16856
16857
16858 SWIGINTERN PyObject *_wrap_VectorReal___getitem__(PyObject *self, PyObject *args) {
16859   Py_ssize_t argc;
16860   PyObject *argv[3] = {
16861     0
16862   };
16863   Py_ssize_t ii;
16864
16865   if (!PyTuple_Check(args)) SWIG_fail;
16866   argc = args ? PyObject_Length(args) : 0;
16867   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
16868     argv[ii] = PyTuple_GET_ITEM(args,ii);
16869   }
16870   if (argc == 2) {
16871     int _v;
16872     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16873     _v = SWIG_CheckState(res);
16874     if (_v) {
16875       {
16876         _v = PySlice_Check(argv[1]);
16877       }
16878       if (_v) {
16879         return _wrap_VectorReal___getitem____SWIG_0(self, args);
16880       }
16881     }
16882   }
16883   if (argc == 2) {
16884     int _v;
16885     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16886     _v = SWIG_CheckState(res);
16887     if (_v) {
16888       {
16889         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
16890         _v = SWIG_CheckState(res);
16891       }
16892       if (_v) {
16893         return _wrap_VectorReal___getitem____SWIG_1(self, args);
16894       }
16895     }
16896   }
16897
16898 fail:
16899   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal___getitem__'.\n"
16900     "  Possible C/C++ prototypes are:\n"
16901     "    std::vector< double >::__getitem__(PySliceObject *)\n"
16902     "    std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
16903   return 0;
16904 }
16905
16906
16907 SWIGINTERN PyObject *_wrap_VectorReal___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16908   PyObject *resultobj = 0;
16909   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
16910   std::vector< double >::difference_type arg2 ;
16911   std::vector< double >::value_type *arg3 = 0 ;
16912   void *argp1 = 0 ;
16913   int res1 = 0 ;
16914   ptrdiff_t val2 ;
16915   int ecode2 = 0 ;
16916   std::vector< double >::value_type temp3 ;
16917   double val3 ;
16918   int ecode3 = 0 ;
16919   PyObject * obj0 = 0 ;
16920   PyObject * obj1 = 0 ;
16921   PyObject * obj2 = 0 ;
16922
16923   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
16924   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
16925   if (!SWIG_IsOK(res1)) {
16926     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'");
16927   }
16928   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
16929   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
16930   if (!SWIG_IsOK(ecode2)) {
16931     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
16932   }
16933   arg2 = static_cast< std::vector< double >::difference_type >(val2);
16934   ecode3 = SWIG_AsVal_double(obj2, &val3);
16935   if (!SWIG_IsOK(ecode3)) {
16936     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
16937   }
16938   temp3 = static_cast< std::vector< double >::value_type >(val3);
16939   arg3 = &temp3;
16940   try {
16941     std_vector_Sl_double_Sg____setitem____SWIG_2(arg1,arg2,(double const &)*arg3);
16942   }
16943   catch(std::out_of_range &_e) {
16944     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
16945   }
16946
16947   resultobj = SWIG_Py_Void();
16948   return resultobj;
16949 fail:
16950   return NULL;
16951 }
16952
16953
16954 SWIGINTERN PyObject *_wrap_VectorReal___setitem__(PyObject *self, PyObject *args) {
16955   Py_ssize_t argc;
16956   PyObject *argv[4] = {
16957     0
16958   };
16959   Py_ssize_t ii;
16960
16961   if (!PyTuple_Check(args)) SWIG_fail;
16962   argc = args ? PyObject_Length(args) : 0;
16963   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
16964     argv[ii] = PyTuple_GET_ITEM(args,ii);
16965   }
16966   if (argc == 2) {
16967     int _v;
16968     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16969     _v = SWIG_CheckState(res);
16970     if (_v) {
16971       {
16972         _v = PySlice_Check(argv[1]);
16973       }
16974       if (_v) {
16975         return _wrap_VectorReal___setitem____SWIG_1(self, args);
16976       }
16977     }
16978   }
16979   if (argc == 3) {
16980     int _v;
16981     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16982     _v = SWIG_CheckState(res);
16983     if (_v) {
16984       {
16985         _v = PySlice_Check(argv[1]);
16986       }
16987       if (_v) {
16988         int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
16989         _v = SWIG_CheckState(res);
16990         if (_v) {
16991           return _wrap_VectorReal___setitem____SWIG_0(self, args);
16992         }
16993       }
16994     }
16995   }
16996   if (argc == 3) {
16997     int _v;
16998     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
16999     _v = SWIG_CheckState(res);
17000     if (_v) {
17001       {
17002         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
17003         _v = SWIG_CheckState(res);
17004       }
17005       if (_v) {
17006         {
17007           int res = SWIG_AsVal_double(argv[2], NULL);
17008           _v = SWIG_CheckState(res);
17009         }
17010         if (_v) {
17011           return _wrap_VectorReal___setitem____SWIG_2(self, args);
17012         }
17013       }
17014     }
17015   }
17016
17017 fail:
17018   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal___setitem__'.\n"
17019     "  Possible C/C++ prototypes are:\n"
17020     "    std::vector< double >::__setitem__(PySliceObject *,std::vector< double,std::allocator< double > > const &)\n"
17021     "    std::vector< double >::__setitem__(PySliceObject *)\n"
17022     "    std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
17023   return 0;
17024 }
17025
17026
17027 SWIGINTERN PyObject *_wrap_VectorReal_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17028   PyObject *resultobj = 0;
17029   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17030   void *argp1 = 0 ;
17031   int res1 = 0 ;
17032   PyObject * obj0 = 0 ;
17033   std::vector< double >::value_type result;
17034
17035   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop",&obj0)) SWIG_fail;
17036   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17037   if (!SWIG_IsOK(res1)) {
17038     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop" "', argument " "1"" of type '" "std::vector< double > *""'");
17039   }
17040   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17041   try {
17042     result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
17043   }
17044   catch(std::out_of_range &_e) {
17045     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
17046   }
17047
17048   resultobj = SWIG_From_double(static_cast< double >(result));
17049   return resultobj;
17050 fail:
17051   return NULL;
17052 }
17053
17054
17055 SWIGINTERN PyObject *_wrap_VectorReal_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17056   PyObject *resultobj = 0;
17057   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17058   std::vector< double >::value_type *arg2 = 0 ;
17059   void *argp1 = 0 ;
17060   int res1 = 0 ;
17061   std::vector< double >::value_type temp2 ;
17062   double val2 ;
17063   int ecode2 = 0 ;
17064   PyObject * obj0 = 0 ;
17065   PyObject * obj1 = 0 ;
17066
17067   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_append",&obj0,&obj1)) SWIG_fail;
17068   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17069   if (!SWIG_IsOK(res1)) {
17070     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_append" "', argument " "1"" of type '" "std::vector< double > *""'");
17071   }
17072   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17073   ecode2 = SWIG_AsVal_double(obj1, &val2);
17074   if (!SWIG_IsOK(ecode2)) {
17075     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
17076   }
17077   temp2 = static_cast< std::vector< double >::value_type >(val2);
17078   arg2 = &temp2;
17079   std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
17080   resultobj = SWIG_Py_Void();
17081   return resultobj;
17082 fail:
17083   return NULL;
17084 }
17085
17086
17087 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17088   PyObject *resultobj = 0;
17089   std::vector< double > *result = 0 ;
17090
17091   if (!PyArg_ParseTuple(args,(char *)":new_VectorReal")) SWIG_fail;
17092   result = (std::vector< double > *)new std::vector< double >();
17093   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
17094   return resultobj;
17095 fail:
17096   return NULL;
17097 }
17098
17099
17100 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17101   PyObject *resultobj = 0;
17102   std::vector< double > *arg1 = 0 ;
17103   int res1 = SWIG_OLDOBJ ;
17104   PyObject * obj0 = 0 ;
17105   std::vector< double > *result = 0 ;
17106
17107   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
17108   {
17109     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
17110     res1 = swig::asptr(obj0, &ptr);
17111     if (!SWIG_IsOK(res1)) {
17112       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double > const &""'");
17113     }
17114     if (!ptr) {
17115       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double > const &""'");
17116     }
17117     arg1 = ptr;
17118   }
17119   result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
17120   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
17121   if (SWIG_IsNewObj(res1)) delete arg1;
17122   return resultobj;
17123 fail:
17124   if (SWIG_IsNewObj(res1)) delete arg1;
17125   return NULL;
17126 }
17127
17128
17129 SWIGINTERN PyObject *_wrap_VectorReal_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17130   PyObject *resultobj = 0;
17131   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17132   void *argp1 = 0 ;
17133   int res1 = 0 ;
17134   PyObject * obj0 = 0 ;
17135   bool result;
17136
17137   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_empty",&obj0)) SWIG_fail;
17138   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17139   if (!SWIG_IsOK(res1)) {
17140     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_empty" "', argument " "1"" of type '" "std::vector< double > const *""'");
17141   }
17142   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17143   result = (bool)((std::vector< double > const *)arg1)->empty();
17144   resultobj = SWIG_From_bool(static_cast< bool >(result));
17145   return resultobj;
17146 fail:
17147   return NULL;
17148 }
17149
17150
17151 SWIGINTERN PyObject *_wrap_VectorReal_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17152   PyObject *resultobj = 0;
17153   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17154   void *argp1 = 0 ;
17155   int res1 = 0 ;
17156   PyObject * obj0 = 0 ;
17157   std::vector< double >::size_type result;
17158
17159   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_size",&obj0)) SWIG_fail;
17160   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17161   if (!SWIG_IsOK(res1)) {
17162     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_size" "', argument " "1"" of type '" "std::vector< double > const *""'");
17163   }
17164   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17165   result = ((std::vector< double > const *)arg1)->size();
17166   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17167   return resultobj;
17168 fail:
17169   return NULL;
17170 }
17171
17172
17173 SWIGINTERN PyObject *_wrap_VectorReal_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17174   PyObject *resultobj = 0;
17175   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17176   std::vector< double > *arg2 = 0 ;
17177   void *argp1 = 0 ;
17178   int res1 = 0 ;
17179   void *argp2 = 0 ;
17180   int res2 = 0 ;
17181   PyObject * obj0 = 0 ;
17182   PyObject * obj1 = 0 ;
17183
17184   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_swap",&obj0,&obj1)) SWIG_fail;
17185   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17186   if (!SWIG_IsOK(res1)) {
17187     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_swap" "', argument " "1"" of type '" "std::vector< double > *""'");
17188   }
17189   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17190   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
17191   if (!SWIG_IsOK(res2)) {
17192     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
17193   }
17194   if (!argp2) {
17195     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorReal_swap" "', argument " "2"" of type '" "std::vector< double > &""'");
17196   }
17197   arg2 = reinterpret_cast< std::vector< double > * >(argp2);
17198   (arg1)->swap(*arg2);
17199   resultobj = SWIG_Py_Void();
17200   return resultobj;
17201 fail:
17202   return NULL;
17203 }
17204
17205
17206 SWIGINTERN PyObject *_wrap_VectorReal_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17207   PyObject *resultobj = 0;
17208   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17209   void *argp1 = 0 ;
17210   int res1 = 0 ;
17211   PyObject * obj0 = 0 ;
17212   std::vector< double >::iterator result;
17213
17214   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_begin",&obj0)) SWIG_fail;
17215   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17216   if (!SWIG_IsOK(res1)) {
17217     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_begin" "', argument " "1"" of type '" "std::vector< double > *""'");
17218   }
17219   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17220   result = (arg1)->begin();
17221   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
17222     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17223   return resultobj;
17224 fail:
17225   return NULL;
17226 }
17227
17228
17229 SWIGINTERN PyObject *_wrap_VectorReal_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17230   PyObject *resultobj = 0;
17231   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17232   void *argp1 = 0 ;
17233   int res1 = 0 ;
17234   PyObject * obj0 = 0 ;
17235   std::vector< double >::iterator result;
17236
17237   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_end",&obj0)) SWIG_fail;
17238   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17239   if (!SWIG_IsOK(res1)) {
17240     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_end" "', argument " "1"" of type '" "std::vector< double > *""'");
17241   }
17242   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17243   result = (arg1)->end();
17244   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
17245     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17246   return resultobj;
17247 fail:
17248   return NULL;
17249 }
17250
17251
17252 SWIGINTERN PyObject *_wrap_VectorReal_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17253   PyObject *resultobj = 0;
17254   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17255   void *argp1 = 0 ;
17256   int res1 = 0 ;
17257   PyObject * obj0 = 0 ;
17258   std::vector< double >::reverse_iterator result;
17259
17260   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rbegin",&obj0)) SWIG_fail;
17261   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17262   if (!SWIG_IsOK(res1)) {
17263     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rbegin" "', argument " "1"" of type '" "std::vector< double > *""'");
17264   }
17265   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17266   result = (arg1)->rbegin();
17267   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
17268     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17269   return resultobj;
17270 fail:
17271   return NULL;
17272 }
17273
17274
17275 SWIGINTERN PyObject *_wrap_VectorReal_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17276   PyObject *resultobj = 0;
17277   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17278   void *argp1 = 0 ;
17279   int res1 = 0 ;
17280   PyObject * obj0 = 0 ;
17281   std::vector< double >::reverse_iterator result;
17282
17283   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_rend",&obj0)) SWIG_fail;
17284   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17285   if (!SWIG_IsOK(res1)) {
17286     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_rend" "', argument " "1"" of type '" "std::vector< double > *""'");
17287   }
17288   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17289   result = (arg1)->rend();
17290   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
17291     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17292   return resultobj;
17293 fail:
17294   return NULL;
17295 }
17296
17297
17298 SWIGINTERN PyObject *_wrap_VectorReal_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17299   PyObject *resultobj = 0;
17300   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17301   void *argp1 = 0 ;
17302   int res1 = 0 ;
17303   PyObject * obj0 = 0 ;
17304
17305   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_clear",&obj0)) SWIG_fail;
17306   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17307   if (!SWIG_IsOK(res1)) {
17308     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_clear" "', argument " "1"" of type '" "std::vector< double > *""'");
17309   }
17310   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17311   (arg1)->clear();
17312   resultobj = SWIG_Py_Void();
17313   return resultobj;
17314 fail:
17315   return NULL;
17316 }
17317
17318
17319 SWIGINTERN PyObject *_wrap_VectorReal_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17320   PyObject *resultobj = 0;
17321   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17322   void *argp1 = 0 ;
17323   int res1 = 0 ;
17324   PyObject * obj0 = 0 ;
17325   SwigValueWrapper< std::allocator< double > > result;
17326
17327   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_get_allocator",&obj0)) SWIG_fail;
17328   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17329   if (!SWIG_IsOK(res1)) {
17330     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'");
17331   }
17332   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17333   result = ((std::vector< double > const *)arg1)->get_allocator();
17334   resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
17335   return resultobj;
17336 fail:
17337   return NULL;
17338 }
17339
17340
17341 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17342   PyObject *resultobj = 0;
17343   std::vector< double >::size_type arg1 ;
17344   size_t val1 ;
17345   int ecode1 = 0 ;
17346   PyObject * obj0 = 0 ;
17347   std::vector< double > *result = 0 ;
17348
17349   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorReal",&obj0)) SWIG_fail;
17350   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
17351   if (!SWIG_IsOK(ecode1)) {
17352     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
17353   }
17354   arg1 = static_cast< std::vector< double >::size_type >(val1);
17355   result = (std::vector< double > *)new std::vector< double >(arg1);
17356   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
17357   return resultobj;
17358 fail:
17359   return NULL;
17360 }
17361
17362
17363 SWIGINTERN PyObject *_wrap_VectorReal_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17364   PyObject *resultobj = 0;
17365   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17366   void *argp1 = 0 ;
17367   int res1 = 0 ;
17368   PyObject * obj0 = 0 ;
17369
17370   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_pop_back",&obj0)) SWIG_fail;
17371   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17372   if (!SWIG_IsOK(res1)) {
17373     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'");
17374   }
17375   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17376   (arg1)->pop_back();
17377   resultobj = SWIG_Py_Void();
17378   return resultobj;
17379 fail:
17380   return NULL;
17381 }
17382
17383
17384 SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17385   PyObject *resultobj = 0;
17386   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17387   std::vector< double >::size_type arg2 ;
17388   void *argp1 = 0 ;
17389   int res1 = 0 ;
17390   size_t val2 ;
17391   int ecode2 = 0 ;
17392   PyObject * obj0 = 0 ;
17393   PyObject * obj1 = 0 ;
17394
17395   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_resize",&obj0,&obj1)) SWIG_fail;
17396   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17397   if (!SWIG_IsOK(res1)) {
17398     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
17399   }
17400   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17401   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17402   if (!SWIG_IsOK(ecode2)) {
17403     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
17404   }
17405   arg2 = static_cast< std::vector< double >::size_type >(val2);
17406   (arg1)->resize(arg2);
17407   resultobj = SWIG_Py_Void();
17408   return resultobj;
17409 fail:
17410   return NULL;
17411 }
17412
17413
17414 SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17415   PyObject *resultobj = 0;
17416   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17417   std::vector< double >::iterator arg2 ;
17418   void *argp1 = 0 ;
17419   int res1 = 0 ;
17420   swig::SwigPyIterator *iter2 = 0 ;
17421   int res2 ;
17422   PyObject * obj0 = 0 ;
17423   PyObject * obj1 = 0 ;
17424   std::vector< double >::iterator result;
17425
17426   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_erase",&obj0,&obj1)) SWIG_fail;
17427   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17428   if (!SWIG_IsOK(res1)) {
17429     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
17430   }
17431   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17432   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17433   if (!SWIG_IsOK(res2) || !iter2) {
17434     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17435   } else {
17436     swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
17437     if (iter_t) {
17438       arg2 = iter_t->get_current();
17439     } else {
17440       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17441     }
17442   }
17443   result = std_vector_Sl_double_Sg__erase__SWIG_0(arg1,arg2);
17444   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
17445     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17446   return resultobj;
17447 fail:
17448   return NULL;
17449 }
17450
17451
17452 SWIGINTERN PyObject *_wrap_VectorReal_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17453   PyObject *resultobj = 0;
17454   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17455   std::vector< double >::iterator arg2 ;
17456   std::vector< double >::iterator arg3 ;
17457   void *argp1 = 0 ;
17458   int res1 = 0 ;
17459   swig::SwigPyIterator *iter2 = 0 ;
17460   int res2 ;
17461   swig::SwigPyIterator *iter3 = 0 ;
17462   int res3 ;
17463   PyObject * obj0 = 0 ;
17464   PyObject * obj1 = 0 ;
17465   PyObject * obj2 = 0 ;
17466   std::vector< double >::iterator result;
17467
17468   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_erase",&obj0,&obj1,&obj2)) SWIG_fail;
17469   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17470   if (!SWIG_IsOK(res1)) {
17471     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_erase" "', argument " "1"" of type '" "std::vector< double > *""'");
17472   }
17473   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17474   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17475   if (!SWIG_IsOK(res2) || !iter2) {
17476     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17477   } else {
17478     swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
17479     if (iter_t) {
17480       arg2 = iter_t->get_current();
17481     } else {
17482       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17483     }
17484   }
17485   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
17486   if (!SWIG_IsOK(res3) || !iter3) {
17487     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
17488   } else {
17489     swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter3);
17490     if (iter_t) {
17491       arg3 = iter_t->get_current();
17492     } else {
17493       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
17494     }
17495   }
17496   result = std_vector_Sl_double_Sg__erase__SWIG_1(arg1,arg2,arg3);
17497   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
17498     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17499   return resultobj;
17500 fail:
17501   return NULL;
17502 }
17503
17504
17505 SWIGINTERN PyObject *_wrap_VectorReal_erase(PyObject *self, PyObject *args) {
17506   Py_ssize_t argc;
17507   PyObject *argv[4] = {
17508     0
17509   };
17510   Py_ssize_t ii;
17511
17512   if (!PyTuple_Check(args)) SWIG_fail;
17513   argc = args ? PyObject_Length(args) : 0;
17514   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
17515     argv[ii] = PyTuple_GET_ITEM(args,ii);
17516   }
17517   if (argc == 2) {
17518     int _v;
17519     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17520     _v = SWIG_CheckState(res);
17521     if (_v) {
17522       swig::SwigPyIterator *iter = 0;
17523       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17524       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
17525       if (_v) {
17526         return _wrap_VectorReal_erase__SWIG_0(self, args);
17527       }
17528     }
17529   }
17530   if (argc == 3) {
17531     int _v;
17532     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17533     _v = SWIG_CheckState(res);
17534     if (_v) {
17535       swig::SwigPyIterator *iter = 0;
17536       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17537       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
17538       if (_v) {
17539         swig::SwigPyIterator *iter = 0;
17540         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17541         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
17542         if (_v) {
17543           return _wrap_VectorReal_erase__SWIG_1(self, args);
17544         }
17545       }
17546     }
17547   }
17548
17549 fail:
17550   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal_erase'.\n"
17551     "  Possible C/C++ prototypes are:\n"
17552     "    std::vector< double >::erase(std::vector< double >::iterator)\n"
17553     "    std::vector< double >::erase(std::vector< double >::iterator,std::vector< double >::iterator)\n");
17554   return 0;
17555 }
17556
17557
17558 SWIGINTERN PyObject *_wrap_new_VectorReal__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17559   PyObject *resultobj = 0;
17560   std::vector< double >::size_type arg1 ;
17561   std::vector< double >::value_type *arg2 = 0 ;
17562   size_t val1 ;
17563   int ecode1 = 0 ;
17564   std::vector< double >::value_type temp2 ;
17565   double val2 ;
17566   int ecode2 = 0 ;
17567   PyObject * obj0 = 0 ;
17568   PyObject * obj1 = 0 ;
17569   std::vector< double > *result = 0 ;
17570
17571   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorReal",&obj0,&obj1)) SWIG_fail;
17572   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
17573   if (!SWIG_IsOK(ecode1)) {
17574     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorReal" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
17575   }
17576   arg1 = static_cast< std::vector< double >::size_type >(val1);
17577   ecode2 = SWIG_AsVal_double(obj1, &val2);
17578   if (!SWIG_IsOK(ecode2)) {
17579     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorReal" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
17580   }
17581   temp2 = static_cast< std::vector< double >::value_type >(val2);
17582   arg2 = &temp2;
17583   result = (std::vector< double > *)new std::vector< double >(arg1,(std::vector< double >::value_type const &)*arg2);
17584   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_NEW |  0 );
17585   return resultobj;
17586 fail:
17587   return NULL;
17588 }
17589
17590
17591 SWIGINTERN PyObject *_wrap_new_VectorReal(PyObject *self, PyObject *args) {
17592   Py_ssize_t argc;
17593   PyObject *argv[3] = {
17594     0
17595   };
17596   Py_ssize_t ii;
17597
17598   if (!PyTuple_Check(args)) SWIG_fail;
17599   argc = args ? PyObject_Length(args) : 0;
17600   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
17601     argv[ii] = PyTuple_GET_ITEM(args,ii);
17602   }
17603   if (argc == 0) {
17604     return _wrap_new_VectorReal__SWIG_0(self, args);
17605   }
17606   if (argc == 1) {
17607     int _v;
17608     {
17609       int res = SWIG_AsVal_size_t(argv[0], NULL);
17610       _v = SWIG_CheckState(res);
17611     }
17612     if (_v) {
17613       return _wrap_new_VectorReal__SWIG_2(self, args);
17614     }
17615   }
17616   if (argc == 1) {
17617     int _v;
17618     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17619     _v = SWIG_CheckState(res);
17620     if (_v) {
17621       return _wrap_new_VectorReal__SWIG_1(self, args);
17622     }
17623   }
17624   if (argc == 2) {
17625     int _v;
17626     {
17627       int res = SWIG_AsVal_size_t(argv[0], NULL);
17628       _v = SWIG_CheckState(res);
17629     }
17630     if (_v) {
17631       {
17632         int res = SWIG_AsVal_double(argv[1], NULL);
17633         _v = SWIG_CheckState(res);
17634       }
17635       if (_v) {
17636         return _wrap_new_VectorReal__SWIG_3(self, args);
17637       }
17638     }
17639   }
17640
17641 fail:
17642   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorReal'.\n"
17643     "  Possible C/C++ prototypes are:\n"
17644     "    std::vector< double >::vector()\n"
17645     "    std::vector< double >::vector(std::vector< double > const &)\n"
17646     "    std::vector< double >::vector(std::vector< double >::size_type)\n"
17647     "    std::vector< double >::vector(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
17648   return 0;
17649 }
17650
17651
17652 SWIGINTERN PyObject *_wrap_VectorReal_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17653   PyObject *resultobj = 0;
17654   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17655   std::vector< double >::value_type *arg2 = 0 ;
17656   void *argp1 = 0 ;
17657   int res1 = 0 ;
17658   std::vector< double >::value_type temp2 ;
17659   double val2 ;
17660   int ecode2 = 0 ;
17661   PyObject * obj0 = 0 ;
17662   PyObject * obj1 = 0 ;
17663
17664   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_push_back",&obj0,&obj1)) SWIG_fail;
17665   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17666   if (!SWIG_IsOK(res1)) {
17667     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_push_back" "', argument " "1"" of type '" "std::vector< double > *""'");
17668   }
17669   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17670   ecode2 = SWIG_AsVal_double(obj1, &val2);
17671   if (!SWIG_IsOK(ecode2)) {
17672     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
17673   }
17674   temp2 = static_cast< std::vector< double >::value_type >(val2);
17675   arg2 = &temp2;
17676   (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
17677   resultobj = SWIG_Py_Void();
17678   return resultobj;
17679 fail:
17680   return NULL;
17681 }
17682
17683
17684 SWIGINTERN PyObject *_wrap_VectorReal_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17685   PyObject *resultobj = 0;
17686   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17687   void *argp1 = 0 ;
17688   int res1 = 0 ;
17689   PyObject * obj0 = 0 ;
17690   std::vector< double >::value_type *result = 0 ;
17691
17692   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_front",&obj0)) SWIG_fail;
17693   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17694   if (!SWIG_IsOK(res1)) {
17695     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_front" "', argument " "1"" of type '" "std::vector< double > const *""'");
17696   }
17697   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17698   result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->front();
17699   resultobj = SWIG_From_double(static_cast< double >(*result));
17700   return resultobj;
17701 fail:
17702   return NULL;
17703 }
17704
17705
17706 SWIGINTERN PyObject *_wrap_VectorReal_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17707   PyObject *resultobj = 0;
17708   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17709   void *argp1 = 0 ;
17710   int res1 = 0 ;
17711   PyObject * obj0 = 0 ;
17712   std::vector< double >::value_type *result = 0 ;
17713
17714   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_back",&obj0)) SWIG_fail;
17715   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17716   if (!SWIG_IsOK(res1)) {
17717     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_back" "', argument " "1"" of type '" "std::vector< double > const *""'");
17718   }
17719   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17720   result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->back();
17721   resultobj = SWIG_From_double(static_cast< double >(*result));
17722   return resultobj;
17723 fail:
17724   return NULL;
17725 }
17726
17727
17728 SWIGINTERN PyObject *_wrap_VectorReal_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17729   PyObject *resultobj = 0;
17730   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17731   std::vector< double >::size_type arg2 ;
17732   std::vector< double >::value_type *arg3 = 0 ;
17733   void *argp1 = 0 ;
17734   int res1 = 0 ;
17735   size_t val2 ;
17736   int ecode2 = 0 ;
17737   std::vector< double >::value_type temp3 ;
17738   double val3 ;
17739   int ecode3 = 0 ;
17740   PyObject * obj0 = 0 ;
17741   PyObject * obj1 = 0 ;
17742   PyObject * obj2 = 0 ;
17743
17744   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_assign",&obj0,&obj1,&obj2)) SWIG_fail;
17745   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17746   if (!SWIG_IsOK(res1)) {
17747     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_assign" "', argument " "1"" of type '" "std::vector< double > *""'");
17748   }
17749   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17750   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17751   if (!SWIG_IsOK(ecode2)) {
17752     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
17753   }
17754   arg2 = static_cast< std::vector< double >::size_type >(val2);
17755   ecode3 = SWIG_AsVal_double(obj2, &val3);
17756   if (!SWIG_IsOK(ecode3)) {
17757     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
17758   }
17759   temp3 = static_cast< std::vector< double >::value_type >(val3);
17760   arg3 = &temp3;
17761   (arg1)->assign(arg2,(std::vector< double >::value_type const &)*arg3);
17762   resultobj = SWIG_Py_Void();
17763   return resultobj;
17764 fail:
17765   return NULL;
17766 }
17767
17768
17769 SWIGINTERN PyObject *_wrap_VectorReal_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17770   PyObject *resultobj = 0;
17771   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17772   std::vector< double >::size_type arg2 ;
17773   std::vector< double >::value_type *arg3 = 0 ;
17774   void *argp1 = 0 ;
17775   int res1 = 0 ;
17776   size_t val2 ;
17777   int ecode2 = 0 ;
17778   std::vector< double >::value_type temp3 ;
17779   double val3 ;
17780   int ecode3 = 0 ;
17781   PyObject * obj0 = 0 ;
17782   PyObject * obj1 = 0 ;
17783   PyObject * obj2 = 0 ;
17784
17785   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_resize",&obj0,&obj1,&obj2)) SWIG_fail;
17786   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17787   if (!SWIG_IsOK(res1)) {
17788     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_resize" "', argument " "1"" of type '" "std::vector< double > *""'");
17789   }
17790   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17791   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17792   if (!SWIG_IsOK(ecode2)) {
17793     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
17794   }
17795   arg2 = static_cast< std::vector< double >::size_type >(val2);
17796   ecode3 = SWIG_AsVal_double(obj2, &val3);
17797   if (!SWIG_IsOK(ecode3)) {
17798     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
17799   }
17800   temp3 = static_cast< std::vector< double >::value_type >(val3);
17801   arg3 = &temp3;
17802   (arg1)->resize(arg2,(std::vector< double >::value_type const &)*arg3);
17803   resultobj = SWIG_Py_Void();
17804   return resultobj;
17805 fail:
17806   return NULL;
17807 }
17808
17809
17810 SWIGINTERN PyObject *_wrap_VectorReal_resize(PyObject *self, PyObject *args) {
17811   Py_ssize_t argc;
17812   PyObject *argv[4] = {
17813     0
17814   };
17815   Py_ssize_t ii;
17816
17817   if (!PyTuple_Check(args)) SWIG_fail;
17818   argc = args ? PyObject_Length(args) : 0;
17819   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
17820     argv[ii] = PyTuple_GET_ITEM(args,ii);
17821   }
17822   if (argc == 2) {
17823     int _v;
17824     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17825     _v = SWIG_CheckState(res);
17826     if (_v) {
17827       {
17828         int res = SWIG_AsVal_size_t(argv[1], NULL);
17829         _v = SWIG_CheckState(res);
17830       }
17831       if (_v) {
17832         return _wrap_VectorReal_resize__SWIG_0(self, args);
17833       }
17834     }
17835   }
17836   if (argc == 3) {
17837     int _v;
17838     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17839     _v = SWIG_CheckState(res);
17840     if (_v) {
17841       {
17842         int res = SWIG_AsVal_size_t(argv[1], NULL);
17843         _v = SWIG_CheckState(res);
17844       }
17845       if (_v) {
17846         {
17847           int res = SWIG_AsVal_double(argv[2], NULL);
17848           _v = SWIG_CheckState(res);
17849         }
17850         if (_v) {
17851           return _wrap_VectorReal_resize__SWIG_1(self, args);
17852         }
17853       }
17854     }
17855   }
17856
17857 fail:
17858   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal_resize'.\n"
17859     "  Possible C/C++ prototypes are:\n"
17860     "    std::vector< double >::resize(std::vector< double >::size_type)\n"
17861     "    std::vector< double >::resize(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
17862   return 0;
17863 }
17864
17865
17866 SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17867   PyObject *resultobj = 0;
17868   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17869   std::vector< double >::iterator arg2 ;
17870   std::vector< double >::value_type *arg3 = 0 ;
17871   void *argp1 = 0 ;
17872   int res1 = 0 ;
17873   swig::SwigPyIterator *iter2 = 0 ;
17874   int res2 ;
17875   std::vector< double >::value_type temp3 ;
17876   double val3 ;
17877   int ecode3 = 0 ;
17878   PyObject * obj0 = 0 ;
17879   PyObject * obj1 = 0 ;
17880   PyObject * obj2 = 0 ;
17881   std::vector< double >::iterator result;
17882
17883   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorReal_insert",&obj0,&obj1,&obj2)) SWIG_fail;
17884   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17885   if (!SWIG_IsOK(res1)) {
17886     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
17887   }
17888   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17889   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17890   if (!SWIG_IsOK(res2) || !iter2) {
17891     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17892   } else {
17893     swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
17894     if (iter_t) {
17895       arg2 = iter_t->get_current();
17896     } else {
17897       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17898     }
17899   }
17900   ecode3 = SWIG_AsVal_double(obj2, &val3);
17901   if (!SWIG_IsOK(ecode3)) {
17902     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
17903   }
17904   temp3 = static_cast< std::vector< double >::value_type >(val3);
17905   arg3 = &temp3;
17906   result = std_vector_Sl_double_Sg__insert__SWIG_0(arg1,arg2,(double const &)*arg3);
17907   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
17908     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
17909   return resultobj;
17910 fail:
17911   return NULL;
17912 }
17913
17914
17915 SWIGINTERN PyObject *_wrap_VectorReal_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17916   PyObject *resultobj = 0;
17917   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
17918   std::vector< double >::iterator arg2 ;
17919   std::vector< double >::size_type arg3 ;
17920   std::vector< double >::value_type *arg4 = 0 ;
17921   void *argp1 = 0 ;
17922   int res1 = 0 ;
17923   swig::SwigPyIterator *iter2 = 0 ;
17924   int res2 ;
17925   size_t val3 ;
17926   int ecode3 = 0 ;
17927   std::vector< double >::value_type temp4 ;
17928   double val4 ;
17929   int ecode4 = 0 ;
17930   PyObject * obj0 = 0 ;
17931   PyObject * obj1 = 0 ;
17932   PyObject * obj2 = 0 ;
17933   PyObject * obj3 = 0 ;
17934
17935   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorReal_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17936   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
17937   if (!SWIG_IsOK(res1)) {
17938     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_insert" "', argument " "1"" of type '" "std::vector< double > *""'");
17939   }
17940   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
17941   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
17942   if (!SWIG_IsOK(res2) || !iter2) {
17943     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17944   } else {
17945     swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
17946     if (iter_t) {
17947       arg2 = iter_t->get_current();
17948     } else {
17949       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorReal_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
17950     }
17951   }
17952   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
17953   if (!SWIG_IsOK(ecode3)) {
17954     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorReal_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
17955   }
17956   arg3 = static_cast< std::vector< double >::size_type >(val3);
17957   ecode4 = SWIG_AsVal_double(obj3, &val4);
17958   if (!SWIG_IsOK(ecode4)) {
17959     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorReal_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
17960   }
17961   temp4 = static_cast< std::vector< double >::value_type >(val4);
17962   arg4 = &temp4;
17963   std_vector_Sl_double_Sg__insert__SWIG_1(arg1,arg2,arg3,(double const &)*arg4);
17964   resultobj = SWIG_Py_Void();
17965   return resultobj;
17966 fail:
17967   return NULL;
17968 }
17969
17970
17971 SWIGINTERN PyObject *_wrap_VectorReal_insert(PyObject *self, PyObject *args) {
17972   Py_ssize_t argc;
17973   PyObject *argv[5] = {
17974     0
17975   };
17976   Py_ssize_t ii;
17977
17978   if (!PyTuple_Check(args)) SWIG_fail;
17979   argc = args ? PyObject_Length(args) : 0;
17980   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
17981     argv[ii] = PyTuple_GET_ITEM(args,ii);
17982   }
17983   if (argc == 3) {
17984     int _v;
17985     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
17986     _v = SWIG_CheckState(res);
17987     if (_v) {
17988       swig::SwigPyIterator *iter = 0;
17989       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
17990       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
17991       if (_v) {
17992         {
17993           int res = SWIG_AsVal_double(argv[2], NULL);
17994           _v = SWIG_CheckState(res);
17995         }
17996         if (_v) {
17997           return _wrap_VectorReal_insert__SWIG_0(self, args);
17998         }
17999       }
18000     }
18001   }
18002   if (argc == 4) {
18003     int _v;
18004     int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
18005     _v = SWIG_CheckState(res);
18006     if (_v) {
18007       swig::SwigPyIterator *iter = 0;
18008       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
18009       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
18010       if (_v) {
18011         {
18012           int res = SWIG_AsVal_size_t(argv[2], NULL);
18013           _v = SWIG_CheckState(res);
18014         }
18015         if (_v) {
18016           {
18017             int res = SWIG_AsVal_double(argv[3], NULL);
18018             _v = SWIG_CheckState(res);
18019           }
18020           if (_v) {
18021             return _wrap_VectorReal_insert__SWIG_1(self, args);
18022           }
18023         }
18024       }
18025     }
18026   }
18027
18028 fail:
18029   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorReal_insert'.\n"
18030     "  Possible C/C++ prototypes are:\n"
18031     "    std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
18032     "    std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
18033   return 0;
18034 }
18035
18036
18037 SWIGINTERN PyObject *_wrap_VectorReal_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18038   PyObject *resultobj = 0;
18039   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
18040   std::vector< double >::size_type arg2 ;
18041   void *argp1 = 0 ;
18042   int res1 = 0 ;
18043   size_t val2 ;
18044   int ecode2 = 0 ;
18045   PyObject * obj0 = 0 ;
18046   PyObject * obj1 = 0 ;
18047
18048   if (!PyArg_ParseTuple(args,(char *)"OO:VectorReal_reserve",&obj0,&obj1)) SWIG_fail;
18049   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
18050   if (!SWIG_IsOK(res1)) {
18051     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_reserve" "', argument " "1"" of type '" "std::vector< double > *""'");
18052   }
18053   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
18054   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
18055   if (!SWIG_IsOK(ecode2)) {
18056     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorReal_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
18057   }
18058   arg2 = static_cast< std::vector< double >::size_type >(val2);
18059   (arg1)->reserve(arg2);
18060   resultobj = SWIG_Py_Void();
18061   return resultobj;
18062 fail:
18063   return NULL;
18064 }
18065
18066
18067 SWIGINTERN PyObject *_wrap_VectorReal_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18068   PyObject *resultobj = 0;
18069   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
18070   void *argp1 = 0 ;
18071   int res1 = 0 ;
18072   PyObject * obj0 = 0 ;
18073   std::vector< double >::size_type result;
18074
18075   if (!PyArg_ParseTuple(args,(char *)"O:VectorReal_capacity",&obj0)) SWIG_fail;
18076   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
18077   if (!SWIG_IsOK(res1)) {
18078     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorReal_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'");
18079   }
18080   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
18081   result = ((std::vector< double > const *)arg1)->capacity();
18082   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18083   return resultobj;
18084 fail:
18085   return NULL;
18086 }
18087
18088
18089 SWIGINTERN PyObject *_wrap_delete_VectorReal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18090   PyObject *resultobj = 0;
18091   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
18092   void *argp1 = 0 ;
18093   int res1 = 0 ;
18094   PyObject * obj0 = 0 ;
18095
18096   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorReal",&obj0)) SWIG_fail;
18097   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_DISOWN |  0 );
18098   if (!SWIG_IsOK(res1)) {
18099     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorReal" "', argument " "1"" of type '" "std::vector< double > *""'");
18100   }
18101   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
18102   delete arg1;
18103   resultobj = SWIG_Py_Void();
18104   return resultobj;
18105 fail:
18106   return NULL;
18107 }
18108
18109
18110 SWIGINTERN PyObject *VectorReal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18111   PyObject *obj;
18112   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
18113   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_NewClientData(obj));
18114   return SWIG_Py_Void();
18115 }
18116
18117 SWIGINTERN PyObject *_wrap_VectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18118   PyObject *resultobj = 0;
18119   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18120   PyObject **arg2 = (PyObject **) 0 ;
18121   void *argp1 = 0 ;
18122   int res1 = 0 ;
18123   PyObject * obj0 = 0 ;
18124   swig::SwigPyIterator *result = 0 ;
18125
18126   arg2 = &obj0;
18127   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_iterator",&obj0)) SWIG_fail;
18128   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18129   if (!SWIG_IsOK(res1)) {
18130     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_iterator" "', argument " "1"" of type '" "std::vector< int > *""'");
18131   }
18132   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18133   result = (swig::SwigPyIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
18134   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
18135   return resultobj;
18136 fail:
18137   return NULL;
18138 }
18139
18140
18141 SWIGINTERN PyObject *_wrap_VectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18142   PyObject *resultobj = 0;
18143   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18144   void *argp1 = 0 ;
18145   int res1 = 0 ;
18146   PyObject * obj0 = 0 ;
18147   bool result;
18148
18149   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___nonzero__",&obj0)) SWIG_fail;
18150   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18151   if (!SWIG_IsOK(res1)) {
18152     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'");
18153   }
18154   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18155   result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1);
18156   resultobj = SWIG_From_bool(static_cast< bool >(result));
18157   return resultobj;
18158 fail:
18159   return NULL;
18160 }
18161
18162
18163 SWIGINTERN PyObject *_wrap_VectorInt___bool__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18164   PyObject *resultobj = 0;
18165   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18166   void *argp1 = 0 ;
18167   int res1 = 0 ;
18168   PyObject * obj0 = 0 ;
18169   bool result;
18170
18171   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___bool__",&obj0)) SWIG_fail;
18172   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18173   if (!SWIG_IsOK(res1)) {
18174     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'");
18175   }
18176   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18177   result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< int > const *)arg1);
18178   resultobj = SWIG_From_bool(static_cast< bool >(result));
18179   return resultobj;
18180 fail:
18181   return NULL;
18182 }
18183
18184
18185 SWIGINTERN PyObject *_wrap_VectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18186   PyObject *resultobj = 0;
18187   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18188   void *argp1 = 0 ;
18189   int res1 = 0 ;
18190   PyObject * obj0 = 0 ;
18191   std::vector< int >::size_type result;
18192
18193   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt___len__",&obj0)) SWIG_fail;
18194   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18195   if (!SWIG_IsOK(res1)) {
18196     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___len__" "', argument " "1"" of type '" "std::vector< int > const *""'");
18197   }
18198   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18199   result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1);
18200   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18201   return resultobj;
18202 fail:
18203   return NULL;
18204 }
18205
18206
18207 SWIGINTERN PyObject *_wrap_VectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18208   PyObject *resultobj = 0;
18209   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18210   std::vector< int >::difference_type arg2 ;
18211   std::vector< int >::difference_type arg3 ;
18212   void *argp1 = 0 ;
18213   int res1 = 0 ;
18214   ptrdiff_t val2 ;
18215   int ecode2 = 0 ;
18216   ptrdiff_t val3 ;
18217   int ecode3 = 0 ;
18218   PyObject * obj0 = 0 ;
18219   PyObject * obj1 = 0 ;
18220   PyObject * obj2 = 0 ;
18221   std::vector< int,std::allocator< int > > *result = 0 ;
18222
18223   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
18224   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18225   if (!SWIG_IsOK(res1)) {
18226     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
18227   }
18228   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18229   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18230   if (!SWIG_IsOK(ecode2)) {
18231     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18232   }
18233   arg2 = static_cast< std::vector< int >::difference_type >(val2);
18234   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
18235   if (!SWIG_IsOK(ecode3)) {
18236     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
18237   }
18238   arg3 = static_cast< std::vector< int >::difference_type >(val3);
18239   try {
18240     result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
18241   }
18242   catch(std::out_of_range &_e) {
18243     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18244   }
18245   catch(std::invalid_argument &_e) {
18246     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18247   }
18248
18249   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN |  0 );
18250   return resultobj;
18251 fail:
18252   return NULL;
18253 }
18254
18255
18256 SWIGINTERN PyObject *_wrap_VectorInt___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18257   PyObject *resultobj = 0;
18258   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18259   std::vector< int >::difference_type arg2 ;
18260   std::vector< int >::difference_type arg3 ;
18261   void *argp1 = 0 ;
18262   int res1 = 0 ;
18263   ptrdiff_t val2 ;
18264   int ecode2 = 0 ;
18265   ptrdiff_t val3 ;
18266   int ecode3 = 0 ;
18267   PyObject * obj0 = 0 ;
18268   PyObject * obj1 = 0 ;
18269   PyObject * obj2 = 0 ;
18270
18271   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
18272   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18273   if (!SWIG_IsOK(res1)) {
18274     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
18275   }
18276   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18277   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18278   if (!SWIG_IsOK(ecode2)) {
18279     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18280   }
18281   arg2 = static_cast< std::vector< int >::difference_type >(val2);
18282   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
18283   if (!SWIG_IsOK(ecode3)) {
18284     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
18285   }
18286   arg3 = static_cast< std::vector< int >::difference_type >(val3);
18287   try {
18288     std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3);
18289   }
18290   catch(std::out_of_range &_e) {
18291     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18292   }
18293   catch(std::invalid_argument &_e) {
18294     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18295   }
18296
18297   resultobj = SWIG_Py_Void();
18298   return resultobj;
18299 fail:
18300   return NULL;
18301 }
18302
18303
18304 SWIGINTERN PyObject *_wrap_VectorInt___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18305   PyObject *resultobj = 0;
18306   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18307   std::vector< int >::difference_type arg2 ;
18308   std::vector< int >::difference_type arg3 ;
18309   std::vector< int,std::allocator< int > > *arg4 = 0 ;
18310   void *argp1 = 0 ;
18311   int res1 = 0 ;
18312   ptrdiff_t val2 ;
18313   int ecode2 = 0 ;
18314   ptrdiff_t val3 ;
18315   int ecode3 = 0 ;
18316   int res4 = SWIG_OLDOBJ ;
18317   PyObject * obj0 = 0 ;
18318   PyObject * obj1 = 0 ;
18319   PyObject * obj2 = 0 ;
18320   PyObject * obj3 = 0 ;
18321
18322   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18323   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18324   if (!SWIG_IsOK(res1)) {
18325     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
18326   }
18327   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18328   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18329   if (!SWIG_IsOK(ecode2)) {
18330     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18331   }
18332   arg2 = static_cast< std::vector< int >::difference_type >(val2);
18333   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
18334   if (!SWIG_IsOK(ecode3)) {
18335     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
18336   }
18337   arg3 = static_cast< std::vector< int >::difference_type >(val3);
18338   {
18339     std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
18340     res4 = swig::asptr(obj3, &ptr);
18341     if (!SWIG_IsOK(res4)) {
18342       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
18343     }
18344     if (!ptr) {
18345       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'");
18346     }
18347     arg4 = ptr;
18348   }
18349   try {
18350     std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
18351   }
18352   catch(std::out_of_range &_e) {
18353     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18354   }
18355   catch(std::invalid_argument &_e) {
18356     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18357   }
18358
18359   resultobj = SWIG_Py_Void();
18360   if (SWIG_IsNewObj(res4)) delete arg4;
18361   return resultobj;
18362 fail:
18363   if (SWIG_IsNewObj(res4)) delete arg4;
18364   return NULL;
18365 }
18366
18367
18368 SWIGINTERN PyObject *_wrap_VectorInt___setslice__(PyObject *self, PyObject *args) {
18369   Py_ssize_t argc;
18370   PyObject *argv[5] = {
18371     0
18372   };
18373   Py_ssize_t ii;
18374
18375   if (!PyTuple_Check(args)) SWIG_fail;
18376   argc = args ? PyObject_Length(args) : 0;
18377   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
18378     argv[ii] = PyTuple_GET_ITEM(args,ii);
18379   }
18380   if (argc == 3) {
18381     int _v;
18382     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18383     _v = SWIG_CheckState(res);
18384     if (_v) {
18385       {
18386         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
18387         _v = SWIG_CheckState(res);
18388       }
18389       if (_v) {
18390         {
18391           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
18392           _v = SWIG_CheckState(res);
18393         }
18394         if (_v) {
18395           return _wrap_VectorInt___setslice____SWIG_0(self, args);
18396         }
18397       }
18398     }
18399   }
18400   if (argc == 4) {
18401     int _v;
18402     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18403     _v = SWIG_CheckState(res);
18404     if (_v) {
18405       {
18406         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
18407         _v = SWIG_CheckState(res);
18408       }
18409       if (_v) {
18410         {
18411           int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
18412           _v = SWIG_CheckState(res);
18413         }
18414         if (_v) {
18415           int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
18416           _v = SWIG_CheckState(res);
18417           if (_v) {
18418             return _wrap_VectorInt___setslice____SWIG_1(self, args);
18419           }
18420         }
18421       }
18422     }
18423   }
18424
18425 fail:
18426   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___setslice__'.\n"
18427     "  Possible C/C++ prototypes are:\n"
18428     "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n"
18429     "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n");
18430   return 0;
18431 }
18432
18433
18434 SWIGINTERN PyObject *_wrap_VectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18435   PyObject *resultobj = 0;
18436   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18437   std::vector< int >::difference_type arg2 ;
18438   std::vector< int >::difference_type arg3 ;
18439   void *argp1 = 0 ;
18440   int res1 = 0 ;
18441   ptrdiff_t val2 ;
18442   int ecode2 = 0 ;
18443   ptrdiff_t val3 ;
18444   int ecode3 = 0 ;
18445   PyObject * obj0 = 0 ;
18446   PyObject * obj1 = 0 ;
18447   PyObject * obj2 = 0 ;
18448
18449   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
18450   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18451   if (!SWIG_IsOK(res1)) {
18452     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'");
18453   }
18454   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18455   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18456   if (!SWIG_IsOK(ecode2)) {
18457     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18458   }
18459   arg2 = static_cast< std::vector< int >::difference_type >(val2);
18460   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
18461   if (!SWIG_IsOK(ecode3)) {
18462     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
18463   }
18464   arg3 = static_cast< std::vector< int >::difference_type >(val3);
18465   try {
18466     std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
18467   }
18468   catch(std::out_of_range &_e) {
18469     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18470   }
18471   catch(std::invalid_argument &_e) {
18472     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18473   }
18474
18475   resultobj = SWIG_Py_Void();
18476   return resultobj;
18477 fail:
18478   return NULL;
18479 }
18480
18481
18482 SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18483   PyObject *resultobj = 0;
18484   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18485   std::vector< int >::difference_type arg2 ;
18486   void *argp1 = 0 ;
18487   int res1 = 0 ;
18488   ptrdiff_t val2 ;
18489   int ecode2 = 0 ;
18490   PyObject * obj0 = 0 ;
18491   PyObject * obj1 = 0 ;
18492
18493   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
18494   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18495   if (!SWIG_IsOK(res1)) {
18496     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18497   }
18498   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18499   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18500   if (!SWIG_IsOK(ecode2)) {
18501     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18502   }
18503   arg2 = static_cast< std::vector< int >::difference_type >(val2);
18504   try {
18505     std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,arg2);
18506   }
18507   catch(std::out_of_range &_e) {
18508     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18509   }
18510   catch(std::invalid_argument &_e) {
18511     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18512   }
18513
18514   resultobj = SWIG_Py_Void();
18515   return resultobj;
18516 fail:
18517   return NULL;
18518 }
18519
18520
18521 SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18522   PyObject *resultobj = 0;
18523   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18524   PySliceObject *arg2 = (PySliceObject *) 0 ;
18525   void *argp1 = 0 ;
18526   int res1 = 0 ;
18527   PyObject * obj0 = 0 ;
18528   PyObject * obj1 = 0 ;
18529   std::vector< int,std::allocator< int > > *result = 0 ;
18530
18531   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
18532   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18533   if (!SWIG_IsOK(res1)) {
18534     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18535   }
18536   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18537   {
18538     if (!PySlice_Check(obj1)) {
18539       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
18540     }
18541     arg2 = (PySliceObject *) obj1;
18542   }
18543   try {
18544     result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
18545   }
18546   catch(std::out_of_range &_e) {
18547     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18548   }
18549   catch(std::invalid_argument &_e) {
18550     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18551   }
18552
18553   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN |  0 );
18554   return resultobj;
18555 fail:
18556   return NULL;
18557 }
18558
18559
18560 SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18561   PyObject *resultobj = 0;
18562   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18563   PySliceObject *arg2 = (PySliceObject *) 0 ;
18564   std::vector< int,std::allocator< int > > *arg3 = 0 ;
18565   void *argp1 = 0 ;
18566   int res1 = 0 ;
18567   int res3 = SWIG_OLDOBJ ;
18568   PyObject * obj0 = 0 ;
18569   PyObject * obj1 = 0 ;
18570   PyObject * obj2 = 0 ;
18571
18572   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
18573   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18574   if (!SWIG_IsOK(res1)) {
18575     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18576   }
18577   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18578   {
18579     if (!PySlice_Check(obj1)) {
18580       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
18581     }
18582     arg2 = (PySliceObject *) obj1;
18583   }
18584   {
18585     std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
18586     res3 = swig::asptr(obj2, &ptr);
18587     if (!SWIG_IsOK(res3)) {
18588       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'");
18589     }
18590     if (!ptr) {
18591       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'");
18592     }
18593     arg3 = ptr;
18594   }
18595   try {
18596     std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
18597   }
18598   catch(std::out_of_range &_e) {
18599     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18600   }
18601   catch(std::invalid_argument &_e) {
18602     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18603   }
18604
18605   resultobj = SWIG_Py_Void();
18606   if (SWIG_IsNewObj(res3)) delete arg3;
18607   return resultobj;
18608 fail:
18609   if (SWIG_IsNewObj(res3)) delete arg3;
18610   return NULL;
18611 }
18612
18613
18614 SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18615   PyObject *resultobj = 0;
18616   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18617   PySliceObject *arg2 = (PySliceObject *) 0 ;
18618   void *argp1 = 0 ;
18619   int res1 = 0 ;
18620   PyObject * obj0 = 0 ;
18621   PyObject * obj1 = 0 ;
18622
18623   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___setitem__",&obj0,&obj1)) SWIG_fail;
18624   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18625   if (!SWIG_IsOK(res1)) {
18626     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18627   }
18628   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18629   {
18630     if (!PySlice_Check(obj1)) {
18631       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
18632     }
18633     arg2 = (PySliceObject *) obj1;
18634   }
18635   try {
18636     std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
18637   }
18638   catch(std::out_of_range &_e) {
18639     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18640   }
18641   catch(std::invalid_argument &_e) {
18642     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18643   }
18644
18645   resultobj = SWIG_Py_Void();
18646   return resultobj;
18647 fail:
18648   return NULL;
18649 }
18650
18651
18652 SWIGINTERN PyObject *_wrap_VectorInt___delitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18653   PyObject *resultobj = 0;
18654   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18655   PySliceObject *arg2 = (PySliceObject *) 0 ;
18656   void *argp1 = 0 ;
18657   int res1 = 0 ;
18658   PyObject * obj0 = 0 ;
18659   PyObject * obj1 = 0 ;
18660
18661   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
18662   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18663   if (!SWIG_IsOK(res1)) {
18664     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18665   }
18666   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18667   {
18668     if (!PySlice_Check(obj1)) {
18669       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
18670     }
18671     arg2 = (PySliceObject *) obj1;
18672   }
18673   try {
18674     std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
18675   }
18676   catch(std::out_of_range &_e) {
18677     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18678   }
18679   catch(std::invalid_argument &_e) {
18680     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
18681   }
18682
18683   resultobj = SWIG_Py_Void();
18684   return resultobj;
18685 fail:
18686   return NULL;
18687 }
18688
18689
18690 SWIGINTERN PyObject *_wrap_VectorInt___delitem__(PyObject *self, PyObject *args) {
18691   Py_ssize_t argc;
18692   PyObject *argv[3] = {
18693     0
18694   };
18695   Py_ssize_t ii;
18696
18697   if (!PyTuple_Check(args)) SWIG_fail;
18698   argc = args ? PyObject_Length(args) : 0;
18699   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
18700     argv[ii] = PyTuple_GET_ITEM(args,ii);
18701   }
18702   if (argc == 2) {
18703     int _v;
18704     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18705     _v = SWIG_CheckState(res);
18706     if (_v) {
18707       {
18708         _v = PySlice_Check(argv[1]);
18709       }
18710       if (_v) {
18711         return _wrap_VectorInt___delitem____SWIG_1(self, args);
18712       }
18713     }
18714   }
18715   if (argc == 2) {
18716     int _v;
18717     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18718     _v = SWIG_CheckState(res);
18719     if (_v) {
18720       {
18721         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
18722         _v = SWIG_CheckState(res);
18723       }
18724       if (_v) {
18725         return _wrap_VectorInt___delitem____SWIG_0(self, args);
18726       }
18727     }
18728   }
18729
18730 fail:
18731   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___delitem__'.\n"
18732     "  Possible C/C++ prototypes are:\n"
18733     "    std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
18734     "    std::vector< int >::__delitem__(PySliceObject *)\n");
18735   return 0;
18736 }
18737
18738
18739 SWIGINTERN PyObject *_wrap_VectorInt___getitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18740   PyObject *resultobj = 0;
18741   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18742   std::vector< int >::difference_type arg2 ;
18743   void *argp1 = 0 ;
18744   int res1 = 0 ;
18745   ptrdiff_t val2 ;
18746   int ecode2 = 0 ;
18747   PyObject * obj0 = 0 ;
18748   PyObject * obj1 = 0 ;
18749   std::vector< int >::value_type *result = 0 ;
18750
18751   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
18752   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18753   if (!SWIG_IsOK(res1)) {
18754     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'");
18755   }
18756   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18757   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18758   if (!SWIG_IsOK(ecode2)) {
18759     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18760   }
18761   arg2 = static_cast< std::vector< int >::difference_type >(val2);
18762   try {
18763     result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,arg2);
18764   }
18765   catch(std::out_of_range &_e) {
18766     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18767   }
18768
18769   resultobj = SWIG_From_int(static_cast< int >(*result));
18770   return resultobj;
18771 fail:
18772   return NULL;
18773 }
18774
18775
18776 SWIGINTERN PyObject *_wrap_VectorInt___getitem__(PyObject *self, PyObject *args) {
18777   Py_ssize_t argc;
18778   PyObject *argv[3] = {
18779     0
18780   };
18781   Py_ssize_t ii;
18782
18783   if (!PyTuple_Check(args)) SWIG_fail;
18784   argc = args ? PyObject_Length(args) : 0;
18785   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
18786     argv[ii] = PyTuple_GET_ITEM(args,ii);
18787   }
18788   if (argc == 2) {
18789     int _v;
18790     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18791     _v = SWIG_CheckState(res);
18792     if (_v) {
18793       {
18794         _v = PySlice_Check(argv[1]);
18795       }
18796       if (_v) {
18797         return _wrap_VectorInt___getitem____SWIG_0(self, args);
18798       }
18799     }
18800   }
18801   if (argc == 2) {
18802     int _v;
18803     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18804     _v = SWIG_CheckState(res);
18805     if (_v) {
18806       {
18807         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
18808         _v = SWIG_CheckState(res);
18809       }
18810       if (_v) {
18811         return _wrap_VectorInt___getitem____SWIG_1(self, args);
18812       }
18813     }
18814   }
18815
18816 fail:
18817   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___getitem__'.\n"
18818     "  Possible C/C++ prototypes are:\n"
18819     "    std::vector< int >::__getitem__(PySliceObject *)\n"
18820     "    std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
18821   return 0;
18822 }
18823
18824
18825 SWIGINTERN PyObject *_wrap_VectorInt___setitem____SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18826   PyObject *resultobj = 0;
18827   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18828   std::vector< int >::difference_type arg2 ;
18829   std::vector< int >::value_type *arg3 = 0 ;
18830   void *argp1 = 0 ;
18831   int res1 = 0 ;
18832   ptrdiff_t val2 ;
18833   int ecode2 = 0 ;
18834   std::vector< int >::value_type temp3 ;
18835   int val3 ;
18836   int ecode3 = 0 ;
18837   PyObject * obj0 = 0 ;
18838   PyObject * obj1 = 0 ;
18839   PyObject * obj2 = 0 ;
18840
18841   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
18842   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18843   if (!SWIG_IsOK(res1)) {
18844     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'");
18845   }
18846   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18847   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
18848   if (!SWIG_IsOK(ecode2)) {
18849     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
18850   }
18851   arg2 = static_cast< std::vector< int >::difference_type >(val2);
18852   ecode3 = SWIG_AsVal_int(obj2, &val3);
18853   if (!SWIG_IsOK(ecode3)) {
18854     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
18855   }
18856   temp3 = static_cast< std::vector< int >::value_type >(val3);
18857   arg3 = &temp3;
18858   try {
18859     std_vector_Sl_int_Sg____setitem____SWIG_2(arg1,arg2,(int const &)*arg3);
18860   }
18861   catch(std::out_of_range &_e) {
18862     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18863   }
18864
18865   resultobj = SWIG_Py_Void();
18866   return resultobj;
18867 fail:
18868   return NULL;
18869 }
18870
18871
18872 SWIGINTERN PyObject *_wrap_VectorInt___setitem__(PyObject *self, PyObject *args) {
18873   Py_ssize_t argc;
18874   PyObject *argv[4] = {
18875     0
18876   };
18877   Py_ssize_t ii;
18878
18879   if (!PyTuple_Check(args)) SWIG_fail;
18880   argc = args ? PyObject_Length(args) : 0;
18881   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
18882     argv[ii] = PyTuple_GET_ITEM(args,ii);
18883   }
18884   if (argc == 2) {
18885     int _v;
18886     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18887     _v = SWIG_CheckState(res);
18888     if (_v) {
18889       {
18890         _v = PySlice_Check(argv[1]);
18891       }
18892       if (_v) {
18893         return _wrap_VectorInt___setitem____SWIG_1(self, args);
18894       }
18895     }
18896   }
18897   if (argc == 3) {
18898     int _v;
18899     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18900     _v = SWIG_CheckState(res);
18901     if (_v) {
18902       {
18903         _v = PySlice_Check(argv[1]);
18904       }
18905       if (_v) {
18906         int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
18907         _v = SWIG_CheckState(res);
18908         if (_v) {
18909           return _wrap_VectorInt___setitem____SWIG_0(self, args);
18910         }
18911       }
18912     }
18913   }
18914   if (argc == 3) {
18915     int _v;
18916     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
18917     _v = SWIG_CheckState(res);
18918     if (_v) {
18919       {
18920         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
18921         _v = SWIG_CheckState(res);
18922       }
18923       if (_v) {
18924         {
18925           int res = SWIG_AsVal_int(argv[2], NULL);
18926           _v = SWIG_CheckState(res);
18927         }
18928         if (_v) {
18929           return _wrap_VectorInt___setitem____SWIG_2(self, args);
18930         }
18931       }
18932     }
18933   }
18934
18935 fail:
18936   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt___setitem__'.\n"
18937     "  Possible C/C++ prototypes are:\n"
18938     "    std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
18939     "    std::vector< int >::__setitem__(PySliceObject *)\n"
18940     "    std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
18941   return 0;
18942 }
18943
18944
18945 SWIGINTERN PyObject *_wrap_VectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18946   PyObject *resultobj = 0;
18947   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18948   void *argp1 = 0 ;
18949   int res1 = 0 ;
18950   PyObject * obj0 = 0 ;
18951   std::vector< int >::value_type result;
18952
18953   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop",&obj0)) SWIG_fail;
18954   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18955   if (!SWIG_IsOK(res1)) {
18956     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop" "', argument " "1"" of type '" "std::vector< int > *""'");
18957   }
18958   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18959   try {
18960     result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
18961   }
18962   catch(std::out_of_range &_e) {
18963     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
18964   }
18965
18966   resultobj = SWIG_From_int(static_cast< int >(result));
18967   return resultobj;
18968 fail:
18969   return NULL;
18970 }
18971
18972
18973 SWIGINTERN PyObject *_wrap_VectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18974   PyObject *resultobj = 0;
18975   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
18976   std::vector< int >::value_type *arg2 = 0 ;
18977   void *argp1 = 0 ;
18978   int res1 = 0 ;
18979   std::vector< int >::value_type temp2 ;
18980   int val2 ;
18981   int ecode2 = 0 ;
18982   PyObject * obj0 = 0 ;
18983   PyObject * obj1 = 0 ;
18984
18985   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_append",&obj0,&obj1)) SWIG_fail;
18986   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
18987   if (!SWIG_IsOK(res1)) {
18988     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_append" "', argument " "1"" of type '" "std::vector< int > *""'");
18989   }
18990   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
18991   ecode2 = SWIG_AsVal_int(obj1, &val2);
18992   if (!SWIG_IsOK(ecode2)) {
18993     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
18994   }
18995   temp2 = static_cast< std::vector< int >::value_type >(val2);
18996   arg2 = &temp2;
18997   std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
18998   resultobj = SWIG_Py_Void();
18999   return resultobj;
19000 fail:
19001   return NULL;
19002 }
19003
19004
19005 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19006   PyObject *resultobj = 0;
19007   std::vector< int > *result = 0 ;
19008
19009   if (!PyArg_ParseTuple(args,(char *)":new_VectorInt")) SWIG_fail;
19010   result = (std::vector< int > *)new std::vector< int >();
19011   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
19012   return resultobj;
19013 fail:
19014   return NULL;
19015 }
19016
19017
19018 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19019   PyObject *resultobj = 0;
19020   std::vector< int > *arg1 = 0 ;
19021   int res1 = SWIG_OLDOBJ ;
19022   PyObject * obj0 = 0 ;
19023   std::vector< int > *result = 0 ;
19024
19025   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
19026   {
19027     std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
19028     res1 = swig::asptr(obj0, &ptr);
19029     if (!SWIG_IsOK(res1)) {
19030       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'");
19031     }
19032     if (!ptr) {
19033       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'");
19034     }
19035     arg1 = ptr;
19036   }
19037   result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
19038   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
19039   if (SWIG_IsNewObj(res1)) delete arg1;
19040   return resultobj;
19041 fail:
19042   if (SWIG_IsNewObj(res1)) delete arg1;
19043   return NULL;
19044 }
19045
19046
19047 SWIGINTERN PyObject *_wrap_VectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19048   PyObject *resultobj = 0;
19049   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19050   void *argp1 = 0 ;
19051   int res1 = 0 ;
19052   PyObject * obj0 = 0 ;
19053   bool result;
19054
19055   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_empty",&obj0)) SWIG_fail;
19056   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19057   if (!SWIG_IsOK(res1)) {
19058     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_empty" "', argument " "1"" of type '" "std::vector< int > const *""'");
19059   }
19060   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19061   result = (bool)((std::vector< int > const *)arg1)->empty();
19062   resultobj = SWIG_From_bool(static_cast< bool >(result));
19063   return resultobj;
19064 fail:
19065   return NULL;
19066 }
19067
19068
19069 SWIGINTERN PyObject *_wrap_VectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19070   PyObject *resultobj = 0;
19071   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19072   void *argp1 = 0 ;
19073   int res1 = 0 ;
19074   PyObject * obj0 = 0 ;
19075   std::vector< int >::size_type result;
19076
19077   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_size",&obj0)) SWIG_fail;
19078   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19079   if (!SWIG_IsOK(res1)) {
19080     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_size" "', argument " "1"" of type '" "std::vector< int > const *""'");
19081   }
19082   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19083   result = ((std::vector< int > const *)arg1)->size();
19084   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19085   return resultobj;
19086 fail:
19087   return NULL;
19088 }
19089
19090
19091 SWIGINTERN PyObject *_wrap_VectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19092   PyObject *resultobj = 0;
19093   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19094   std::vector< int > *arg2 = 0 ;
19095   void *argp1 = 0 ;
19096   int res1 = 0 ;
19097   void *argp2 = 0 ;
19098   int res2 = 0 ;
19099   PyObject * obj0 = 0 ;
19100   PyObject * obj1 = 0 ;
19101
19102   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_swap",&obj0,&obj1)) SWIG_fail;
19103   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19104   if (!SWIG_IsOK(res1)) {
19105     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_swap" "', argument " "1"" of type '" "std::vector< int > *""'");
19106   }
19107   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19108   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
19109   if (!SWIG_IsOK(res2)) {
19110     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
19111   }
19112   if (!argp2) {
19113     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'");
19114   }
19115   arg2 = reinterpret_cast< std::vector< int > * >(argp2);
19116   (arg1)->swap(*arg2);
19117   resultobj = SWIG_Py_Void();
19118   return resultobj;
19119 fail:
19120   return NULL;
19121 }
19122
19123
19124 SWIGINTERN PyObject *_wrap_VectorInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19125   PyObject *resultobj = 0;
19126   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19127   void *argp1 = 0 ;
19128   int res1 = 0 ;
19129   PyObject * obj0 = 0 ;
19130   std::vector< int >::iterator result;
19131
19132   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_begin",&obj0)) SWIG_fail;
19133   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19134   if (!SWIG_IsOK(res1)) {
19135     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_begin" "', argument " "1"" of type '" "std::vector< int > *""'");
19136   }
19137   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19138   result = (arg1)->begin();
19139   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
19140     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19141   return resultobj;
19142 fail:
19143   return NULL;
19144 }
19145
19146
19147 SWIGINTERN PyObject *_wrap_VectorInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19148   PyObject *resultobj = 0;
19149   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19150   void *argp1 = 0 ;
19151   int res1 = 0 ;
19152   PyObject * obj0 = 0 ;
19153   std::vector< int >::iterator result;
19154
19155   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_end",&obj0)) SWIG_fail;
19156   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19157   if (!SWIG_IsOK(res1)) {
19158     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_end" "', argument " "1"" of type '" "std::vector< int > *""'");
19159   }
19160   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19161   result = (arg1)->end();
19162   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
19163     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19164   return resultobj;
19165 fail:
19166   return NULL;
19167 }
19168
19169
19170 SWIGINTERN PyObject *_wrap_VectorInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19171   PyObject *resultobj = 0;
19172   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19173   void *argp1 = 0 ;
19174   int res1 = 0 ;
19175   PyObject * obj0 = 0 ;
19176   std::vector< int >::reverse_iterator result;
19177
19178   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rbegin",&obj0)) SWIG_fail;
19179   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19180   if (!SWIG_IsOK(res1)) {
19181     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rbegin" "', argument " "1"" of type '" "std::vector< int > *""'");
19182   }
19183   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19184   result = (arg1)->rbegin();
19185   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
19186     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19187   return resultobj;
19188 fail:
19189   return NULL;
19190 }
19191
19192
19193 SWIGINTERN PyObject *_wrap_VectorInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19194   PyObject *resultobj = 0;
19195   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19196   void *argp1 = 0 ;
19197   int res1 = 0 ;
19198   PyObject * obj0 = 0 ;
19199   std::vector< int >::reverse_iterator result;
19200
19201   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_rend",&obj0)) SWIG_fail;
19202   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19203   if (!SWIG_IsOK(res1)) {
19204     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_rend" "', argument " "1"" of type '" "std::vector< int > *""'");
19205   }
19206   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19207   result = (arg1)->rend();
19208   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
19209     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19210   return resultobj;
19211 fail:
19212   return NULL;
19213 }
19214
19215
19216 SWIGINTERN PyObject *_wrap_VectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19217   PyObject *resultobj = 0;
19218   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19219   void *argp1 = 0 ;
19220   int res1 = 0 ;
19221   PyObject * obj0 = 0 ;
19222
19223   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_clear",&obj0)) SWIG_fail;
19224   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19225   if (!SWIG_IsOK(res1)) {
19226     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_clear" "', argument " "1"" of type '" "std::vector< int > *""'");
19227   }
19228   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19229   (arg1)->clear();
19230   resultobj = SWIG_Py_Void();
19231   return resultobj;
19232 fail:
19233   return NULL;
19234 }
19235
19236
19237 SWIGINTERN PyObject *_wrap_VectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19238   PyObject *resultobj = 0;
19239   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19240   void *argp1 = 0 ;
19241   int res1 = 0 ;
19242   PyObject * obj0 = 0 ;
19243   SwigValueWrapper< std::allocator< int > > result;
19244
19245   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_get_allocator",&obj0)) SWIG_fail;
19246   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19247   if (!SWIG_IsOK(res1)) {
19248     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'");
19249   }
19250   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19251   result = ((std::vector< int > const *)arg1)->get_allocator();
19252   resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
19253   return resultobj;
19254 fail:
19255   return NULL;
19256 }
19257
19258
19259 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19260   PyObject *resultobj = 0;
19261   std::vector< int >::size_type arg1 ;
19262   size_t val1 ;
19263   int ecode1 = 0 ;
19264   PyObject * obj0 = 0 ;
19265   std::vector< int > *result = 0 ;
19266
19267   if (!PyArg_ParseTuple(args,(char *)"O:new_VectorInt",&obj0)) SWIG_fail;
19268   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
19269   if (!SWIG_IsOK(ecode1)) {
19270     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
19271   }
19272   arg1 = static_cast< std::vector< int >::size_type >(val1);
19273   result = (std::vector< int > *)new std::vector< int >(arg1);
19274   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
19275   return resultobj;
19276 fail:
19277   return NULL;
19278 }
19279
19280
19281 SWIGINTERN PyObject *_wrap_VectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19282   PyObject *resultobj = 0;
19283   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19284   void *argp1 = 0 ;
19285   int res1 = 0 ;
19286   PyObject * obj0 = 0 ;
19287
19288   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_pop_back",&obj0)) SWIG_fail;
19289   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19290   if (!SWIG_IsOK(res1)) {
19291     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'");
19292   }
19293   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19294   (arg1)->pop_back();
19295   resultobj = SWIG_Py_Void();
19296   return resultobj;
19297 fail:
19298   return NULL;
19299 }
19300
19301
19302 SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19303   PyObject *resultobj = 0;
19304   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19305   std::vector< int >::size_type arg2 ;
19306   void *argp1 = 0 ;
19307   int res1 = 0 ;
19308   size_t val2 ;
19309   int ecode2 = 0 ;
19310   PyObject * obj0 = 0 ;
19311   PyObject * obj1 = 0 ;
19312
19313   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_resize",&obj0,&obj1)) SWIG_fail;
19314   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19315   if (!SWIG_IsOK(res1)) {
19316     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
19317   }
19318   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19319   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19320   if (!SWIG_IsOK(ecode2)) {
19321     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
19322   }
19323   arg2 = static_cast< std::vector< int >::size_type >(val2);
19324   (arg1)->resize(arg2);
19325   resultobj = SWIG_Py_Void();
19326   return resultobj;
19327 fail:
19328   return NULL;
19329 }
19330
19331
19332 SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19333   PyObject *resultobj = 0;
19334   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19335   std::vector< int >::iterator arg2 ;
19336   void *argp1 = 0 ;
19337   int res1 = 0 ;
19338   swig::SwigPyIterator *iter2 = 0 ;
19339   int res2 ;
19340   PyObject * obj0 = 0 ;
19341   PyObject * obj1 = 0 ;
19342   std::vector< int >::iterator result;
19343
19344   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_erase",&obj0,&obj1)) SWIG_fail;
19345   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19346   if (!SWIG_IsOK(res1)) {
19347     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
19348   }
19349   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19350   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
19351   if (!SWIG_IsOK(res2) || !iter2) {
19352     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19353   } else {
19354     swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
19355     if (iter_t) {
19356       arg2 = iter_t->get_current();
19357     } else {
19358       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19359     }
19360   }
19361   result = std_vector_Sl_int_Sg__erase__SWIG_0(arg1,arg2);
19362   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
19363     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19364   return resultobj;
19365 fail:
19366   return NULL;
19367 }
19368
19369
19370 SWIGINTERN PyObject *_wrap_VectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19371   PyObject *resultobj = 0;
19372   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19373   std::vector< int >::iterator arg2 ;
19374   std::vector< int >::iterator arg3 ;
19375   void *argp1 = 0 ;
19376   int res1 = 0 ;
19377   swig::SwigPyIterator *iter2 = 0 ;
19378   int res2 ;
19379   swig::SwigPyIterator *iter3 = 0 ;
19380   int res3 ;
19381   PyObject * obj0 = 0 ;
19382   PyObject * obj1 = 0 ;
19383   PyObject * obj2 = 0 ;
19384   std::vector< int >::iterator result;
19385
19386   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
19387   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19388   if (!SWIG_IsOK(res1)) {
19389     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'");
19390   }
19391   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19392   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
19393   if (!SWIG_IsOK(res2) || !iter2) {
19394     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19395   } else {
19396     swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
19397     if (iter_t) {
19398       arg2 = iter_t->get_current();
19399     } else {
19400       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19401     }
19402   }
19403   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
19404   if (!SWIG_IsOK(res3) || !iter3) {
19405     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
19406   } else {
19407     swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter3);
19408     if (iter_t) {
19409       arg3 = iter_t->get_current();
19410     } else {
19411       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
19412     }
19413   }
19414   result = std_vector_Sl_int_Sg__erase__SWIG_1(arg1,arg2,arg3);
19415   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
19416     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19417   return resultobj;
19418 fail:
19419   return NULL;
19420 }
19421
19422
19423 SWIGINTERN PyObject *_wrap_VectorInt_erase(PyObject *self, PyObject *args) {
19424   Py_ssize_t argc;
19425   PyObject *argv[4] = {
19426     0
19427   };
19428   Py_ssize_t ii;
19429
19430   if (!PyTuple_Check(args)) SWIG_fail;
19431   argc = args ? PyObject_Length(args) : 0;
19432   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
19433     argv[ii] = PyTuple_GET_ITEM(args,ii);
19434   }
19435   if (argc == 2) {
19436     int _v;
19437     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19438     _v = SWIG_CheckState(res);
19439     if (_v) {
19440       swig::SwigPyIterator *iter = 0;
19441       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
19442       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
19443       if (_v) {
19444         return _wrap_VectorInt_erase__SWIG_0(self, args);
19445       }
19446     }
19447   }
19448   if (argc == 3) {
19449     int _v;
19450     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19451     _v = SWIG_CheckState(res);
19452     if (_v) {
19453       swig::SwigPyIterator *iter = 0;
19454       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
19455       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
19456       if (_v) {
19457         swig::SwigPyIterator *iter = 0;
19458         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
19459         _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
19460         if (_v) {
19461           return _wrap_VectorInt_erase__SWIG_1(self, args);
19462         }
19463       }
19464     }
19465   }
19466
19467 fail:
19468   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_erase'.\n"
19469     "  Possible C/C++ prototypes are:\n"
19470     "    std::vector< int >::erase(std::vector< int >::iterator)\n"
19471     "    std::vector< int >::erase(std::vector< int >::iterator,std::vector< int >::iterator)\n");
19472   return 0;
19473 }
19474
19475
19476 SWIGINTERN PyObject *_wrap_new_VectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19477   PyObject *resultobj = 0;
19478   std::vector< int >::size_type arg1 ;
19479   std::vector< int >::value_type *arg2 = 0 ;
19480   size_t val1 ;
19481   int ecode1 = 0 ;
19482   std::vector< int >::value_type temp2 ;
19483   int val2 ;
19484   int ecode2 = 0 ;
19485   PyObject * obj0 = 0 ;
19486   PyObject * obj1 = 0 ;
19487   std::vector< int > *result = 0 ;
19488
19489   if (!PyArg_ParseTuple(args,(char *)"OO:new_VectorInt",&obj0,&obj1)) SWIG_fail;
19490   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
19491   if (!SWIG_IsOK(ecode1)) {
19492     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
19493   }
19494   arg1 = static_cast< std::vector< int >::size_type >(val1);
19495   ecode2 = SWIG_AsVal_int(obj1, &val2);
19496   if (!SWIG_IsOK(ecode2)) {
19497     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorInt" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
19498   }
19499   temp2 = static_cast< std::vector< int >::value_type >(val2);
19500   arg2 = &temp2;
19501   result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2);
19502   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
19503   return resultobj;
19504 fail:
19505   return NULL;
19506 }
19507
19508
19509 SWIGINTERN PyObject *_wrap_new_VectorInt(PyObject *self, PyObject *args) {
19510   Py_ssize_t argc;
19511   PyObject *argv[3] = {
19512     0
19513   };
19514   Py_ssize_t ii;
19515
19516   if (!PyTuple_Check(args)) SWIG_fail;
19517   argc = args ? PyObject_Length(args) : 0;
19518   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
19519     argv[ii] = PyTuple_GET_ITEM(args,ii);
19520   }
19521   if (argc == 0) {
19522     return _wrap_new_VectorInt__SWIG_0(self, args);
19523   }
19524   if (argc == 1) {
19525     int _v;
19526     {
19527       int res = SWIG_AsVal_size_t(argv[0], NULL);
19528       _v = SWIG_CheckState(res);
19529     }
19530     if (_v) {
19531       return _wrap_new_VectorInt__SWIG_2(self, args);
19532     }
19533   }
19534   if (argc == 1) {
19535     int _v;
19536     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19537     _v = SWIG_CheckState(res);
19538     if (_v) {
19539       return _wrap_new_VectorInt__SWIG_1(self, args);
19540     }
19541   }
19542   if (argc == 2) {
19543     int _v;
19544     {
19545       int res = SWIG_AsVal_size_t(argv[0], NULL);
19546       _v = SWIG_CheckState(res);
19547     }
19548     if (_v) {
19549       {
19550         int res = SWIG_AsVal_int(argv[1], NULL);
19551         _v = SWIG_CheckState(res);
19552       }
19553       if (_v) {
19554         return _wrap_new_VectorInt__SWIG_3(self, args);
19555       }
19556     }
19557   }
19558
19559 fail:
19560   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VectorInt'.\n"
19561     "  Possible C/C++ prototypes are:\n"
19562     "    std::vector< int >::vector()\n"
19563     "    std::vector< int >::vector(std::vector< int > const &)\n"
19564     "    std::vector< int >::vector(std::vector< int >::size_type)\n"
19565     "    std::vector< int >::vector(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
19566   return 0;
19567 }
19568
19569
19570 SWIGINTERN PyObject *_wrap_VectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19571   PyObject *resultobj = 0;
19572   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19573   std::vector< int >::value_type *arg2 = 0 ;
19574   void *argp1 = 0 ;
19575   int res1 = 0 ;
19576   std::vector< int >::value_type temp2 ;
19577   int val2 ;
19578   int ecode2 = 0 ;
19579   PyObject * obj0 = 0 ;
19580   PyObject * obj1 = 0 ;
19581
19582   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_push_back",&obj0,&obj1)) SWIG_fail;
19583   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19584   if (!SWIG_IsOK(res1)) {
19585     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_push_back" "', argument " "1"" of type '" "std::vector< int > *""'");
19586   }
19587   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19588   ecode2 = SWIG_AsVal_int(obj1, &val2);
19589   if (!SWIG_IsOK(ecode2)) {
19590     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
19591   }
19592   temp2 = static_cast< std::vector< int >::value_type >(val2);
19593   arg2 = &temp2;
19594   (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
19595   resultobj = SWIG_Py_Void();
19596   return resultobj;
19597 fail:
19598   return NULL;
19599 }
19600
19601
19602 SWIGINTERN PyObject *_wrap_VectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19603   PyObject *resultobj = 0;
19604   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19605   void *argp1 = 0 ;
19606   int res1 = 0 ;
19607   PyObject * obj0 = 0 ;
19608   std::vector< int >::value_type *result = 0 ;
19609
19610   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_front",&obj0)) SWIG_fail;
19611   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19612   if (!SWIG_IsOK(res1)) {
19613     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_front" "', argument " "1"" of type '" "std::vector< int > const *""'");
19614   }
19615   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19616   result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front();
19617   resultobj = SWIG_From_int(static_cast< int >(*result));
19618   return resultobj;
19619 fail:
19620   return NULL;
19621 }
19622
19623
19624 SWIGINTERN PyObject *_wrap_VectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19625   PyObject *resultobj = 0;
19626   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19627   void *argp1 = 0 ;
19628   int res1 = 0 ;
19629   PyObject * obj0 = 0 ;
19630   std::vector< int >::value_type *result = 0 ;
19631
19632   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_back",&obj0)) SWIG_fail;
19633   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19634   if (!SWIG_IsOK(res1)) {
19635     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_back" "', argument " "1"" of type '" "std::vector< int > const *""'");
19636   }
19637   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19638   result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->back();
19639   resultobj = SWIG_From_int(static_cast< int >(*result));
19640   return resultobj;
19641 fail:
19642   return NULL;
19643 }
19644
19645
19646 SWIGINTERN PyObject *_wrap_VectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19647   PyObject *resultobj = 0;
19648   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19649   std::vector< int >::size_type arg2 ;
19650   std::vector< int >::value_type *arg3 = 0 ;
19651   void *argp1 = 0 ;
19652   int res1 = 0 ;
19653   size_t val2 ;
19654   int ecode2 = 0 ;
19655   std::vector< int >::value_type temp3 ;
19656   int val3 ;
19657   int ecode3 = 0 ;
19658   PyObject * obj0 = 0 ;
19659   PyObject * obj1 = 0 ;
19660   PyObject * obj2 = 0 ;
19661
19662   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail;
19663   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19664   if (!SWIG_IsOK(res1)) {
19665     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_assign" "', argument " "1"" of type '" "std::vector< int > *""'");
19666   }
19667   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19668   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19669   if (!SWIG_IsOK(ecode2)) {
19670     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
19671   }
19672   arg2 = static_cast< std::vector< int >::size_type >(val2);
19673   ecode3 = SWIG_AsVal_int(obj2, &val3);
19674   if (!SWIG_IsOK(ecode3)) {
19675     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
19676   }
19677   temp3 = static_cast< std::vector< int >::value_type >(val3);
19678   arg3 = &temp3;
19679   (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
19680   resultobj = SWIG_Py_Void();
19681   return resultobj;
19682 fail:
19683   return NULL;
19684 }
19685
19686
19687 SWIGINTERN PyObject *_wrap_VectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19688   PyObject *resultobj = 0;
19689   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19690   std::vector< int >::size_type arg2 ;
19691   std::vector< int >::value_type *arg3 = 0 ;
19692   void *argp1 = 0 ;
19693   int res1 = 0 ;
19694   size_t val2 ;
19695   int ecode2 = 0 ;
19696   std::vector< int >::value_type temp3 ;
19697   int val3 ;
19698   int ecode3 = 0 ;
19699   PyObject * obj0 = 0 ;
19700   PyObject * obj1 = 0 ;
19701   PyObject * obj2 = 0 ;
19702
19703   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail;
19704   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19705   if (!SWIG_IsOK(res1)) {
19706     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'");
19707   }
19708   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19709   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19710   if (!SWIG_IsOK(ecode2)) {
19711     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
19712   }
19713   arg2 = static_cast< std::vector< int >::size_type >(val2);
19714   ecode3 = SWIG_AsVal_int(obj2, &val3);
19715   if (!SWIG_IsOK(ecode3)) {
19716     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
19717   }
19718   temp3 = static_cast< std::vector< int >::value_type >(val3);
19719   arg3 = &temp3;
19720   (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
19721   resultobj = SWIG_Py_Void();
19722   return resultobj;
19723 fail:
19724   return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_VectorInt_resize(PyObject *self, PyObject *args) {
19729   Py_ssize_t argc;
19730   PyObject *argv[4] = {
19731     0
19732   };
19733   Py_ssize_t ii;
19734
19735   if (!PyTuple_Check(args)) SWIG_fail;
19736   argc = args ? PyObject_Length(args) : 0;
19737   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
19738     argv[ii] = PyTuple_GET_ITEM(args,ii);
19739   }
19740   if (argc == 2) {
19741     int _v;
19742     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19743     _v = SWIG_CheckState(res);
19744     if (_v) {
19745       {
19746         int res = SWIG_AsVal_size_t(argv[1], NULL);
19747         _v = SWIG_CheckState(res);
19748       }
19749       if (_v) {
19750         return _wrap_VectorInt_resize__SWIG_0(self, args);
19751       }
19752     }
19753   }
19754   if (argc == 3) {
19755     int _v;
19756     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19757     _v = SWIG_CheckState(res);
19758     if (_v) {
19759       {
19760         int res = SWIG_AsVal_size_t(argv[1], NULL);
19761         _v = SWIG_CheckState(res);
19762       }
19763       if (_v) {
19764         {
19765           int res = SWIG_AsVal_int(argv[2], NULL);
19766           _v = SWIG_CheckState(res);
19767         }
19768         if (_v) {
19769           return _wrap_VectorInt_resize__SWIG_1(self, args);
19770         }
19771       }
19772     }
19773   }
19774
19775 fail:
19776   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_resize'.\n"
19777     "  Possible C/C++ prototypes are:\n"
19778     "    std::vector< int >::resize(std::vector< int >::size_type)\n"
19779     "    std::vector< int >::resize(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
19780   return 0;
19781 }
19782
19783
19784 SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19785   PyObject *resultobj = 0;
19786   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19787   std::vector< int >::iterator arg2 ;
19788   std::vector< int >::value_type *arg3 = 0 ;
19789   void *argp1 = 0 ;
19790   int res1 = 0 ;
19791   swig::SwigPyIterator *iter2 = 0 ;
19792   int res2 ;
19793   std::vector< int >::value_type temp3 ;
19794   int val3 ;
19795   int ecode3 = 0 ;
19796   PyObject * obj0 = 0 ;
19797   PyObject * obj1 = 0 ;
19798   PyObject * obj2 = 0 ;
19799   std::vector< int >::iterator result;
19800
19801   if (!PyArg_ParseTuple(args,(char *)"OOO:VectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail;
19802   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19803   if (!SWIG_IsOK(res1)) {
19804     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
19805   }
19806   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19807   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
19808   if (!SWIG_IsOK(res2) || !iter2) {
19809     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19810   } else {
19811     swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
19812     if (iter_t) {
19813       arg2 = iter_t->get_current();
19814     } else {
19815       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19816     }
19817   }
19818   ecode3 = SWIG_AsVal_int(obj2, &val3);
19819   if (!SWIG_IsOK(ecode3)) {
19820     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
19821   }
19822   temp3 = static_cast< std::vector< int >::value_type >(val3);
19823   arg3 = &temp3;
19824   result = std_vector_Sl_int_Sg__insert__SWIG_0(arg1,arg2,(int const &)*arg3);
19825   resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
19826     swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
19827   return resultobj;
19828 fail:
19829   return NULL;
19830 }
19831
19832
19833 SWIGINTERN PyObject *_wrap_VectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19834   PyObject *resultobj = 0;
19835   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19836   std::vector< int >::iterator arg2 ;
19837   std::vector< int >::size_type arg3 ;
19838   std::vector< int >::value_type *arg4 = 0 ;
19839   void *argp1 = 0 ;
19840   int res1 = 0 ;
19841   swig::SwigPyIterator *iter2 = 0 ;
19842   int res2 ;
19843   size_t val3 ;
19844   int ecode3 = 0 ;
19845   std::vector< int >::value_type temp4 ;
19846   int val4 ;
19847   int ecode4 = 0 ;
19848   PyObject * obj0 = 0 ;
19849   PyObject * obj1 = 0 ;
19850   PyObject * obj2 = 0 ;
19851   PyObject * obj3 = 0 ;
19852
19853   if (!PyArg_ParseTuple(args,(char *)"OOOO:VectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19854   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19855   if (!SWIG_IsOK(res1)) {
19856     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'");
19857   }
19858   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19859   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
19860   if (!SWIG_IsOK(res2) || !iter2) {
19861     SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19862   } else {
19863     swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
19864     if (iter_t) {
19865       arg2 = iter_t->get_current();
19866     } else {
19867       SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "VectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
19868     }
19869   }
19870   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
19871   if (!SWIG_IsOK(ecode3)) {
19872     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
19873   }
19874   arg3 = static_cast< std::vector< int >::size_type >(val3);
19875   ecode4 = SWIG_AsVal_int(obj3, &val4);
19876   if (!SWIG_IsOK(ecode4)) {
19877     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorInt_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
19878   }
19879   temp4 = static_cast< std::vector< int >::value_type >(val4);
19880   arg4 = &temp4;
19881   std_vector_Sl_int_Sg__insert__SWIG_1(arg1,arg2,arg3,(int const &)*arg4);
19882   resultobj = SWIG_Py_Void();
19883   return resultobj;
19884 fail:
19885   return NULL;
19886 }
19887
19888
19889 SWIGINTERN PyObject *_wrap_VectorInt_insert(PyObject *self, PyObject *args) {
19890   Py_ssize_t argc;
19891   PyObject *argv[5] = {
19892     0
19893   };
19894   Py_ssize_t ii;
19895
19896   if (!PyTuple_Check(args)) SWIG_fail;
19897   argc = args ? PyObject_Length(args) : 0;
19898   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
19899     argv[ii] = PyTuple_GET_ITEM(args,ii);
19900   }
19901   if (argc == 3) {
19902     int _v;
19903     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19904     _v = SWIG_CheckState(res);
19905     if (_v) {
19906       swig::SwigPyIterator *iter = 0;
19907       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
19908       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
19909       if (_v) {
19910         {
19911           int res = SWIG_AsVal_int(argv[2], NULL);
19912           _v = SWIG_CheckState(res);
19913         }
19914         if (_v) {
19915           return _wrap_VectorInt_insert__SWIG_0(self, args);
19916         }
19917       }
19918     }
19919   }
19920   if (argc == 4) {
19921     int _v;
19922     int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
19923     _v = SWIG_CheckState(res);
19924     if (_v) {
19925       swig::SwigPyIterator *iter = 0;
19926       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
19927       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
19928       if (_v) {
19929         {
19930           int res = SWIG_AsVal_size_t(argv[2], NULL);
19931           _v = SWIG_CheckState(res);
19932         }
19933         if (_v) {
19934           {
19935             int res = SWIG_AsVal_int(argv[3], NULL);
19936             _v = SWIG_CheckState(res);
19937           }
19938           if (_v) {
19939             return _wrap_VectorInt_insert__SWIG_1(self, args);
19940           }
19941         }
19942       }
19943     }
19944   }
19945
19946 fail:
19947   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'VectorInt_insert'.\n"
19948     "  Possible C/C++ prototypes are:\n"
19949     "    std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
19950     "    std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
19951   return 0;
19952 }
19953
19954
19955 SWIGINTERN PyObject *_wrap_VectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19956   PyObject *resultobj = 0;
19957   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19958   std::vector< int >::size_type arg2 ;
19959   void *argp1 = 0 ;
19960   int res1 = 0 ;
19961   size_t val2 ;
19962   int ecode2 = 0 ;
19963   PyObject * obj0 = 0 ;
19964   PyObject * obj1 = 0 ;
19965
19966   if (!PyArg_ParseTuple(args,(char *)"OO:VectorInt_reserve",&obj0,&obj1)) SWIG_fail;
19967   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19968   if (!SWIG_IsOK(res1)) {
19969     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_reserve" "', argument " "1"" of type '" "std::vector< int > *""'");
19970   }
19971   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19972   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19973   if (!SWIG_IsOK(ecode2)) {
19974     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorInt_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
19975   }
19976   arg2 = static_cast< std::vector< int >::size_type >(val2);
19977   (arg1)->reserve(arg2);
19978   resultobj = SWIG_Py_Void();
19979   return resultobj;
19980 fail:
19981   return NULL;
19982 }
19983
19984
19985 SWIGINTERN PyObject *_wrap_VectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19986   PyObject *resultobj = 0;
19987   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
19988   void *argp1 = 0 ;
19989   int res1 = 0 ;
19990   PyObject * obj0 = 0 ;
19991   std::vector< int >::size_type result;
19992
19993   if (!PyArg_ParseTuple(args,(char *)"O:VectorInt_capacity",&obj0)) SWIG_fail;
19994   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
19995   if (!SWIG_IsOK(res1)) {
19996     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInt_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'");
19997   }
19998   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
19999   result = ((std::vector< int > const *)arg1)->capacity();
20000   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20001   return resultobj;
20002 fail:
20003   return NULL;
20004 }
20005
20006
20007 SWIGINTERN PyObject *_wrap_delete_VectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20008   PyObject *resultobj = 0;
20009   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
20010   void *argp1 = 0 ;
20011   int res1 = 0 ;
20012   PyObject * obj0 = 0 ;
20013
20014   if (!PyArg_ParseTuple(args,(char *)"O:delete_VectorInt",&obj0)) SWIG_fail;
20015   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN |  0 );
20016   if (!SWIG_IsOK(res1)) {
20017     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInt" "', argument " "1"" of type '" "std::vector< int > *""'");
20018   }
20019   arg1 = reinterpret_cast< std::vector< int > * >(argp1);
20020   delete arg1;
20021   resultobj = SWIG_Py_Void();
20022   return resultobj;
20023 fail:
20024   return NULL;
20025 }
20026
20027
20028 SWIGINTERN PyObject *VectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20029   PyObject *obj;
20030   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
20031   SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj));
20032   return SWIG_Py_Void();
20033 }
20034
20035 SWIGINTERN int Swig_var_ABR_TYPES_set(PyObject *) {
20036   SWIG_Error(SWIG_AttributeError,"Variable ABR_TYPES is read-only.");
20037   return 1;
20038 }
20039
20040
20041 SWIGINTERN PyObject *Swig_var_ABR_TYPES_get(void) {
20042   PyObject *pyobj = 0;
20043
20044   pyobj = SWIG_FromCharPtr(Hex::ABR_TYPES);
20045   return pyobj;
20046 }
20047
20048
20049 SWIGINTERN PyObject *_wrap_get_temp_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20050   PyObject *resultobj = 0;
20051   cpchar arg1 = (cpchar) 0 ;
20052   pchar arg2 = (pchar) 0 ;
20053   int res1 ;
20054   char *buf1 = 0 ;
20055   int alloc1 = 0 ;
20056   int res2 ;
20057   char *buf2 = 0 ;
20058   int alloc2 = 0 ;
20059   PyObject * obj0 = 0 ;
20060   PyObject * obj1 = 0 ;
20061   pchar result;
20062
20063   if (!PyArg_ParseTuple(args,(char *)"OO:get_temp_name",&obj0,&obj1)) SWIG_fail;
20064   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20065   if (!SWIG_IsOK(res1)) {
20066     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_temp_name" "', argument " "1"" of type '" "cpchar""'");
20067   }
20068   arg1 = reinterpret_cast< cpchar >(buf1);
20069   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20070   if (!SWIG_IsOK(res2)) {
20071     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_temp_name" "', argument " "2"" of type '" "pchar""'");
20072   }
20073   arg2 = reinterpret_cast< pchar >(buf2);
20074   result = (pchar)Hex::get_temp_name((char const *)arg1,arg2);
20075   resultobj = SWIG_FromCharPtr((const char *)result);
20076   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20077   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20078   return resultobj;
20079 fail:
20080   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20081   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20082   return NULL;
20083 }
20084
20085
20086 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20087   PyObject *resultobj = 0;
20088   cpchar arg1 = (cpchar) 0 ;
20089   cpchar arg2 = (cpchar) 0 ;
20090   cpchar arg3 = (cpchar) 0 ;
20091   int res1 ;
20092   char *buf1 = 0 ;
20093   int alloc1 = 0 ;
20094   int res2 ;
20095   char *buf2 = 0 ;
20096   int alloc2 = 0 ;
20097   int res3 ;
20098   char *buf3 = 0 ;
20099   int alloc3 = 0 ;
20100   PyObject * obj0 = 0 ;
20101   PyObject * obj1 = 0 ;
20102   PyObject * obj2 = 0 ;
20103
20104   if (!PyArg_ParseTuple(args,(char *)"OOO:fatal_error",&obj0,&obj1,&obj2)) SWIG_fail;
20105   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20106   if (!SWIG_IsOK(res1)) {
20107     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
20108   }
20109   arg1 = reinterpret_cast< cpchar >(buf1);
20110   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20111   if (!SWIG_IsOK(res2)) {
20112     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fatal_error" "', argument " "2"" of type '" "cpchar""'");
20113   }
20114   arg2 = reinterpret_cast< cpchar >(buf2);
20115   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
20116   if (!SWIG_IsOK(res3)) {
20117     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fatal_error" "', argument " "3"" of type '" "cpchar""'");
20118   }
20119   arg3 = reinterpret_cast< cpchar >(buf3);
20120   Hex::fatal_error((char const *)arg1,(char const *)arg2,(char const *)arg3);
20121   resultobj = SWIG_Py_Void();
20122   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20123   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20124   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20125   return resultobj;
20126 fail:
20127   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20128   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20129   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20130   return NULL;
20131 }
20132
20133
20134 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20135   PyObject *resultobj = 0;
20136   cpchar arg1 = (cpchar) 0 ;
20137   cpchar arg2 = (cpchar) 0 ;
20138   int res1 ;
20139   char *buf1 = 0 ;
20140   int alloc1 = 0 ;
20141   int res2 ;
20142   char *buf2 = 0 ;
20143   int alloc2 = 0 ;
20144   PyObject * obj0 = 0 ;
20145   PyObject * obj1 = 0 ;
20146
20147   if (!PyArg_ParseTuple(args,(char *)"OO:fatal_error",&obj0,&obj1)) SWIG_fail;
20148   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20149   if (!SWIG_IsOK(res1)) {
20150     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
20151   }
20152   arg1 = reinterpret_cast< cpchar >(buf1);
20153   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20154   if (!SWIG_IsOK(res2)) {
20155     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fatal_error" "', argument " "2"" of type '" "cpchar""'");
20156   }
20157   arg2 = reinterpret_cast< cpchar >(buf2);
20158   Hex::fatal_error((char const *)arg1,(char const *)arg2);
20159   resultobj = SWIG_Py_Void();
20160   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20161   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20162   return resultobj;
20163 fail:
20164   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20165   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20166   return NULL;
20167 }
20168
20169
20170 SWIGINTERN PyObject *_wrap_fatal_error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20171   PyObject *resultobj = 0;
20172   cpchar arg1 = (cpchar) 0 ;
20173   int res1 ;
20174   char *buf1 = 0 ;
20175   int alloc1 = 0 ;
20176   PyObject * obj0 = 0 ;
20177
20178   if (!PyArg_ParseTuple(args,(char *)"O:fatal_error",&obj0)) SWIG_fail;
20179   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20180   if (!SWIG_IsOK(res1)) {
20181     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fatal_error" "', argument " "1"" of type '" "cpchar""'");
20182   }
20183   arg1 = reinterpret_cast< cpchar >(buf1);
20184   Hex::fatal_error((char const *)arg1);
20185   resultobj = SWIG_Py_Void();
20186   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20187   return resultobj;
20188 fail:
20189   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20190   return NULL;
20191 }
20192
20193
20194 SWIGINTERN PyObject *_wrap_fatal_error(PyObject *self, PyObject *args) {
20195   Py_ssize_t argc;
20196   PyObject *argv[4] = {
20197     0
20198   };
20199   Py_ssize_t ii;
20200
20201   if (!PyTuple_Check(args)) SWIG_fail;
20202   argc = args ? PyObject_Length(args) : 0;
20203   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
20204     argv[ii] = PyTuple_GET_ITEM(args,ii);
20205   }
20206   if (argc == 1) {
20207     int _v;
20208     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
20209     _v = SWIG_CheckState(res);
20210     if (_v) {
20211       return _wrap_fatal_error__SWIG_2(self, args);
20212     }
20213   }
20214   if (argc == 2) {
20215     int _v;
20216     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
20217     _v = SWIG_CheckState(res);
20218     if (_v) {
20219       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
20220       _v = SWIG_CheckState(res);
20221       if (_v) {
20222         return _wrap_fatal_error__SWIG_1(self, args);
20223       }
20224     }
20225   }
20226   if (argc == 3) {
20227     int _v;
20228     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
20229     _v = SWIG_CheckState(res);
20230     if (_v) {
20231       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
20232       _v = SWIG_CheckState(res);
20233       if (_v) {
20234         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
20235         _v = SWIG_CheckState(res);
20236         if (_v) {
20237           return _wrap_fatal_error__SWIG_0(self, args);
20238         }
20239       }
20240     }
20241   }
20242
20243 fail:
20244   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'fatal_error'.\n"
20245     "  Possible C/C++ prototypes are:\n"
20246     "    Hex::fatal_error(cpchar,cpchar,cpchar)\n"
20247     "    Hex::fatal_error(cpchar,cpchar)\n"
20248     "    Hex::fatal_error(cpchar)\n");
20249   return 0;
20250 }
20251
20252
20253 SWIGINTERN PyObject *_wrap_prod_scalaire(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20254   PyObject *resultobj = 0;
20255   double *arg1 ;
20256   double *arg2 ;
20257   void *argp1 = 0 ;
20258   int res1 = 0 ;
20259   void *argp2 = 0 ;
20260   int res2 = 0 ;
20261   PyObject * obj0 = 0 ;
20262   PyObject * obj1 = 0 ;
20263   double result;
20264
20265   if (!PyArg_ParseTuple(args,(char *)"OO:prod_scalaire",&obj0,&obj1)) SWIG_fail;
20266   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20267   if (!SWIG_IsOK(res1)) {
20268     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_scalaire" "', argument " "1"" of type '" "double []""'");
20269   }
20270   arg1 = reinterpret_cast< double * >(argp1);
20271   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20272   if (!SWIG_IsOK(res2)) {
20273     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_scalaire" "', argument " "2"" of type '" "double []""'");
20274   }
20275   arg2 = reinterpret_cast< double * >(argp2);
20276   result = (double)Hex::prod_scalaire(arg1,arg2);
20277   resultobj = SWIG_From_double(static_cast< double >(result));
20278   return resultobj;
20279 fail:
20280   return NULL;
20281 }
20282
20283
20284 SWIGINTERN PyObject *_wrap_prod_vectoriel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20285   PyObject *resultobj = 0;
20286   double *arg1 ;
20287   double *arg2 ;
20288   double *arg3 ;
20289   void *argp1 = 0 ;
20290   int res1 = 0 ;
20291   void *argp2 = 0 ;
20292   int res2 = 0 ;
20293   void *argp3 = 0 ;
20294   int res3 = 0 ;
20295   PyObject * obj0 = 0 ;
20296   PyObject * obj1 = 0 ;
20297   PyObject * obj2 = 0 ;
20298   double *result = 0 ;
20299
20300   if (!PyArg_ParseTuple(args,(char *)"OOO:prod_vectoriel",&obj0,&obj1,&obj2)) SWIG_fail;
20301   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20302   if (!SWIG_IsOK(res1)) {
20303     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_vectoriel" "', argument " "1"" of type '" "double []""'");
20304   }
20305   arg1 = reinterpret_cast< double * >(argp1);
20306   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20307   if (!SWIG_IsOK(res2)) {
20308     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_vectoriel" "', argument " "2"" of type '" "double []""'");
20309   }
20310   arg2 = reinterpret_cast< double * >(argp2);
20311   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
20312   if (!SWIG_IsOK(res3)) {
20313     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "prod_vectoriel" "', argument " "3"" of type '" "double []""'");
20314   }
20315   arg3 = reinterpret_cast< double * >(argp3);
20316   result = (double *)Hex::prod_vectoriel(arg1,arg2,arg3);
20317   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
20318   return resultobj;
20319 fail:
20320   return NULL;
20321 }
20322
20323
20324 SWIGINTERN PyObject *_wrap_prod_mixte(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20325   PyObject *resultobj = 0;
20326   double *arg1 ;
20327   double *arg2 ;
20328   double *arg3 ;
20329   void *argp1 = 0 ;
20330   int res1 = 0 ;
20331   void *argp2 = 0 ;
20332   int res2 = 0 ;
20333   void *argp3 = 0 ;
20334   int res3 = 0 ;
20335   PyObject * obj0 = 0 ;
20336   PyObject * obj1 = 0 ;
20337   PyObject * obj2 = 0 ;
20338   double result;
20339
20340   if (!PyArg_ParseTuple(args,(char *)"OOO:prod_mixte",&obj0,&obj1,&obj2)) SWIG_fail;
20341   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20342   if (!SWIG_IsOK(res1)) {
20343     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "prod_mixte" "', argument " "1"" of type '" "double []""'");
20344   }
20345   arg1 = reinterpret_cast< double * >(argp1);
20346   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20347   if (!SWIG_IsOK(res2)) {
20348     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "prod_mixte" "', argument " "2"" of type '" "double []""'");
20349   }
20350   arg2 = reinterpret_cast< double * >(argp2);
20351   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
20352   if (!SWIG_IsOK(res3)) {
20353     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "prod_mixte" "', argument " "3"" of type '" "double []""'");
20354   }
20355   arg3 = reinterpret_cast< double * >(argp3);
20356   result = (double)Hex::prod_mixte(arg1,arg2,arg3);
20357   resultobj = SWIG_From_double(static_cast< double >(result));
20358   return resultobj;
20359 fail:
20360   return NULL;
20361 }
20362
20363
20364 SWIGINTERN PyObject *_wrap_deg2radians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20365   PyObject *resultobj = 0;
20366   double arg1 ;
20367   double val1 ;
20368   int ecode1 = 0 ;
20369   PyObject * obj0 = 0 ;
20370   double result;
20371
20372   if (!PyArg_ParseTuple(args,(char *)"O:deg2radians",&obj0)) SWIG_fail;
20373   ecode1 = SWIG_AsVal_double(obj0, &val1);
20374   if (!SWIG_IsOK(ecode1)) {
20375     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "deg2radians" "', argument " "1"" of type '" "double""'");
20376   }
20377   arg1 = static_cast< double >(val1);
20378   result = (double)Hex::deg2radians(arg1);
20379   resultobj = SWIG_From_double(static_cast< double >(result));
20380   return resultobj;
20381 fail:
20382   return NULL;
20383 }
20384
20385
20386 SWIGINTERN PyObject *_wrap_rad2degres(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20387   PyObject *resultobj = 0;
20388   double arg1 ;
20389   double val1 ;
20390   int ecode1 = 0 ;
20391   PyObject * obj0 = 0 ;
20392   double result;
20393
20394   if (!PyArg_ParseTuple(args,(char *)"O:rad2degres",&obj0)) SWIG_fail;
20395   ecode1 = SWIG_AsVal_double(obj0, &val1);
20396   if (!SWIG_IsOK(ecode1)) {
20397     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "rad2degres" "', argument " "1"" of type '" "double""'");
20398   }
20399   arg1 = static_cast< double >(val1);
20400   result = (double)Hex::rad2degres(arg1);
20401   resultobj = SWIG_From_double(static_cast< double >(result));
20402   return resultobj;
20403 fail:
20404   return NULL;
20405 }
20406
20407
20408 SWIGINTERN PyObject *_wrap_calc_norme(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20409   PyObject *resultobj = 0;
20410   double *arg1 ;
20411   void *argp1 = 0 ;
20412   int res1 = 0 ;
20413   PyObject * obj0 = 0 ;
20414   double result;
20415
20416   if (!PyArg_ParseTuple(args,(char *)"O:calc_norme",&obj0)) SWIG_fail;
20417   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20418   if (!SWIG_IsOK(res1)) {
20419     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_norme" "', argument " "1"" of type '" "double []""'");
20420   }
20421   arg1 = reinterpret_cast< double * >(argp1);
20422   result = (double)Hex::calc_norme(arg1);
20423   resultobj = SWIG_From_double(static_cast< double >(result));
20424   return resultobj;
20425 fail:
20426   return NULL;
20427 }
20428
20429
20430 SWIGINTERN PyObject *_wrap_calc_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20431   PyObject *resultobj = 0;
20432   double *arg1 ;
20433   double *arg2 ;
20434   void *argp1 = 0 ;
20435   int res1 = 0 ;
20436   void *argp2 = 0 ;
20437   int res2 = 0 ;
20438   PyObject * obj0 = 0 ;
20439   PyObject * obj1 = 0 ;
20440   double result;
20441
20442   if (!PyArg_ParseTuple(args,(char *)"OO:calc_distance",&obj0,&obj1)) SWIG_fail;
20443   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20444   if (!SWIG_IsOK(res1)) {
20445     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_distance" "', argument " "1"" of type '" "double []""'");
20446   }
20447   arg1 = reinterpret_cast< double * >(argp1);
20448   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20449   if (!SWIG_IsOK(res2)) {
20450     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_distance" "', argument " "2"" of type '" "double []""'");
20451   }
20452   arg2 = reinterpret_cast< double * >(argp2);
20453   result = (double)Hex::calc_distance(arg1,arg2);
20454   resultobj = SWIG_From_double(static_cast< double >(result));
20455   return resultobj;
20456 fail:
20457   return NULL;
20458 }
20459
20460
20461 SWIGINTERN PyObject *_wrap_calc_d2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20462   PyObject *resultobj = 0;
20463   double *arg1 ;
20464   double *arg2 ;
20465   void *argp1 = 0 ;
20466   int res1 = 0 ;
20467   void *argp2 = 0 ;
20468   int res2 = 0 ;
20469   PyObject * obj0 = 0 ;
20470   PyObject * obj1 = 0 ;
20471   double result;
20472
20473   if (!PyArg_ParseTuple(args,(char *)"OO:calc_d2",&obj0,&obj1)) SWIG_fail;
20474   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20475   if (!SWIG_IsOK(res1)) {
20476     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_d2" "', argument " "1"" of type '" "double []""'");
20477   }
20478   arg1 = reinterpret_cast< double * >(argp1);
20479   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20480   if (!SWIG_IsOK(res2)) {
20481     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_d2" "', argument " "2"" of type '" "double []""'");
20482   }
20483   arg2 = reinterpret_cast< double * >(argp2);
20484   result = (double)Hex::calc_d2(arg1,arg2);
20485   resultobj = SWIG_From_double(static_cast< double >(result));
20486   return resultobj;
20487 fail:
20488   return NULL;
20489 }
20490
20491
20492 SWIGINTERN PyObject *_wrap_calc_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20493   PyObject *resultobj = 0;
20494   double *arg1 ;
20495   double *arg2 ;
20496   double *arg3 ;
20497   void *argp1 = 0 ;
20498   int res1 = 0 ;
20499   void *argp2 = 0 ;
20500   int res2 = 0 ;
20501   void *argp3 = 0 ;
20502   int res3 = 0 ;
20503   PyObject * obj0 = 0 ;
20504   PyObject * obj1 = 0 ;
20505   PyObject * obj2 = 0 ;
20506
20507   if (!PyArg_ParseTuple(args,(char *)"OOO:calc_vecteur",&obj0,&obj1,&obj2)) SWIG_fail;
20508   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20509   if (!SWIG_IsOK(res1)) {
20510     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_vecteur" "', argument " "1"" of type '" "double []""'");
20511   }
20512   arg1 = reinterpret_cast< double * >(argp1);
20513   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20514   if (!SWIG_IsOK(res2)) {
20515     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_vecteur" "', argument " "2"" of type '" "double []""'");
20516   }
20517   arg2 = reinterpret_cast< double * >(argp2);
20518   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
20519   if (!SWIG_IsOK(res3)) {
20520     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "calc_vecteur" "', argument " "3"" of type '" "double []""'");
20521   }
20522   arg3 = reinterpret_cast< double * >(argp3);
20523   Hex::calc_vecteur(arg1,arg2,arg3);
20524   resultobj = SWIG_Py_Void();
20525   return resultobj;
20526 fail:
20527   return NULL;
20528 }
20529
20530
20531 SWIGINTERN PyObject *_wrap_copy_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20532   PyObject *resultobj = 0;
20533   double *arg1 ;
20534   double *arg2 ;
20535   void *argp1 = 0 ;
20536   int res1 = 0 ;
20537   void *argp2 = 0 ;
20538   int res2 = 0 ;
20539   PyObject * obj0 = 0 ;
20540   PyObject * obj1 = 0 ;
20541
20542   if (!PyArg_ParseTuple(args,(char *)"OO:copy_vecteur",&obj0,&obj1)) SWIG_fail;
20543   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20544   if (!SWIG_IsOK(res1)) {
20545     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_vecteur" "', argument " "1"" of type '" "double []""'");
20546   }
20547   arg1 = reinterpret_cast< double * >(argp1);
20548   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20549   if (!SWIG_IsOK(res2)) {
20550     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copy_vecteur" "', argument " "2"" of type '" "double []""'");
20551   }
20552   arg2 = reinterpret_cast< double * >(argp2);
20553   Hex::copy_vecteur(arg1,arg2);
20554   resultobj = SWIG_Py_Void();
20555   return resultobj;
20556 fail:
20557   return NULL;
20558 }
20559
20560
20561 SWIGINTERN PyObject *_wrap_calc_milieu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20562   PyObject *resultobj = 0;
20563   double *arg1 ;
20564   double *arg2 ;
20565   double *arg3 ;
20566   void *argp1 = 0 ;
20567   int res1 = 0 ;
20568   void *argp2 = 0 ;
20569   int res2 = 0 ;
20570   void *argp3 = 0 ;
20571   int res3 = 0 ;
20572   PyObject * obj0 = 0 ;
20573   PyObject * obj1 = 0 ;
20574   PyObject * obj2 = 0 ;
20575
20576   if (!PyArg_ParseTuple(args,(char *)"OOO:calc_milieu",&obj0,&obj1,&obj2)) SWIG_fail;
20577   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20578   if (!SWIG_IsOK(res1)) {
20579     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "calc_milieu" "', argument " "1"" of type '" "double []""'");
20580   }
20581   arg1 = reinterpret_cast< double * >(argp1);
20582   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20583   if (!SWIG_IsOK(res2)) {
20584     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "calc_milieu" "', argument " "2"" of type '" "double []""'");
20585   }
20586   arg2 = reinterpret_cast< double * >(argp2);
20587   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
20588   if (!SWIG_IsOK(res3)) {
20589     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "calc_milieu" "', argument " "3"" of type '" "double []""'");
20590   }
20591   arg3 = reinterpret_cast< double * >(argp3);
20592   Hex::calc_milieu(arg1,arg2,arg3);
20593   resultobj = SWIG_Py_Void();
20594   return resultobj;
20595 fail:
20596   return NULL;
20597 }
20598
20599
20600 SWIGINTERN PyObject *_wrap_normer_vecteur(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20601   PyObject *resultobj = 0;
20602   double *arg1 ;
20603   void *argp1 = 0 ;
20604   int res1 = 0 ;
20605   PyObject * obj0 = 0 ;
20606   int result;
20607
20608   if (!PyArg_ParseTuple(args,(char *)"O:normer_vecteur",&obj0)) SWIG_fail;
20609   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20610   if (!SWIG_IsOK(res1)) {
20611     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "normer_vecteur" "', argument " "1"" of type '" "double []""'");
20612   }
20613   arg1 = reinterpret_cast< double * >(argp1);
20614   result = (int)Hex::normer_vecteur(arg1);
20615   resultobj = SWIG_From_int(static_cast< int >(result));
20616   return resultobj;
20617 fail:
20618   return NULL;
20619 }
20620
20621
20622 SWIGINTERN PyObject *_wrap_carre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20623   PyObject *resultobj = 0;
20624   double arg1 ;
20625   double val1 ;
20626   int ecode1 = 0 ;
20627   PyObject * obj0 = 0 ;
20628   double result;
20629
20630   if (!PyArg_ParseTuple(args,(char *)"O:carre",&obj0)) SWIG_fail;
20631   ecode1 = SWIG_AsVal_double(obj0, &val1);
20632   if (!SWIG_IsOK(ecode1)) {
20633     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "carre" "', argument " "1"" of type '" "double""'");
20634   }
20635   arg1 = static_cast< double >(val1);
20636   result = (double)Hex::carre(arg1);
20637   resultobj = SWIG_From_double(static_cast< double >(result));
20638   return resultobj;
20639 fail:
20640   return NULL;
20641 }
20642
20643
20644 SWIGINTERN PyObject *_wrap_same_coords__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20645   PyObject *resultobj = 0;
20646   double *arg1 = (double *) 0 ;
20647   double *arg2 = (double *) 0 ;
20648   double arg3 ;
20649   void *argp1 = 0 ;
20650   int res1 = 0 ;
20651   void *argp2 = 0 ;
20652   int res2 = 0 ;
20653   double val3 ;
20654   int ecode3 = 0 ;
20655   PyObject * obj0 = 0 ;
20656   PyObject * obj1 = 0 ;
20657   PyObject * obj2 = 0 ;
20658   bool result;
20659
20660   if (!PyArg_ParseTuple(args,(char *)"OOO:same_coords",&obj0,&obj1,&obj2)) SWIG_fail;
20661   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20662   if (!SWIG_IsOK(res1)) {
20663     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "same_coords" "', argument " "1"" of type '" "double *""'");
20664   }
20665   arg1 = reinterpret_cast< double * >(argp1);
20666   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20667   if (!SWIG_IsOK(res2)) {
20668     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "same_coords" "', argument " "2"" of type '" "double *""'");
20669   }
20670   arg2 = reinterpret_cast< double * >(argp2);
20671   ecode3 = SWIG_AsVal_double(obj2, &val3);
20672   if (!SWIG_IsOK(ecode3)) {
20673     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "same_coords" "', argument " "3"" of type '" "double""'");
20674   }
20675   arg3 = static_cast< double >(val3);
20676   result = (bool)Hex::same_coords(arg1,arg2,arg3);
20677   resultobj = SWIG_From_bool(static_cast< bool >(result));
20678   return resultobj;
20679 fail:
20680   return NULL;
20681 }
20682
20683
20684 SWIGINTERN PyObject *_wrap_same_coords__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20685   PyObject *resultobj = 0;
20686   double *arg1 = (double *) 0 ;
20687   double *arg2 = (double *) 0 ;
20688   void *argp1 = 0 ;
20689   int res1 = 0 ;
20690   void *argp2 = 0 ;
20691   int res2 = 0 ;
20692   PyObject * obj0 = 0 ;
20693   PyObject * obj1 = 0 ;
20694   bool result;
20695
20696   if (!PyArg_ParseTuple(args,(char *)"OO:same_coords",&obj0,&obj1)) SWIG_fail;
20697   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20698   if (!SWIG_IsOK(res1)) {
20699     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "same_coords" "', argument " "1"" of type '" "double *""'");
20700   }
20701   arg1 = reinterpret_cast< double * >(argp1);
20702   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20703   if (!SWIG_IsOK(res2)) {
20704     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "same_coords" "', argument " "2"" of type '" "double *""'");
20705   }
20706   arg2 = reinterpret_cast< double * >(argp2);
20707   result = (bool)Hex::same_coords(arg1,arg2);
20708   resultobj = SWIG_From_bool(static_cast< bool >(result));
20709   return resultobj;
20710 fail:
20711   return NULL;
20712 }
20713
20714
20715 SWIGINTERN PyObject *_wrap_same_coords(PyObject *self, PyObject *args) {
20716   Py_ssize_t argc;
20717   PyObject *argv[4] = {
20718     0
20719   };
20720   Py_ssize_t ii;
20721
20722   if (!PyTuple_Check(args)) SWIG_fail;
20723   argc = args ? PyObject_Length(args) : 0;
20724   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
20725     argv[ii] = PyTuple_GET_ITEM(args,ii);
20726   }
20727   if (argc == 2) {
20728     int _v;
20729     void *vptr = 0;
20730     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
20731     _v = SWIG_CheckState(res);
20732     if (_v) {
20733       void *vptr = 0;
20734       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
20735       _v = SWIG_CheckState(res);
20736       if (_v) {
20737         return _wrap_same_coords__SWIG_1(self, args);
20738       }
20739     }
20740   }
20741   if (argc == 3) {
20742     int _v;
20743     void *vptr = 0;
20744     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
20745     _v = SWIG_CheckState(res);
20746     if (_v) {
20747       void *vptr = 0;
20748       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
20749       _v = SWIG_CheckState(res);
20750       if (_v) {
20751         {
20752           int res = SWIG_AsVal_double(argv[2], NULL);
20753           _v = SWIG_CheckState(res);
20754         }
20755         if (_v) {
20756           return _wrap_same_coords__SWIG_0(self, args);
20757         }
20758       }
20759     }
20760   }
20761
20762 fail:
20763   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'same_coords'.\n"
20764     "  Possible C/C++ prototypes are:\n"
20765     "    Hex::same_coords(double *,double *,double)\n"
20766     "    Hex::same_coords(double *,double *)\n");
20767   return 0;
20768 }
20769
20770
20771 SWIGINTERN PyObject *_wrap_requals__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20772   PyObject *resultobj = 0;
20773   double arg1 ;
20774   double arg2 ;
20775   double val1 ;
20776   int ecode1 = 0 ;
20777   double val2 ;
20778   int ecode2 = 0 ;
20779   PyObject * obj0 = 0 ;
20780   PyObject * obj1 = 0 ;
20781   bool result;
20782
20783   if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
20784   ecode1 = SWIG_AsVal_double(obj0, &val1);
20785   if (!SWIG_IsOK(ecode1)) {
20786     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "requals" "', argument " "1"" of type '" "double""'");
20787   }
20788   arg1 = static_cast< double >(val1);
20789   ecode2 = SWIG_AsVal_double(obj1, &val2);
20790   if (!SWIG_IsOK(ecode2)) {
20791     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "requals" "', argument " "2"" of type '" "double""'");
20792   }
20793   arg2 = static_cast< double >(val2);
20794   result = (bool)Hex::requals(arg1,arg2);
20795   resultobj = SWIG_From_bool(static_cast< bool >(result));
20796   return resultobj;
20797 fail:
20798   return NULL;
20799 }
20800
20801
20802 SWIGINTERN PyObject *_wrap_requals__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20803   PyObject *resultobj = 0;
20804   double *arg1 = (double *) 0 ;
20805   double *arg2 = (double *) 0 ;
20806   void *argp1 = 0 ;
20807   int res1 = 0 ;
20808   void *argp2 = 0 ;
20809   int res2 = 0 ;
20810   PyObject * obj0 = 0 ;
20811   PyObject * obj1 = 0 ;
20812   bool result;
20813
20814   if (!PyArg_ParseTuple(args,(char *)"OO:requals",&obj0,&obj1)) SWIG_fail;
20815   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
20816   if (!SWIG_IsOK(res1)) {
20817     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "requals" "', argument " "1"" of type '" "double const *""'");
20818   }
20819   arg1 = reinterpret_cast< double * >(argp1);
20820   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
20821   if (!SWIG_IsOK(res2)) {
20822     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "requals" "', argument " "2"" of type '" "double const *""'");
20823   }
20824   arg2 = reinterpret_cast< double * >(argp2);
20825   result = (bool)Hex::requals((double const *)arg1,(double const *)arg2);
20826   resultobj = SWIG_From_bool(static_cast< bool >(result));
20827   return resultobj;
20828 fail:
20829   return NULL;
20830 }
20831
20832
20833 SWIGINTERN PyObject *_wrap_requals(PyObject *self, PyObject *args) {
20834   Py_ssize_t argc;
20835   PyObject *argv[3] = {
20836     0
20837   };
20838   Py_ssize_t ii;
20839
20840   if (!PyTuple_Check(args)) SWIG_fail;
20841   argc = args ? PyObject_Length(args) : 0;
20842   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
20843     argv[ii] = PyTuple_GET_ITEM(args,ii);
20844   }
20845   if (argc == 2) {
20846     int _v;
20847     void *vptr = 0;
20848     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
20849     _v = SWIG_CheckState(res);
20850     if (_v) {
20851       void *vptr = 0;
20852       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
20853       _v = SWIG_CheckState(res);
20854       if (_v) {
20855         return _wrap_requals__SWIG_1(self, args);
20856       }
20857     }
20858   }
20859   if (argc == 2) {
20860     int _v;
20861     {
20862       int res = SWIG_AsVal_double(argv[0], NULL);
20863       _v = SWIG_CheckState(res);
20864     }
20865     if (_v) {
20866       {
20867         int res = SWIG_AsVal_double(argv[1], NULL);
20868         _v = SWIG_CheckState(res);
20869       }
20870       if (_v) {
20871         return _wrap_requals__SWIG_0(self, args);
20872       }
20873     }
20874   }
20875
20876 fail:
20877   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'requals'.\n"
20878     "  Possible C/C++ prototypes are:\n"
20879     "    Hex::requals(double const,double const)\n"
20880     "    Hex::requals(double const *,double const *)\n");
20881   return 0;
20882 }
20883
20884
20885 SWIGINTERN PyObject *_wrap_on_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20886   PyObject *resultobj = 0;
20887   bool result;
20888
20889   if (!PyArg_ParseTuple(args,(char *)":on_debug")) SWIG_fail;
20890   result = (bool)Hex::on_debug();
20891   resultobj = SWIG_From_bool(static_cast< bool >(result));
20892   return resultobj;
20893 fail:
20894   return NULL;
20895 }
20896
20897
20898 SWIGINTERN PyObject *_wrap_in_test(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20899   PyObject *resultobj = 0;
20900   bool result;
20901
20902   if (!PyArg_ParseTuple(args,(char *)":in_test")) SWIG_fail;
20903   result = (bool)Hex::in_test();
20904   resultobj = SWIG_From_bool(static_cast< bool >(result));
20905   return resultobj;
20906 fail:
20907   return NULL;
20908 }
20909
20910
20911 SWIGINTERN PyObject *_wrap_niv_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20912   PyObject *resultobj = 0;
20913   int result;
20914
20915   if (!PyArg_ParseTuple(args,(char *)":niv_debug")) SWIG_fail;
20916   result = (int)Hex::niv_debug();
20917   resultobj = SWIG_From_int(static_cast< int >(result));
20918   return resultobj;
20919 fail:
20920   return NULL;
20921 }
20922
20923
20924 SWIGINTERN PyObject *_wrap_set_minus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20925   PyObject *resultobj = 0;
20926   std::string *arg1 = 0 ;
20927   void *argp1 = 0 ;
20928   int res1 = 0 ;
20929   PyObject * obj0 = 0 ;
20930
20931   if (!PyArg_ParseTuple(args,(char *)"O:set_minus",&obj0)) SWIG_fail;
20932   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_string,  0 );
20933   if (!SWIG_IsOK(res1)) {
20934     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_minus" "', argument " "1"" of type '" "string &""'");
20935   }
20936   if (!argp1) {
20937     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_minus" "', argument " "1"" of type '" "string &""'");
20938   }
20939   arg1 = reinterpret_cast< std::string * >(argp1);
20940   Hex::set_minus(*arg1);
20941   resultobj = SWIG_Py_Void();
20942   return resultobj;
20943 fail:
20944   return NULL;
20945 }
20946
20947
20948 SWIGINTERN PyObject *_wrap_special_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949   PyObject *resultobj = 0;
20950   bool result;
20951
20952   if (!PyArg_ParseTuple(args,(char *)":special_option")) SWIG_fail;
20953   result = (bool)Hex::special_option();
20954   resultobj = SWIG_From_bool(static_cast< bool >(result));
20955   return resultobj;
20956 fail:
20957   return NULL;
20958 }
20959
20960
20961 SWIGINTERN PyObject *_wrap_set_special_option(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20962   PyObject *resultobj = 0;
20963   bool arg1 ;
20964   bool val1 ;
20965   int ecode1 = 0 ;
20966   PyObject * obj0 = 0 ;
20967
20968   if (!PyArg_ParseTuple(args,(char *)"O:set_special_option",&obj0)) SWIG_fail;
20969   ecode1 = SWIG_AsVal_bool(obj0, &val1);
20970   if (!SWIG_IsOK(ecode1)) {
20971     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_special_option" "', argument " "1"" of type '" "bool""'");
20972   }
20973   arg1 = static_cast< bool >(val1);
20974   Hex::set_special_option(arg1);
20975   resultobj = SWIG_Py_Void();
20976   return resultobj;
20977 fail:
20978   return NULL;
20979 }
20980
20981
20982 SWIGINTERN PyObject *_wrap_sizeof_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20983   PyObject *resultobj = 0;
20984   cpchar arg1 = (cpchar) 0 ;
20985   int res1 ;
20986   char *buf1 = 0 ;
20987   int alloc1 = 0 ;
20988   PyObject * obj0 = 0 ;
20989   int result;
20990
20991   if (!PyArg_ParseTuple(args,(char *)"O:sizeof_file",&obj0)) SWIG_fail;
20992   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20993   if (!SWIG_IsOK(res1)) {
20994     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sizeof_file" "', argument " "1"" of type '" "cpchar""'");
20995   }
20996   arg1 = reinterpret_cast< cpchar >(buf1);
20997   result = (int)Hex::sizeof_file((char const *)arg1);
20998   resultobj = SWIG_From_int(static_cast< int >(result));
20999   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21000   return resultobj;
21001 fail:
21002   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21003   return NULL;
21004 }
21005
21006
21007 SWIGINTERN PyObject *_wrap_read_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21008   PyObject *resultobj = 0;
21009   cpchar arg1 = (cpchar) 0 ;
21010   int *arg2 = 0 ;
21011   int res1 ;
21012   char *buf1 = 0 ;
21013   int alloc1 = 0 ;
21014   void *argp2 = 0 ;
21015   int res2 = 0 ;
21016   PyObject * obj0 = 0 ;
21017   PyObject * obj1 = 0 ;
21018   char *result = 0 ;
21019
21020   if (!PyArg_ParseTuple(args,(char *)"OO:read_file",&obj0,&obj1)) SWIG_fail;
21021   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
21022   if (!SWIG_IsOK(res1)) {
21023     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read_file" "', argument " "1"" of type '" "cpchar""'");
21024   }
21025   arg1 = reinterpret_cast< cpchar >(buf1);
21026   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int,  0 );
21027   if (!SWIG_IsOK(res2)) {
21028     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "read_file" "', argument " "2"" of type '" "int &""'");
21029   }
21030   if (!argp2) {
21031     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "read_file" "', argument " "2"" of type '" "int &""'");
21032   }
21033   arg2 = reinterpret_cast< int * >(argp2);
21034   result = (char *)Hex::read_file((char const *)arg1,*arg2);
21035   resultobj = SWIG_FromCharPtr((const char *)result);
21036   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21037   return resultobj;
21038 fail:
21039   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21040   return NULL;
21041 }
21042
21043
21044 SWIGINTERN PyObject *_wrap_get_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21045   PyObject *resultobj = 0;
21046   std::string *arg1 = 0 ;
21047   void *argp1 = 0 ;
21048   int res1 = 0 ;
21049   PyObject * obj0 = 0 ;
21050   cpchar result;
21051
21052   if (!PyArg_ParseTuple(args,(char *)"O:get_time",&obj0)) SWIG_fail;
21053   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_string,  0 );
21054   if (!SWIG_IsOK(res1)) {
21055     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_time" "', argument " "1"" of type '" "string &""'");
21056   }
21057   if (!argp1) {
21058     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "get_time" "', argument " "1"" of type '" "string &""'");
21059   }
21060   arg1 = reinterpret_cast< std::string * >(argp1);
21061   result = (cpchar)Hex::get_time(*arg1);
21062   resultobj = SWIG_FromCharPtr((const char *)result);
21063   return resultobj;
21064 fail:
21065   return NULL;
21066 }
21067
21068
21069 SWIGINTERN PyObject *_wrap_make_basename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21070   PyObject *resultobj = 0;
21071   cpchar arg1 = (cpchar) 0 ;
21072   std::string *arg2 = 0 ;
21073   int res1 ;
21074   char *buf1 = 0 ;
21075   int alloc1 = 0 ;
21076   void *argp2 = 0 ;
21077   int res2 = 0 ;
21078   PyObject * obj0 = 0 ;
21079   PyObject * obj1 = 0 ;
21080   int result;
21081
21082   if (!PyArg_ParseTuple(args,(char *)"OO:make_basename",&obj0,&obj1)) SWIG_fail;
21083   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
21084   if (!SWIG_IsOK(res1)) {
21085     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_basename" "', argument " "1"" of type '" "cpchar""'");
21086   }
21087   arg1 = reinterpret_cast< cpchar >(buf1);
21088   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string,  0 );
21089   if (!SWIG_IsOK(res2)) {
21090     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_basename" "', argument " "2"" of type '" "string &""'");
21091   }
21092   if (!argp2) {
21093     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_basename" "', argument " "2"" of type '" "string &""'");
21094   }
21095   arg2 = reinterpret_cast< std::string * >(argp2);
21096   result = (int)Hex::make_basename((char const *)arg1,*arg2);
21097   resultobj = SWIG_From_int(static_cast< int >(result));
21098   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21099   return resultobj;
21100 fail:
21101   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21102   return NULL;
21103 }
21104
21105
21106 SWIGINTERN int Swig_var_Epsil_set(PyObject *) {
21107   SWIG_Error(SWIG_AttributeError,"Variable Epsil is read-only.");
21108   return 1;
21109 }
21110
21111
21112 SWIGINTERN PyObject *Swig_var_Epsil_get(void) {
21113   PyObject *pyobj = 0;
21114
21115   pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil));
21116   return pyobj;
21117 }
21118
21119
21120 SWIGINTERN int Swig_var_UnEpsil_set(PyObject *) {
21121   SWIG_Error(SWIG_AttributeError,"Variable UnEpsil is read-only.");
21122   return 1;
21123 }
21124
21125
21126 SWIGINTERN PyObject *Swig_var_UnEpsil_get(void) {
21127   PyObject *pyobj = 0;
21128
21129   pyobj = SWIG_From_double(static_cast< double >(Hex::UnEpsil));
21130   return pyobj;
21131 }
21132
21133
21134 SWIGINTERN int Swig_var_Epsil2_set(PyObject *) {
21135   SWIG_Error(SWIG_AttributeError,"Variable Epsil2 is read-only.");
21136   return 1;
21137 }
21138
21139
21140 SWIGINTERN PyObject *Swig_var_Epsil2_get(void) {
21141   PyObject *pyobj = 0;
21142
21143   pyobj = SWIG_From_double(static_cast< double >(Hex::Epsil2));
21144   return pyobj;
21145 }
21146
21147
21148 SWIGINTERN PyObject *_wrap_EltBase_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21149   PyObject *resultobj = 0;
21150   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21151   void *argp1 = 0 ;
21152   int res1 = 0 ;
21153   PyObject * obj0 = 0 ;
21154   int result;
21155
21156   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countHexa",&obj0)) SWIG_fail;
21157   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21158   if (!SWIG_IsOK(res1)) {
21159     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countHexa" "', argument " "1"" of type '" "Hex::EltBase *""'");
21160   }
21161   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21162   result = (int)(arg1)->countHexa();
21163   resultobj = SWIG_From_int(static_cast< int >(result));
21164   return resultobj;
21165 fail:
21166   return NULL;
21167 }
21168
21169
21170 SWIGINTERN PyObject *_wrap_EltBase_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21171   PyObject *resultobj = 0;
21172   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21173   void *argp1 = 0 ;
21174   int res1 = 0 ;
21175   PyObject * obj0 = 0 ;
21176   int result;
21177
21178   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countQuad",&obj0)) SWIG_fail;
21179   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21180   if (!SWIG_IsOK(res1)) {
21181     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countQuad" "', argument " "1"" of type '" "Hex::EltBase *""'");
21182   }
21183   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21184   result = (int)(arg1)->countQuad();
21185   resultobj = SWIG_From_int(static_cast< int >(result));
21186   return resultobj;
21187 fail:
21188   return NULL;
21189 }
21190
21191
21192 SWIGINTERN PyObject *_wrap_EltBase_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21193   PyObject *resultobj = 0;
21194   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21195   void *argp1 = 0 ;
21196   int res1 = 0 ;
21197   PyObject * obj0 = 0 ;
21198   int result;
21199
21200   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countEdge",&obj0)) SWIG_fail;
21201   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21202   if (!SWIG_IsOK(res1)) {
21203     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countEdge" "', argument " "1"" of type '" "Hex::EltBase *""'");
21204   }
21205   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21206   result = (int)(arg1)->countEdge();
21207   resultobj = SWIG_From_int(static_cast< int >(result));
21208   return resultobj;
21209 fail:
21210   return NULL;
21211 }
21212
21213
21214 SWIGINTERN PyObject *_wrap_EltBase_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21215   PyObject *resultobj = 0;
21216   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21217   void *argp1 = 0 ;
21218   int res1 = 0 ;
21219   PyObject * obj0 = 0 ;
21220   int result;
21221
21222   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_countVertex",&obj0)) SWIG_fail;
21223   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21224   if (!SWIG_IsOK(res1)) {
21225     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_countVertex" "', argument " "1"" of type '" "Hex::EltBase *""'");
21226   }
21227   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21228   result = (int)(arg1)->countVertex();
21229   resultobj = SWIG_From_int(static_cast< int >(result));
21230   return resultobj;
21231 fail:
21232   return NULL;
21233 }
21234
21235
21236 SWIGINTERN PyObject *_wrap_EltBase_setError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21237   PyObject *resultobj = 0;
21238   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21239   int arg2 ;
21240   void *argp1 = 0 ;
21241   int res1 = 0 ;
21242   int val2 ;
21243   int ecode2 = 0 ;
21244   PyObject * obj0 = 0 ;
21245   PyObject * obj1 = 0 ;
21246
21247   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setError",&obj0,&obj1)) SWIG_fail;
21248   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21249   if (!SWIG_IsOK(res1)) {
21250     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setError" "', argument " "1"" of type '" "Hex::EltBase *""'");
21251   }
21252   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21253   ecode2 = SWIG_AsVal_int(obj1, &val2);
21254   if (!SWIG_IsOK(ecode2)) {
21255     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setError" "', argument " "2"" of type '" "int""'");
21256   }
21257   arg2 = static_cast< int >(val2);
21258   (arg1)->setError(arg2);
21259   resultobj = SWIG_Py_Void();
21260   return resultobj;
21261 fail:
21262   return NULL;
21263 }
21264
21265
21266 SWIGINTERN PyObject *_wrap_EltBase_setError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21267   PyObject *resultobj = 0;
21268   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21269   void *argp1 = 0 ;
21270   int res1 = 0 ;
21271   PyObject * obj0 = 0 ;
21272
21273   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_setError",&obj0)) SWIG_fail;
21274   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21275   if (!SWIG_IsOK(res1)) {
21276     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setError" "', argument " "1"" of type '" "Hex::EltBase *""'");
21277   }
21278   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21279   (arg1)->setError();
21280   resultobj = SWIG_Py_Void();
21281   return resultobj;
21282 fail:
21283   return NULL;
21284 }
21285
21286
21287 SWIGINTERN PyObject *_wrap_EltBase_setError(PyObject *self, PyObject *args) {
21288   Py_ssize_t argc;
21289   PyObject *argv[3] = {
21290     0
21291   };
21292   Py_ssize_t ii;
21293
21294   if (!PyTuple_Check(args)) SWIG_fail;
21295   argc = args ? PyObject_Length(args) : 0;
21296   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
21297     argv[ii] = PyTuple_GET_ITEM(args,ii);
21298   }
21299   if (argc == 1) {
21300     int _v;
21301     void *vptr = 0;
21302     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
21303     _v = SWIG_CheckState(res);
21304     if (_v) {
21305       return _wrap_EltBase_setError__SWIG_1(self, args);
21306     }
21307   }
21308   if (argc == 2) {
21309     int _v;
21310     void *vptr = 0;
21311     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
21312     _v = SWIG_CheckState(res);
21313     if (_v) {
21314       {
21315         int res = SWIG_AsVal_int(argv[1], NULL);
21316         _v = SWIG_CheckState(res);
21317       }
21318       if (_v) {
21319         return _wrap_EltBase_setError__SWIG_0(self, args);
21320       }
21321     }
21322   }
21323
21324 fail:
21325   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'EltBase_setError'.\n"
21326     "  Possible C/C++ prototypes are:\n"
21327     "    Hex::EltBase::setError(int)\n"
21328     "    Hex::EltBase::setError()\n");
21329   return 0;
21330 }
21331
21332
21333 SWIGINTERN PyObject *_wrap_EltBase_getError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21334   PyObject *resultobj = 0;
21335   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21336   void *argp1 = 0 ;
21337   int res1 = 0 ;
21338   PyObject * obj0 = 0 ;
21339   int result;
21340
21341   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getError",&obj0)) SWIG_fail;
21342   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21343   if (!SWIG_IsOK(res1)) {
21344     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getError" "', argument " "1"" of type '" "Hex::EltBase *""'");
21345   }
21346   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21347   result = (int)(arg1)->getError();
21348   resultobj = SWIG_From_int(static_cast< int >(result));
21349   return resultobj;
21350 fail:
21351   return NULL;
21352 }
21353
21354
21355 SWIGINTERN PyObject *_wrap_EltBase_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21356   PyObject *resultobj = 0;
21357   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21358   void *argp1 = 0 ;
21359   int res1 = 0 ;
21360   PyObject * obj0 = 0 ;
21361   bool result;
21362
21363   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isValid",&obj0)) SWIG_fail;
21364   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21365   if (!SWIG_IsOK(res1)) {
21366     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isValid" "', argument " "1"" of type '" "Hex::EltBase *""'");
21367   }
21368   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21369   result = (bool)(arg1)->isValid();
21370   resultobj = SWIG_From_bool(static_cast< bool >(result));
21371   return resultobj;
21372 fail:
21373   return NULL;
21374 }
21375
21376
21377 SWIGINTERN PyObject *_wrap_EltBase_isBad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378   PyObject *resultobj = 0;
21379   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21380   void *argp1 = 0 ;
21381   int res1 = 0 ;
21382   PyObject * obj0 = 0 ;
21383   bool result;
21384
21385   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isBad",&obj0)) SWIG_fail;
21386   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21387   if (!SWIG_IsOK(res1)) {
21388     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isBad" "', argument " "1"" of type '" "Hex::EltBase *""'");
21389   }
21390   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21391   result = (bool)(arg1)->isBad();
21392   resultobj = SWIG_From_bool(static_cast< bool >(result));
21393   return resultobj;
21394 fail:
21395   return NULL;
21396 }
21397
21398
21399 SWIGINTERN PyObject *_wrap_EltBase_duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21400   PyObject *resultobj = 0;
21401   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21402   void *argp1 = 0 ;
21403   int res1 = 0 ;
21404   PyObject * obj0 = 0 ;
21405
21406   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_duplicate",&obj0)) SWIG_fail;
21407   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21408   if (!SWIG_IsOK(res1)) {
21409     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_duplicate" "', argument " "1"" of type '" "Hex::EltBase *""'");
21410   }
21411   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21412   (arg1)->duplicate();
21413   resultobj = SWIG_Py_Void();
21414   return resultobj;
21415 fail:
21416   return NULL;
21417 }
21418
21419
21420 SWIGINTERN PyObject *_wrap_EltBase_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21421   PyObject *resultobj = 0;
21422   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21423   void *argp1 = 0 ;
21424   int res1 = 0 ;
21425   PyObject * obj0 = 0 ;
21426
21427   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_clearAssociation",&obj0)) SWIG_fail;
21428   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21429   if (!SWIG_IsOK(res1)) {
21430     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_clearAssociation" "', argument " "1"" of type '" "Hex::EltBase *""'");
21431   }
21432   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21433   (arg1)->clearAssociation();
21434   resultobj = SWIG_Py_Void();
21435   return resultobj;
21436 fail:
21437   return NULL;
21438 }
21439
21440
21441 SWIGINTERN PyObject *_wrap_EltBase_replaceEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21442   PyObject *resultobj = 0;
21443   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21444   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
21445   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
21446   void *argp1 = 0 ;
21447   int res1 = 0 ;
21448   void *argp2 = 0 ;
21449   int res2 = 0 ;
21450   void *argp3 = 0 ;
21451   int res3 = 0 ;
21452   PyObject * obj0 = 0 ;
21453   PyObject * obj1 = 0 ;
21454   PyObject * obj2 = 0 ;
21455
21456   if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_replaceEdge",&obj0,&obj1,&obj2)) SWIG_fail;
21457   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21458   if (!SWIG_IsOK(res1)) {
21459     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_replaceEdge" "', argument " "1"" of type '" "Hex::EltBase *""'");
21460   }
21461   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21462   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
21463   if (!SWIG_IsOK(res2)) {
21464     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_replaceEdge" "', argument " "2"" of type '" "Hex::Edge *""'");
21465   }
21466   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
21467   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
21468   if (!SWIG_IsOK(res3)) {
21469     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_replaceEdge" "', argument " "3"" of type '" "Hex::Edge *""'");
21470   }
21471   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
21472   (arg1)->replaceEdge(arg2,arg3);
21473   resultobj = SWIG_Py_Void();
21474   return resultobj;
21475 fail:
21476   return NULL;
21477 }
21478
21479
21480 SWIGINTERN PyObject *_wrap_EltBase_replaceVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21481   PyObject *resultobj = 0;
21482   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21483   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
21484   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
21485   void *argp1 = 0 ;
21486   int res1 = 0 ;
21487   void *argp2 = 0 ;
21488   int res2 = 0 ;
21489   void *argp3 = 0 ;
21490   int res3 = 0 ;
21491   PyObject * obj0 = 0 ;
21492   PyObject * obj1 = 0 ;
21493   PyObject * obj2 = 0 ;
21494
21495   if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_replaceVertex",&obj0,&obj1,&obj2)) SWIG_fail;
21496   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21497   if (!SWIG_IsOK(res1)) {
21498     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_replaceVertex" "', argument " "1"" of type '" "Hex::EltBase *""'");
21499   }
21500   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21501   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21502   if (!SWIG_IsOK(res2)) {
21503     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_replaceVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
21504   }
21505   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
21506   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
21507   if (!SWIG_IsOK(res3)) {
21508     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_replaceVertex" "', argument " "3"" of type '" "Hex::Vertex *""'");
21509   }
21510   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
21511   (arg1)->replaceVertex(arg2,arg3);
21512   resultobj = SWIG_Py_Void();
21513   return resultobj;
21514 fail:
21515   return NULL;
21516 }
21517
21518
21519 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21520   PyObject *resultobj = 0;
21521   Hex::Document *arg1 = (Hex::Document *) 0 ;
21522   Hex::EnumElt arg2 ;
21523   void *argp1 = 0 ;
21524   int res1 = 0 ;
21525   int val2 ;
21526   int ecode2 = 0 ;
21527   PyObject * obj0 = 0 ;
21528   PyObject * obj1 = 0 ;
21529   Hex::EltBase *result = 0 ;
21530
21531   if (!PyArg_ParseTuple(args,(char *)"OO:new_EltBase",&obj0,&obj1)) SWIG_fail;
21532   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21533   if (!SWIG_IsOK(res1)) {
21534     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::Document *""'");
21535   }
21536   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21537   ecode2 = SWIG_AsVal_int(obj1, &val2);
21538   if (!SWIG_IsOK(ecode2)) {
21539     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EltBase" "', argument " "2"" of type '" "Hex::EnumElt""'");
21540   }
21541   arg2 = static_cast< Hex::EnumElt >(val2);
21542   result = (Hex::EltBase *)new Hex::EltBase(arg1,arg2);
21543   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
21544   return resultobj;
21545 fail:
21546   return NULL;
21547 }
21548
21549
21550 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21551   PyObject *resultobj = 0;
21552   Hex::Document *arg1 = (Hex::Document *) 0 ;
21553   void *argp1 = 0 ;
21554   int res1 = 0 ;
21555   PyObject * obj0 = 0 ;
21556   Hex::EltBase *result = 0 ;
21557
21558   if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
21559   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
21560   if (!SWIG_IsOK(res1)) {
21561     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::Document *""'");
21562   }
21563   arg1 = reinterpret_cast< Hex::Document * >(argp1);
21564   result = (Hex::EltBase *)new Hex::EltBase(arg1);
21565   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
21566   return resultobj;
21567 fail:
21568   return NULL;
21569 }
21570
21571
21572 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21573   PyObject *resultobj = 0;
21574   Hex::EnumElt arg1 ;
21575   int val1 ;
21576   int ecode1 = 0 ;
21577   PyObject * obj0 = 0 ;
21578   Hex::EltBase *result = 0 ;
21579
21580   if (!PyArg_ParseTuple(args,(char *)"O:new_EltBase",&obj0)) SWIG_fail;
21581   ecode1 = SWIG_AsVal_int(obj0, &val1);
21582   if (!SWIG_IsOK(ecode1)) {
21583     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EltBase" "', argument " "1"" of type '" "Hex::EnumElt""'");
21584   }
21585   arg1 = static_cast< Hex::EnumElt >(val1);
21586   result = (Hex::EltBase *)new Hex::EltBase(arg1);
21587   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
21588   return resultobj;
21589 fail:
21590   return NULL;
21591 }
21592
21593
21594 SWIGINTERN PyObject *_wrap_new_EltBase__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21595   PyObject *resultobj = 0;
21596   Hex::EltBase *result = 0 ;
21597
21598   if (!PyArg_ParseTuple(args,(char *)":new_EltBase")) SWIG_fail;
21599   result = (Hex::EltBase *)new Hex::EltBase();
21600   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_NEW |  0 );
21601   return resultobj;
21602 fail:
21603   return NULL;
21604 }
21605
21606
21607 SWIGINTERN PyObject *_wrap_new_EltBase(PyObject *self, PyObject *args) {
21608   Py_ssize_t argc;
21609   PyObject *argv[3] = {
21610     0
21611   };
21612   Py_ssize_t ii;
21613
21614   if (!PyTuple_Check(args)) SWIG_fail;
21615   argc = args ? PyObject_Length(args) : 0;
21616   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
21617     argv[ii] = PyTuple_GET_ITEM(args,ii);
21618   }
21619   if (argc == 0) {
21620     return _wrap_new_EltBase__SWIG_3(self, args);
21621   }
21622   if (argc == 1) {
21623     int _v;
21624     void *vptr = 0;
21625     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21626     _v = SWIG_CheckState(res);
21627     if (_v) {
21628       return _wrap_new_EltBase__SWIG_1(self, args);
21629     }
21630   }
21631   if (argc == 1) {
21632     int _v;
21633     {
21634       int res = SWIG_AsVal_int(argv[0], NULL);
21635       _v = SWIG_CheckState(res);
21636     }
21637     if (_v) {
21638       return _wrap_new_EltBase__SWIG_2(self, args);
21639     }
21640   }
21641   if (argc == 2) {
21642     int _v;
21643     void *vptr = 0;
21644     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
21645     _v = SWIG_CheckState(res);
21646     if (_v) {
21647       {
21648         int res = SWIG_AsVal_int(argv[1], NULL);
21649         _v = SWIG_CheckState(res);
21650       }
21651       if (_v) {
21652         return _wrap_new_EltBase__SWIG_0(self, args);
21653       }
21654     }
21655   }
21656
21657 fail:
21658   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_EltBase'.\n"
21659     "  Possible C/C++ prototypes are:\n"
21660     "    Hex::EltBase::EltBase(Hex::Document *,Hex::EnumElt)\n"
21661     "    Hex::EltBase::EltBase(Hex::Document *)\n"
21662     "    Hex::EltBase::EltBase(Hex::EnumElt)\n"
21663     "    Hex::EltBase::EltBase()\n");
21664   return 0;
21665 }
21666
21667
21668 SWIGINTERN PyObject *_wrap_delete_EltBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21669   PyObject *resultobj = 0;
21670   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21671   void *argp1 = 0 ;
21672   int res1 = 0 ;
21673   PyObject * obj0 = 0 ;
21674
21675   if (!PyArg_ParseTuple(args,(char *)"O:delete_EltBase",&obj0)) SWIG_fail;
21676   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, SWIG_POINTER_DISOWN |  0 );
21677   if (!SWIG_IsOK(res1)) {
21678     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EltBase" "', argument " "1"" of type '" "Hex::EltBase *""'");
21679   }
21680   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21681   delete arg1;
21682   resultobj = SWIG_Py_Void();
21683   return resultobj;
21684 fail:
21685   return NULL;
21686 }
21687
21688
21689 SWIGINTERN PyObject *_wrap_EltBase_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21690   PyObject *resultobj = 0;
21691   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21692   void *argp1 = 0 ;
21693   int res1 = 0 ;
21694   PyObject * obj0 = 0 ;
21695
21696   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_remove",&obj0)) SWIG_fail;
21697   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21698   if (!SWIG_IsOK(res1)) {
21699     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_remove" "', argument " "1"" of type '" "Hex::EltBase *""'");
21700   }
21701   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21702   (arg1)->remove();
21703   resultobj = SWIG_Py_Void();
21704   return resultobj;
21705 fail:
21706   return NULL;
21707 }
21708
21709
21710 SWIGINTERN PyObject *_wrap_EltBase_suppress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21711   PyObject *resultobj = 0;
21712   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21713   void *argp1 = 0 ;
21714   int res1 = 0 ;
21715   PyObject * obj0 = 0 ;
21716
21717   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_suppress",&obj0)) SWIG_fail;
21718   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21719   if (!SWIG_IsOK(res1)) {
21720     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_suppress" "', argument " "1"" of type '" "Hex::EltBase *""'");
21721   }
21722   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21723   (arg1)->suppress();
21724   resultobj = SWIG_Py_Void();
21725   return resultobj;
21726 fail:
21727   return NULL;
21728 }
21729
21730
21731 SWIGINTERN PyObject *_wrap_EltBase_dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21732   PyObject *resultobj = 0;
21733   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21734   void *argp1 = 0 ;
21735   int res1 = 0 ;
21736   PyObject * obj0 = 0 ;
21737
21738   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dump",&obj0)) SWIG_fail;
21739   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21740   if (!SWIG_IsOK(res1)) {
21741     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dump" "', argument " "1"" of type '" "Hex::EltBase *""'");
21742   }
21743   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21744   (arg1)->dump();
21745   resultobj = SWIG_Py_Void();
21746   return resultobj;
21747 fail:
21748   return NULL;
21749 }
21750
21751
21752 SWIGINTERN PyObject *_wrap_EltBase_saveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21753   PyObject *resultobj = 0;
21754   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21755   Hex::XmlWriter *arg2 = (Hex::XmlWriter *) 0 ;
21756   void *argp1 = 0 ;
21757   int res1 = 0 ;
21758   void *argp2 = 0 ;
21759   int res2 = 0 ;
21760   PyObject * obj0 = 0 ;
21761   PyObject * obj1 = 0 ;
21762
21763   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_saveXml",&obj0,&obj1)) SWIG_fail;
21764   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21765   if (!SWIG_IsOK(res1)) {
21766     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_saveXml" "', argument " "1"" of type '" "Hex::EltBase *""'");
21767   }
21768   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21769   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__XmlWriter, 0 |  0 );
21770   if (!SWIG_IsOK(res2)) {
21771     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_saveXml" "', argument " "2"" of type '" "Hex::XmlWriter *""'");
21772   }
21773   arg2 = reinterpret_cast< Hex::XmlWriter * >(argp2);
21774   (arg1)->saveXml(arg2);
21775   resultobj = SWIG_Py_Void();
21776   return resultobj;
21777 fail:
21778   return NULL;
21779 }
21780
21781
21782 SWIGINTERN PyObject *_wrap_EltBase_majReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21783   PyObject *resultobj = 0;
21784   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21785   void *argp1 = 0 ;
21786   int res1 = 0 ;
21787   PyObject * obj0 = 0 ;
21788
21789   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_majReferences",&obj0)) SWIG_fail;
21790   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21791   if (!SWIG_IsOK(res1)) {
21792     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_majReferences" "', argument " "1"" of type '" "Hex::EltBase *""'");
21793   }
21794   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21795   (arg1)->majReferences();
21796   resultobj = SWIG_Py_Void();
21797   return resultobj;
21798 fail:
21799   return NULL;
21800 }
21801
21802
21803 SWIGINTERN PyObject *_wrap_EltBase_makeVarName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21804   PyObject *resultobj = 0;
21805   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21806   char *arg2 = (char *) 0 ;
21807   void *argp1 = 0 ;
21808   int res1 = 0 ;
21809   int res2 ;
21810   char *buf2 = 0 ;
21811   int alloc2 = 0 ;
21812   PyObject * obj0 = 0 ;
21813   PyObject * obj1 = 0 ;
21814   char *result = 0 ;
21815
21816   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_makeVarName",&obj0,&obj1)) SWIG_fail;
21817   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21818   if (!SWIG_IsOK(res1)) {
21819     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_makeVarName" "', argument " "1"" of type '" "Hex::EltBase *""'");
21820   }
21821   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21822   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21823   if (!SWIG_IsOK(res2)) {
21824     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_makeVarName" "', argument " "2"" of type '" "char *""'");
21825   }
21826   arg2 = reinterpret_cast< char * >(buf2);
21827   result = (char *)(arg1)->makeVarName(arg2);
21828   resultobj = SWIG_FromCharPtr((const char *)result);
21829   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21830   return resultobj;
21831 fail:
21832   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
21833   return NULL;
21834 }
21835
21836
21837 SWIGINTERN PyObject *_wrap_EltBase_makeName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21838   PyObject *resultobj = 0;
21839   int arg1 ;
21840   int arg2 ;
21841   char *arg3 = (char *) 0 ;
21842   int val1 ;
21843   int ecode1 = 0 ;
21844   int val2 ;
21845   int ecode2 = 0 ;
21846   int res3 ;
21847   char *buf3 = 0 ;
21848   int alloc3 = 0 ;
21849   PyObject * obj0 = 0 ;
21850   PyObject * obj1 = 0 ;
21851   PyObject * obj2 = 0 ;
21852   char *result = 0 ;
21853
21854   if (!PyArg_ParseTuple(args,(char *)"OOO:EltBase_makeName",&obj0,&obj1,&obj2)) SWIG_fail;
21855   ecode1 = SWIG_AsVal_int(obj0, &val1);
21856   if (!SWIG_IsOK(ecode1)) {
21857     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EltBase_makeName" "', argument " "1"" of type '" "int""'");
21858   }
21859   arg1 = static_cast< int >(val1);
21860   ecode2 = SWIG_AsVal_int(obj1, &val2);
21861   if (!SWIG_IsOK(ecode2)) {
21862     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_makeName" "', argument " "2"" of type '" "int""'");
21863   }
21864   arg2 = static_cast< int >(val2);
21865   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
21866   if (!SWIG_IsOK(res3)) {
21867     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EltBase_makeName" "', argument " "3"" of type '" "char *""'");
21868   }
21869   arg3 = reinterpret_cast< char * >(buf3);
21870   result = (char *)Hex::EltBase::makeName(arg1,arg2,arg3);
21871   resultobj = SWIG_FromCharPtr((const char *)result);
21872   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
21873   return resultobj;
21874 fail:
21875   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
21876   return NULL;
21877 }
21878
21879
21880 SWIGINTERN PyObject *_wrap_EltBase_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21881   PyObject *resultobj = 0;
21882   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21883   void *argp1 = 0 ;
21884   int res1 = 0 ;
21885   PyObject * obj0 = 0 ;
21886   Hex::EltBase *result = 0 ;
21887
21888   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_next",&obj0)) SWIG_fail;
21889   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21890   if (!SWIG_IsOK(res1)) {
21891     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_next" "', argument " "1"" of type '" "Hex::EltBase *""'");
21892   }
21893   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21894   result = (Hex::EltBase *)(arg1)->next();
21895   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21896   return resultobj;
21897 fail:
21898   return NULL;
21899 }
21900
21901
21902 SWIGINTERN PyObject *_wrap_EltBase_setNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21903   PyObject *resultobj = 0;
21904   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21905   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
21906   void *argp1 = 0 ;
21907   int res1 = 0 ;
21908   void *argp2 = 0 ;
21909   int res2 = 0 ;
21910   PyObject * obj0 = 0 ;
21911   PyObject * obj1 = 0 ;
21912
21913   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setNext",&obj0,&obj1)) SWIG_fail;
21914   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21915   if (!SWIG_IsOK(res1)) {
21916     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setNext" "', argument " "1"" of type '" "Hex::EltBase *""'");
21917   }
21918   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21919   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21920   if (!SWIG_IsOK(res2)) {
21921     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setNext" "', argument " "2"" of type '" "Hex::EltBase *""'");
21922   }
21923   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
21924   (arg1)->setNext(arg2);
21925   resultobj = SWIG_Py_Void();
21926   return resultobj;
21927 fail:
21928   return NULL;
21929 }
21930
21931
21932 SWIGINTERN PyObject *_wrap_EltBase_getId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21933   PyObject *resultobj = 0;
21934   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21935   void *argp1 = 0 ;
21936   int res1 = 0 ;
21937   PyObject * obj0 = 0 ;
21938   int result;
21939
21940   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getId",&obj0)) SWIG_fail;
21941   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21942   if (!SWIG_IsOK(res1)) {
21943     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getId" "', argument " "1"" of type '" "Hex::EltBase *""'");
21944   }
21945   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21946   result = (int)(arg1)->getId();
21947   resultobj = SWIG_From_int(static_cast< int >(result));
21948   return resultobj;
21949 fail:
21950   return NULL;
21951 }
21952
21953
21954 SWIGINTERN PyObject *_wrap_EltBase_setId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21955   PyObject *resultobj = 0;
21956   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21957   int arg2 ;
21958   void *argp1 = 0 ;
21959   int res1 = 0 ;
21960   int val2 ;
21961   int ecode2 = 0 ;
21962   PyObject * obj0 = 0 ;
21963   PyObject * obj1 = 0 ;
21964
21965   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setId",&obj0,&obj1)) SWIG_fail;
21966   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21967   if (!SWIG_IsOK(res1)) {
21968     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setId" "', argument " "1"" of type '" "Hex::EltBase *""'");
21969   }
21970   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21971   ecode2 = SWIG_AsVal_int(obj1, &val2);
21972   if (!SWIG_IsOK(ecode2)) {
21973     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setId" "', argument " "2"" of type '" "int""'");
21974   }
21975   arg2 = static_cast< int >(val2);
21976   (arg1)->setId(arg2);
21977   resultobj = SWIG_Py_Void();
21978   return resultobj;
21979 fail:
21980   return NULL;
21981 }
21982
21983
21984 SWIGINTERN PyObject *_wrap_EltBase_dad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21985   PyObject *resultobj = 0;
21986   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
21987   void *argp1 = 0 ;
21988   int res1 = 0 ;
21989   PyObject * obj0 = 0 ;
21990   Hex::Document *result = 0 ;
21991
21992   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dad",&obj0)) SWIG_fail;
21993   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
21994   if (!SWIG_IsOK(res1)) {
21995     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dad" "', argument " "1"" of type '" "Hex::EltBase *""'");
21996   }
21997   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
21998   result = (Hex::Document *)(arg1)->dad();
21999   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
22000   return resultobj;
22001 fail:
22002   return NULL;
22003 }
22004
22005
22006 SWIGINTERN PyObject *_wrap_EltBase_getType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22007   PyObject *resultobj = 0;
22008   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22009   void *argp1 = 0 ;
22010   int res1 = 0 ;
22011   PyObject * obj0 = 0 ;
22012   Hex::EnumElt result;
22013
22014   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getType",&obj0)) SWIG_fail;
22015   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22016   if (!SWIG_IsOK(res1)) {
22017     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getType" "', argument " "1"" of type '" "Hex::EltBase *""'");
22018   }
22019   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22020   result = (Hex::EnumElt)(arg1)->getType();
22021   resultobj = SWIG_From_int(static_cast< int >(result));
22022   return resultobj;
22023 fail:
22024   return NULL;
22025 }
22026
22027
22028 SWIGINTERN PyObject *_wrap_EltBase_isHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22029   PyObject *resultobj = 0;
22030   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22031   void *argp1 = 0 ;
22032   int res1 = 0 ;
22033   PyObject * obj0 = 0 ;
22034   bool result;
22035
22036   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isHere",&obj0)) SWIG_fail;
22037   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22038   if (!SWIG_IsOK(res1)) {
22039     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isHere" "', argument " "1"" of type '" "Hex::EltBase *""'");
22040   }
22041   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22042   result = (bool)(arg1)->isHere();
22043   resultobj = SWIG_From_bool(static_cast< bool >(result));
22044   return resultobj;
22045 fail:
22046   return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_EltBase_isDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051   PyObject *resultobj = 0;
22052   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22053   void *argp1 = 0 ;
22054   int res1 = 0 ;
22055   PyObject * obj0 = 0 ;
22056   bool result;
22057
22058   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isDeleted",&obj0)) SWIG_fail;
22059   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22060   if (!SWIG_IsOK(res1)) {
22061     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isDeleted" "', argument " "1"" of type '" "Hex::EltBase *""'");
22062   }
22063   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22064   result = (bool)(arg1)->isDeleted();
22065   resultobj = SWIG_From_bool(static_cast< bool >(result));
22066   return resultobj;
22067 fail:
22068   return NULL;
22069 }
22070
22071
22072 SWIGINTERN PyObject *_wrap_EltBase_razReferences(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22073   PyObject *resultobj = 0;
22074   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22075   void *argp1 = 0 ;
22076   int res1 = 0 ;
22077   PyObject * obj0 = 0 ;
22078
22079   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_razReferences",&obj0)) SWIG_fail;
22080   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22081   if (!SWIG_IsOK(res1)) {
22082     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_razReferences" "', argument " "1"" of type '" "Hex::EltBase *""'");
22083   }
22084   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22085   (arg1)->razReferences();
22086   resultobj = SWIG_Py_Void();
22087   return resultobj;
22088 fail:
22089   return NULL;
22090 }
22091
22092
22093 SWIGINTERN PyObject *_wrap_EltBase_addParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22094   PyObject *resultobj = 0;
22095   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22096   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
22097   void *argp1 = 0 ;
22098   int res1 = 0 ;
22099   void *argp2 = 0 ;
22100   int res2 = 0 ;
22101   PyObject * obj0 = 0 ;
22102   PyObject * obj1 = 0 ;
22103
22104   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_addParent",&obj0,&obj1)) SWIG_fail;
22105   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22106   if (!SWIG_IsOK(res1)) {
22107     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_addParent" "', argument " "1"" of type '" "Hex::EltBase *""'");
22108   }
22109   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22110   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22111   if (!SWIG_IsOK(res2)) {
22112     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_addParent" "', argument " "2"" of type '" "Hex::EltBase *""'");
22113   }
22114   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
22115   (arg1)->addParent(arg2);
22116   resultobj = SWIG_Py_Void();
22117   return resultobj;
22118 fail:
22119   return NULL;
22120 }
22121
22122
22123 SWIGINTERN PyObject *_wrap_EltBase_getNbrParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22124   PyObject *resultobj = 0;
22125   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22126   void *argp1 = 0 ;
22127   int res1 = 0 ;
22128   PyObject * obj0 = 0 ;
22129   int result;
22130
22131   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNbrParents",&obj0)) SWIG_fail;
22132   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22133   if (!SWIG_IsOK(res1)) {
22134     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getNbrParents" "', argument " "1"" of type '" "Hex::EltBase *""'");
22135   }
22136   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22137   result = (int)(arg1)->getNbrParents();
22138   resultobj = SWIG_From_int(static_cast< int >(result));
22139   return resultobj;
22140 fail:
22141   return NULL;
22142 }
22143
22144
22145 SWIGINTERN PyObject *_wrap_EltBase_hasParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22146   PyObject *resultobj = 0;
22147   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22148   void *argp1 = 0 ;
22149   int res1 = 0 ;
22150   PyObject * obj0 = 0 ;
22151   bool result;
22152
22153   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_hasParents",&obj0)) SWIG_fail;
22154   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22155   if (!SWIG_IsOK(res1)) {
22156     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_hasParents" "', argument " "1"" of type '" "Hex::EltBase *""'");
22157   }
22158   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22159   result = (bool)(arg1)->hasParents();
22160   resultobj = SWIG_From_bool(static_cast< bool >(result));
22161   return resultobj;
22162 fail:
22163   return NULL;
22164 }
22165
22166
22167 SWIGINTERN PyObject *_wrap_EltBase_getFather(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22168   PyObject *resultobj = 0;
22169   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22170   int arg2 ;
22171   void *argp1 = 0 ;
22172   int res1 = 0 ;
22173   int val2 ;
22174   int ecode2 = 0 ;
22175   PyObject * obj0 = 0 ;
22176   PyObject * obj1 = 0 ;
22177   Hex::EltBase *result = 0 ;
22178
22179   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getFather",&obj0,&obj1)) SWIG_fail;
22180   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22181   if (!SWIG_IsOK(res1)) {
22182     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getFather" "', argument " "1"" of type '" "Hex::EltBase *""'");
22183   }
22184   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22185   ecode2 = SWIG_AsVal_int(obj1, &val2);
22186   if (!SWIG_IsOK(ecode2)) {
22187     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_getFather" "', argument " "2"" of type '" "int""'");
22188   }
22189   arg2 = static_cast< int >(val2);
22190   result = (Hex::EltBase *)(arg1)->getFather(arg2);
22191   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22192   return resultobj;
22193 fail:
22194   return NULL;
22195 }
22196
22197
22198 SWIGINTERN PyObject *_wrap_EltBase_getMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22199   PyObject *resultobj = 0;
22200   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22201   void *argp1 = 0 ;
22202   int res1 = 0 ;
22203   PyObject * obj0 = 0 ;
22204   int result;
22205
22206   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getMark",&obj0)) SWIG_fail;
22207   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22208   if (!SWIG_IsOK(res1)) {
22209     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getMark" "', argument " "1"" of type '" "Hex::EltBase *""'");
22210   }
22211   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22212   result = (int)(arg1)->getMark();
22213   resultobj = SWIG_From_int(static_cast< int >(result));
22214   return resultobj;
22215 fail:
22216   return NULL;
22217 }
22218
22219
22220 SWIGINTERN PyObject *_wrap_EltBase_setMark(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22221   PyObject *resultobj = 0;
22222   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22223   int arg2 ;
22224   void *argp1 = 0 ;
22225   int res1 = 0 ;
22226   int val2 ;
22227   int ecode2 = 0 ;
22228   PyObject * obj0 = 0 ;
22229   PyObject * obj1 = 0 ;
22230
22231   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setMark",&obj0,&obj1)) SWIG_fail;
22232   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22233   if (!SWIG_IsOK(res1)) {
22234     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setMark" "', argument " "1"" of type '" "Hex::EltBase *""'");
22235   }
22236   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22237   ecode2 = SWIG_AsVal_int(obj1, &val2);
22238   if (!SWIG_IsOK(ecode2)) {
22239     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_setMark" "', argument " "2"" of type '" "int""'");
22240   }
22241   arg2 = static_cast< int >(val2);
22242   (arg1)->setMark(arg2);
22243   resultobj = SWIG_Py_Void();
22244   return resultobj;
22245 fail:
22246   return NULL;
22247 }
22248
22249
22250 SWIGINTERN PyObject *_wrap_EltBase_getName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22251   PyObject *resultobj = 0;
22252   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22253   pchar arg2 = (pchar) 0 ;
22254   void *argp1 = 0 ;
22255   int res1 = 0 ;
22256   int res2 ;
22257   char *buf2 = 0 ;
22258   int alloc2 = 0 ;
22259   PyObject * obj0 = 0 ;
22260   PyObject * obj1 = 0 ;
22261   char *result = 0 ;
22262
22263   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_getName",&obj0,&obj1)) SWIG_fail;
22264   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22265   if (!SWIG_IsOK(res1)) {
22266     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22267   }
22268   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22269   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22270   if (!SWIG_IsOK(res2)) {
22271     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_getName" "', argument " "2"" of type '" "pchar""'");
22272   }
22273   arg2 = reinterpret_cast< pchar >(buf2);
22274   result = (char *)(arg1)->getName(arg2);
22275   resultobj = SWIG_FromCharPtr((const char *)result);
22276   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22277   return resultobj;
22278 fail:
22279   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22280   return NULL;
22281 }
22282
22283
22284 SWIGINTERN PyObject *_wrap_EltBase_printName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22285   PyObject *resultobj = 0;
22286   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22287   cpchar arg2 = (cpchar) 0 ;
22288   void *argp1 = 0 ;
22289   int res1 = 0 ;
22290   int res2 ;
22291   char *buf2 = 0 ;
22292   int alloc2 = 0 ;
22293   PyObject * obj0 = 0 ;
22294   PyObject * obj1 = 0 ;
22295
22296   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_printName",&obj0,&obj1)) SWIG_fail;
22297   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22298   if (!SWIG_IsOK(res1)) {
22299     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_printName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22300   }
22301   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22302   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22303   if (!SWIG_IsOK(res2)) {
22304     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_printName" "', argument " "2"" of type '" "cpchar""'");
22305   }
22306   arg2 = reinterpret_cast< cpchar >(buf2);
22307   (arg1)->printName(arg2);
22308   resultobj = SWIG_Py_Void();
22309   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22310   return resultobj;
22311 fail:
22312   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22313   return NULL;
22314 }
22315
22316
22317 SWIGINTERN PyObject *_wrap_EltBase_printName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22318   PyObject *resultobj = 0;
22319   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22320   void *argp1 = 0 ;
22321   int res1 = 0 ;
22322   PyObject * obj0 = 0 ;
22323
22324   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_printName",&obj0)) SWIG_fail;
22325   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22326   if (!SWIG_IsOK(res1)) {
22327     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_printName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22328   }
22329   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22330   (arg1)->printName();
22331   resultobj = SWIG_Py_Void();
22332   return resultobj;
22333 fail:
22334   return NULL;
22335 }
22336
22337
22338 SWIGINTERN PyObject *_wrap_EltBase_printName(PyObject *self, PyObject *args) {
22339   Py_ssize_t argc;
22340   PyObject *argv[3] = {
22341     0
22342   };
22343   Py_ssize_t ii;
22344
22345   if (!PyTuple_Check(args)) SWIG_fail;
22346   argc = args ? PyObject_Length(args) : 0;
22347   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
22348     argv[ii] = PyTuple_GET_ITEM(args,ii);
22349   }
22350   if (argc == 1) {
22351     int _v;
22352     void *vptr = 0;
22353     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22354     _v = SWIG_CheckState(res);
22355     if (_v) {
22356       return _wrap_EltBase_printName__SWIG_1(self, args);
22357     }
22358   }
22359   if (argc == 2) {
22360     int _v;
22361     void *vptr = 0;
22362     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22363     _v = SWIG_CheckState(res);
22364     if (_v) {
22365       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
22366       _v = SWIG_CheckState(res);
22367       if (_v) {
22368         return _wrap_EltBase_printName__SWIG_0(self, args);
22369       }
22370     }
22371   }
22372
22373 fail:
22374   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'EltBase_printName'.\n"
22375     "  Possible C/C++ prototypes are:\n"
22376     "    Hex::EltBase::printName(cpchar)\n"
22377     "    Hex::EltBase::printName()\n");
22378   return 0;
22379 }
22380
22381
22382 SWIGINTERN PyObject *_wrap_EltBase_dumpRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22383   PyObject *resultobj = 0;
22384   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22385   void *argp1 = 0 ;
22386   int res1 = 0 ;
22387   PyObject * obj0 = 0 ;
22388
22389   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_dumpRef",&obj0)) SWIG_fail;
22390   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22391   if (!SWIG_IsOK(res1)) {
22392     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_dumpRef" "', argument " "1"" of type '" "Hex::EltBase *""'");
22393   }
22394   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22395   (arg1)->dumpRef();
22396   resultobj = SWIG_Py_Void();
22397   return resultobj;
22398 fail:
22399   return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_EltBase_getName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22404   PyObject *resultobj = 0;
22405   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22406   void *argp1 = 0 ;
22407   int res1 = 0 ;
22408   PyObject * obj0 = 0 ;
22409   cpchar result;
22410
22411   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getName",&obj0)) SWIG_fail;
22412   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22413   if (!SWIG_IsOK(res1)) {
22414     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22415   }
22416   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22417   result = (cpchar)(arg1)->getName();
22418   resultobj = SWIG_FromCharPtr((const char *)result);
22419   return resultobj;
22420 fail:
22421   return NULL;
22422 }
22423
22424
22425 SWIGINTERN PyObject *_wrap_EltBase_getName(PyObject *self, PyObject *args) {
22426   Py_ssize_t argc;
22427   PyObject *argv[3] = {
22428     0
22429   };
22430   Py_ssize_t ii;
22431
22432   if (!PyTuple_Check(args)) SWIG_fail;
22433   argc = args ? PyObject_Length(args) : 0;
22434   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
22435     argv[ii] = PyTuple_GET_ITEM(args,ii);
22436   }
22437   if (argc == 1) {
22438     int _v;
22439     void *vptr = 0;
22440     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22441     _v = SWIG_CheckState(res);
22442     if (_v) {
22443       return _wrap_EltBase_getName__SWIG_1(self, args);
22444     }
22445   }
22446   if (argc == 2) {
22447     int _v;
22448     void *vptr = 0;
22449     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22450     _v = SWIG_CheckState(res);
22451     if (_v) {
22452       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
22453       _v = SWIG_CheckState(res);
22454       if (_v) {
22455         return _wrap_EltBase_getName__SWIG_0(self, args);
22456       }
22457     }
22458   }
22459
22460 fail:
22461   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'EltBase_getName'.\n"
22462     "  Possible C/C++ prototypes are:\n"
22463     "    Hex::EltBase::getName(pchar)\n"
22464     "    Hex::EltBase::getName()\n");
22465   return 0;
22466 }
22467
22468
22469 SWIGINTERN PyObject *_wrap_EltBase_setName__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22470   PyObject *resultobj = 0;
22471   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22472   std::string *arg2 = 0 ;
22473   void *argp1 = 0 ;
22474   int res1 = 0 ;
22475   void *argp2 = 0 ;
22476   int res2 = 0 ;
22477   PyObject * obj0 = 0 ;
22478   PyObject * obj1 = 0 ;
22479
22480   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setName",&obj0,&obj1)) SWIG_fail;
22481   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22482   if (!SWIG_IsOK(res1)) {
22483     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22484   }
22485   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22486   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string,  0  | 0);
22487   if (!SWIG_IsOK(res2)) {
22488     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setName" "', argument " "2"" of type '" "string const &""'");
22489   }
22490   if (!argp2) {
22491     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EltBase_setName" "', argument " "2"" of type '" "string const &""'");
22492   }
22493   arg2 = reinterpret_cast< std::string * >(argp2);
22494   (arg1)->setName((std::string const &)*arg2);
22495   resultobj = SWIG_Py_Void();
22496   return resultobj;
22497 fail:
22498   return NULL;
22499 }
22500
22501
22502 SWIGINTERN PyObject *_wrap_EltBase_setName__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22503   PyObject *resultobj = 0;
22504   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22505   cpchar arg2 = (cpchar) 0 ;
22506   void *argp1 = 0 ;
22507   int res1 = 0 ;
22508   int res2 ;
22509   char *buf2 = 0 ;
22510   int alloc2 = 0 ;
22511   PyObject * obj0 = 0 ;
22512   PyObject * obj1 = 0 ;
22513
22514   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_setName",&obj0,&obj1)) SWIG_fail;
22515   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22516   if (!SWIG_IsOK(res1)) {
22517     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_setName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22518   }
22519   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22520   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22521   if (!SWIG_IsOK(res2)) {
22522     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EltBase_setName" "', argument " "2"" of type '" "cpchar""'");
22523   }
22524   arg2 = reinterpret_cast< cpchar >(buf2);
22525   (arg1)->setName(arg2);
22526   resultobj = SWIG_Py_Void();
22527   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22528   return resultobj;
22529 fail:
22530   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22531   return NULL;
22532 }
22533
22534
22535 SWIGINTERN PyObject *_wrap_EltBase_setName(PyObject *self, PyObject *args) {
22536   Py_ssize_t argc;
22537   PyObject *argv[3] = {
22538     0
22539   };
22540   Py_ssize_t ii;
22541
22542   if (!PyTuple_Check(args)) SWIG_fail;
22543   argc = args ? PyObject_Length(args) : 0;
22544   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
22545     argv[ii] = PyTuple_GET_ITEM(args,ii);
22546   }
22547   if (argc == 2) {
22548     int _v;
22549     void *vptr = 0;
22550     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22551     _v = SWIG_CheckState(res);
22552     if (_v) {
22553       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_string, 0);
22554       _v = SWIG_CheckState(res);
22555       if (_v) {
22556         return _wrap_EltBase_setName__SWIG_0(self, args);
22557       }
22558     }
22559   }
22560   if (argc == 2) {
22561     int _v;
22562     void *vptr = 0;
22563     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22564     _v = SWIG_CheckState(res);
22565     if (_v) {
22566       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
22567       _v = SWIG_CheckState(res);
22568       if (_v) {
22569         return _wrap_EltBase_setName__SWIG_1(self, args);
22570       }
22571     }
22572   }
22573
22574 fail:
22575   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'EltBase_setName'.\n"
22576     "  Possible C/C++ prototypes are:\n"
22577     "    Hex::EltBase::setName(string const &)\n"
22578     "    Hex::EltBase::setName(cpchar)\n");
22579   return 0;
22580 }
22581
22582
22583 SWIGINTERN PyObject *_wrap_EltBase_debug__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22584   PyObject *resultobj = 0;
22585   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22586   int arg2 ;
22587   void *argp1 = 0 ;
22588   int res1 = 0 ;
22589   int val2 ;
22590   int ecode2 = 0 ;
22591   PyObject * obj0 = 0 ;
22592   PyObject * obj1 = 0 ;
22593   bool result;
22594
22595   if (!PyArg_ParseTuple(args,(char *)"OO:EltBase_debug",&obj0,&obj1)) SWIG_fail;
22596   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22597   if (!SWIG_IsOK(res1)) {
22598     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_debug" "', argument " "1"" of type '" "Hex::EltBase *""'");
22599   }
22600   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22601   ecode2 = SWIG_AsVal_int(obj1, &val2);
22602   if (!SWIG_IsOK(ecode2)) {
22603     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EltBase_debug" "', argument " "2"" of type '" "int""'");
22604   }
22605   arg2 = static_cast< int >(val2);
22606   result = (bool)(arg1)->debug(arg2);
22607   resultobj = SWIG_From_bool(static_cast< bool >(result));
22608   return resultobj;
22609 fail:
22610   return NULL;
22611 }
22612
22613
22614 SWIGINTERN PyObject *_wrap_EltBase_debug__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22615   PyObject *resultobj = 0;
22616   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22617   void *argp1 = 0 ;
22618   int res1 = 0 ;
22619   PyObject * obj0 = 0 ;
22620   bool result;
22621
22622   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_debug",&obj0)) SWIG_fail;
22623   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22624   if (!SWIG_IsOK(res1)) {
22625     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_debug" "', argument " "1"" of type '" "Hex::EltBase *""'");
22626   }
22627   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22628   result = (bool)(arg1)->debug();
22629   resultobj = SWIG_From_bool(static_cast< bool >(result));
22630   return resultobj;
22631 fail:
22632   return NULL;
22633 }
22634
22635
22636 SWIGINTERN PyObject *_wrap_EltBase_debug(PyObject *self, PyObject *args) {
22637   Py_ssize_t argc;
22638   PyObject *argv[3] = {
22639     0
22640   };
22641   Py_ssize_t ii;
22642
22643   if (!PyTuple_Check(args)) SWIG_fail;
22644   argc = args ? PyObject_Length(args) : 0;
22645   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
22646     argv[ii] = PyTuple_GET_ITEM(args,ii);
22647   }
22648   if (argc == 1) {
22649     int _v;
22650     void *vptr = 0;
22651     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22652     _v = SWIG_CheckState(res);
22653     if (_v) {
22654       return _wrap_EltBase_debug__SWIG_1(self, args);
22655     }
22656   }
22657   if (argc == 2) {
22658     int _v;
22659     void *vptr = 0;
22660     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
22661     _v = SWIG_CheckState(res);
22662     if (_v) {
22663       {
22664         int res = SWIG_AsVal_int(argv[1], NULL);
22665         _v = SWIG_CheckState(res);
22666       }
22667       if (_v) {
22668         return _wrap_EltBase_debug__SWIG_0(self, args);
22669       }
22670     }
22671   }
22672
22673 fail:
22674   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'EltBase_debug'.\n"
22675     "  Possible C/C++ prototypes are:\n"
22676     "    Hex::EltBase::debug(int)\n"
22677     "    Hex::EltBase::debug()\n");
22678   return 0;
22679 }
22680
22681
22682 SWIGINTERN PyObject *_wrap_EltBase_isAssociated(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22683   PyObject *resultobj = 0;
22684   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22685   void *argp1 = 0 ;
22686   int res1 = 0 ;
22687   PyObject * obj0 = 0 ;
22688   bool result;
22689
22690   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_isAssociated",&obj0)) SWIG_fail;
22691   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22692   if (!SWIG_IsOK(res1)) {
22693     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_isAssociated" "', argument " "1"" of type '" "Hex::EltBase *""'");
22694   }
22695   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22696   result = (bool)(arg1)->isAssociated();
22697   resultobj = SWIG_From_bool(static_cast< bool >(result));
22698   return resultobj;
22699 fail:
22700   return NULL;
22701 }
22702
22703
22704 SWIGINTERN PyObject *_wrap_EltBase_getNextName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22705   PyObject *resultobj = 0;
22706   Hex::EltBase *arg1 = (Hex::EltBase *) 0 ;
22707   void *argp1 = 0 ;
22708   int res1 = 0 ;
22709   PyObject * obj0 = 0 ;
22710   std::string result;
22711
22712   if (!PyArg_ParseTuple(args,(char *)"O:EltBase_getNextName",&obj0)) SWIG_fail;
22713   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
22714   if (!SWIG_IsOK(res1)) {
22715     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EltBase_getNextName" "', argument " "1"" of type '" "Hex::EltBase *""'");
22716   }
22717   arg1 = reinterpret_cast< Hex::EltBase * >(argp1);
22718   result = (arg1)->getNextName();
22719   resultobj = SWIG_NewPointerObj((new std::string(static_cast< const std::string& >(result))), SWIGTYPE_p_string, SWIG_POINTER_OWN |  0 );
22720   return resultobj;
22721 fail:
22722   return NULL;
22723 }
22724
22725
22726 SWIGINTERN PyObject *EltBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22727   PyObject *obj;
22728   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
22729   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__EltBase, SWIG_NewClientData(obj));
22730   return SWIG_Py_Void();
22731 }
22732
22733 SWIGINTERN PyObject *_wrap_Vertex_getX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22734   PyObject *resultobj = 0;
22735   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22736   void *argp1 = 0 ;
22737   int res1 = 0 ;
22738   PyObject * obj0 = 0 ;
22739   double result;
22740
22741   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getX",&obj0)) SWIG_fail;
22742   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22743   if (!SWIG_IsOK(res1)) {
22744     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getX" "', argument " "1"" of type '" "Hex::Vertex *""'");
22745   }
22746   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22747   result = (double)(arg1)->getX();
22748   resultobj = SWIG_From_double(static_cast< double >(result));
22749   return resultobj;
22750 fail:
22751   return NULL;
22752 }
22753
22754
22755 SWIGINTERN PyObject *_wrap_Vertex_getY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22756   PyObject *resultobj = 0;
22757   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22758   void *argp1 = 0 ;
22759   int res1 = 0 ;
22760   PyObject * obj0 = 0 ;
22761   double result;
22762
22763   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getY",&obj0)) SWIG_fail;
22764   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22765   if (!SWIG_IsOK(res1)) {
22766     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getY" "', argument " "1"" of type '" "Hex::Vertex *""'");
22767   }
22768   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22769   result = (double)(arg1)->getY();
22770   resultobj = SWIG_From_double(static_cast< double >(result));
22771   return resultobj;
22772 fail:
22773   return NULL;
22774 }
22775
22776
22777 SWIGINTERN PyObject *_wrap_Vertex_getZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22778   PyObject *resultobj = 0;
22779   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22780   void *argp1 = 0 ;
22781   int res1 = 0 ;
22782   PyObject * obj0 = 0 ;
22783   double result;
22784
22785   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getZ",&obj0)) SWIG_fail;
22786   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22787   if (!SWIG_IsOK(res1)) {
22788     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
22789   }
22790   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22791   result = (double)(arg1)->getZ();
22792   resultobj = SWIG_From_double(static_cast< double >(result));
22793   return resultobj;
22794 fail:
22795   return NULL;
22796 }
22797
22798
22799 SWIGINTERN PyObject *_wrap_Vertex_setX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22800   PyObject *resultobj = 0;
22801   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22802   double arg2 ;
22803   void *argp1 = 0 ;
22804   int res1 = 0 ;
22805   double val2 ;
22806   int ecode2 = 0 ;
22807   PyObject * obj0 = 0 ;
22808   PyObject * obj1 = 0 ;
22809
22810   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setX",&obj0,&obj1)) SWIG_fail;
22811   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22812   if (!SWIG_IsOK(res1)) {
22813     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setX" "', argument " "1"" of type '" "Hex::Vertex *""'");
22814   }
22815   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22816   ecode2 = SWIG_AsVal_double(obj1, &val2);
22817   if (!SWIG_IsOK(ecode2)) {
22818     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setX" "', argument " "2"" of type '" "double""'");
22819   }
22820   arg2 = static_cast< double >(val2);
22821   (arg1)->setX(arg2);
22822   resultobj = SWIG_Py_Void();
22823   return resultobj;
22824 fail:
22825   return NULL;
22826 }
22827
22828
22829 SWIGINTERN PyObject *_wrap_Vertex_setY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22830   PyObject *resultobj = 0;
22831   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22832   double arg2 ;
22833   void *argp1 = 0 ;
22834   int res1 = 0 ;
22835   double val2 ;
22836   int ecode2 = 0 ;
22837   PyObject * obj0 = 0 ;
22838   PyObject * obj1 = 0 ;
22839
22840   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setY",&obj0,&obj1)) SWIG_fail;
22841   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22842   if (!SWIG_IsOK(res1)) {
22843     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setY" "', argument " "1"" of type '" "Hex::Vertex *""'");
22844   }
22845   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22846   ecode2 = SWIG_AsVal_double(obj1, &val2);
22847   if (!SWIG_IsOK(ecode2)) {
22848     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setY" "', argument " "2"" of type '" "double""'");
22849   }
22850   arg2 = static_cast< double >(val2);
22851   (arg1)->setY(arg2);
22852   resultobj = SWIG_Py_Void();
22853   return resultobj;
22854 fail:
22855   return NULL;
22856 }
22857
22858
22859 SWIGINTERN PyObject *_wrap_Vertex_setZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22860   PyObject *resultobj = 0;
22861   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22862   double arg2 ;
22863   void *argp1 = 0 ;
22864   int res1 = 0 ;
22865   double val2 ;
22866   int ecode2 = 0 ;
22867   PyObject * obj0 = 0 ;
22868   PyObject * obj1 = 0 ;
22869
22870   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setZ",&obj0,&obj1)) SWIG_fail;
22871   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22872   if (!SWIG_IsOK(res1)) {
22873     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
22874   }
22875   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22876   ecode2 = SWIG_AsVal_double(obj1, &val2);
22877   if (!SWIG_IsOK(ecode2)) {
22878     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setZ" "', argument " "2"" of type '" "double""'");
22879   }
22880   arg2 = static_cast< double >(val2);
22881   (arg1)->setZ(arg2);
22882   resultobj = SWIG_Py_Void();
22883   return resultobj;
22884 fail:
22885   return NULL;
22886 }
22887
22888
22889 SWIGINTERN PyObject *_wrap_Vertex_getAssoX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22890   PyObject *resultobj = 0;
22891   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22892   void *argp1 = 0 ;
22893   int res1 = 0 ;
22894   PyObject * obj0 = 0 ;
22895   double result;
22896
22897   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoX",&obj0)) SWIG_fail;
22898   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22899   if (!SWIG_IsOK(res1)) {
22900     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoX" "', argument " "1"" of type '" "Hex::Vertex *""'");
22901   }
22902   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22903   result = (double)(arg1)->getAssoX();
22904   resultobj = SWIG_From_double(static_cast< double >(result));
22905   return resultobj;
22906 fail:
22907   return NULL;
22908 }
22909
22910
22911 SWIGINTERN PyObject *_wrap_Vertex_getAssoY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22912   PyObject *resultobj = 0;
22913   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22914   void *argp1 = 0 ;
22915   int res1 = 0 ;
22916   PyObject * obj0 = 0 ;
22917   double result;
22918
22919   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoY",&obj0)) SWIG_fail;
22920   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22921   if (!SWIG_IsOK(res1)) {
22922     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoY" "', argument " "1"" of type '" "Hex::Vertex *""'");
22923   }
22924   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22925   result = (double)(arg1)->getAssoY();
22926   resultobj = SWIG_From_double(static_cast< double >(result));
22927   return resultobj;
22928 fail:
22929   return NULL;
22930 }
22931
22932
22933 SWIGINTERN PyObject *_wrap_Vertex_getAssoZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22934   PyObject *resultobj = 0;
22935   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22936   void *argp1 = 0 ;
22937   int res1 = 0 ;
22938   PyObject * obj0 = 0 ;
22939   double result;
22940
22941   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_getAssoZ",&obj0)) SWIG_fail;
22942   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22943   if (!SWIG_IsOK(res1)) {
22944     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_getAssoZ" "', argument " "1"" of type '" "Hex::Vertex *""'");
22945   }
22946   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22947   result = (double)(arg1)->getAssoZ();
22948   resultobj = SWIG_From_double(static_cast< double >(result));
22949   return resultobj;
22950 fail:
22951   return NULL;
22952 }
22953
22954
22955 SWIGINTERN PyObject *_wrap_Vertex_setAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22956   PyObject *resultobj = 0;
22957   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22958   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
22959   int arg3 ;
22960   void *argp1 = 0 ;
22961   int res1 = 0 ;
22962   void *argp2 = 0 ;
22963   int res2 = 0 ;
22964   int val3 ;
22965   int ecode3 = 0 ;
22966   PyObject * obj0 = 0 ;
22967   PyObject * obj1 = 0 ;
22968   PyObject * obj2 = 0 ;
22969   int result;
22970
22971   if (!PyArg_ParseTuple(args,(char *)"OOO:Vertex_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
22972   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
22973   if (!SWIG_IsOK(res1)) {
22974     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setAssociation" "', argument " "1"" of type '" "Hex::Vertex *""'");
22975   }
22976   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
22977   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
22978   if (!SWIG_IsOK(res2)) {
22979     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vertex_setAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
22980   }
22981   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
22982   ecode3 = SWIG_AsVal_int(obj2, &val3);
22983   if (!SWIG_IsOK(ecode3)) {
22984     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vertex_setAssociation" "', argument " "3"" of type '" "int""'");
22985   }
22986   arg3 = static_cast< int >(val3);
22987   result = (int)(arg1)->setAssociation(arg2,arg3);
22988   resultobj = SWIG_From_int(static_cast< int >(result));
22989   return resultobj;
22990 fail:
22991   return NULL;
22992 }
22993
22994
22995 SWIGINTERN PyObject *_wrap_Vertex_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22996   PyObject *resultobj = 0;
22997   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
22998   void *argp1 = 0 ;
22999   int res1 = 0 ;
23000   PyObject * obj0 = 0 ;
23001
23002   if (!PyArg_ParseTuple(args,(char *)"O:Vertex_clearAssociation",&obj0)) SWIG_fail;
23003   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23004   if (!SWIG_IsOK(res1)) {
23005     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_clearAssociation" "', argument " "1"" of type '" "Hex::Vertex *""'");
23006   }
23007   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
23008   (arg1)->clearAssociation();
23009   resultobj = SWIG_Py_Void();
23010   return resultobj;
23011 fail:
23012   return NULL;
23013 }
23014
23015
23016 SWIGINTERN PyObject *_wrap_Vertex_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23017   PyObject *resultobj = 0;
23018   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
23019   double arg2 ;
23020   void *argp1 = 0 ;
23021   int res1 = 0 ;
23022   double val2 ;
23023   int ecode2 = 0 ;
23024   PyObject * obj0 = 0 ;
23025   PyObject * obj1 = 0 ;
23026
23027   if (!PyArg_ParseTuple(args,(char *)"OO:Vertex_setColor",&obj0,&obj1)) SWIG_fail;
23028   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23029   if (!SWIG_IsOK(res1)) {
23030     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vertex_setColor" "', argument " "1"" of type '" "Hex::Vertex *""'");
23031   }
23032   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
23033   ecode2 = SWIG_AsVal_double(obj1, &val2);
23034   if (!SWIG_IsOK(ecode2)) {
23035     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vertex_setColor" "', argument " "2"" of type '" "double""'");
23036   }
23037   arg2 = static_cast< double >(val2);
23038   (arg1)->setColor(arg2);
23039   resultobj = SWIG_Py_Void();
23040   return resultobj;
23041 fail:
23042   return NULL;
23043 }
23044
23045
23046 SWIGINTERN PyObject *_wrap_new_Vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23047   PyObject *resultobj = 0;
23048   Hex::Document *arg1 = (Hex::Document *) 0 ;
23049   double arg2 ;
23050   double arg3 ;
23051   double arg4 ;
23052   void *argp1 = 0 ;
23053   int res1 = 0 ;
23054   double val2 ;
23055   int ecode2 = 0 ;
23056   double val3 ;
23057   int ecode3 = 0 ;
23058   double val4 ;
23059   int ecode4 = 0 ;
23060   PyObject * obj0 = 0 ;
23061   PyObject * obj1 = 0 ;
23062   PyObject * obj2 = 0 ;
23063   PyObject * obj3 = 0 ;
23064   Hex::Vertex *result = 0 ;
23065
23066   if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23067   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
23068   if (!SWIG_IsOK(res1)) {
23069     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vertex" "', argument " "1"" of type '" "Hex::Document *""'");
23070   }
23071   arg1 = reinterpret_cast< Hex::Document * >(argp1);
23072   ecode2 = SWIG_AsVal_double(obj1, &val2);
23073   if (!SWIG_IsOK(ecode2)) {
23074     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vertex" "', argument " "2"" of type '" "double""'");
23075   }
23076   arg2 = static_cast< double >(val2);
23077   ecode3 = SWIG_AsVal_double(obj2, &val3);
23078   if (!SWIG_IsOK(ecode3)) {
23079     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vertex" "', argument " "3"" of type '" "double""'");
23080   }
23081   arg3 = static_cast< double >(val3);
23082   ecode4 = SWIG_AsVal_double(obj3, &val4);
23083   if (!SWIG_IsOK(ecode4)) {
23084     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vertex" "', argument " "4"" of type '" "double""'");
23085   }
23086   arg4 = static_cast< double >(val4);
23087   result = (Hex::Vertex *)new Hex::Vertex(arg1,arg2,arg3,arg4);
23088   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, SWIG_POINTER_NEW |  0 );
23089   return resultobj;
23090 fail:
23091   return NULL;
23092 }
23093
23094
23095 SWIGINTERN PyObject *_wrap_delete_Vertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23096   PyObject *resultobj = 0;
23097   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
23098   void *argp1 = 0 ;
23099   int res1 = 0 ;
23100   PyObject * obj0 = 0 ;
23101
23102   if (!PyArg_ParseTuple(args,(char *)"O:delete_Vertex",&obj0)) SWIG_fail;
23103   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, SWIG_POINTER_DISOWN |  0 );
23104   if (!SWIG_IsOK(res1)) {
23105     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vertex" "', argument " "1"" of type '" "Hex::Vertex *""'");
23106   }
23107   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
23108   delete arg1;
23109   resultobj = SWIG_Py_Void();
23110   return resultobj;
23111 fail:
23112   return NULL;
23113 }
23114
23115
23116 SWIGINTERN PyObject *Vertex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23117   PyObject *obj;
23118   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
23119   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vertex, SWIG_NewClientData(obj));
23120   return SWIG_Py_Void();
23121 }
23122
23123 SWIGINTERN PyObject *_wrap_Edge_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23124   PyObject *resultobj = 0;
23125   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23126   int arg2 ;
23127   void *argp1 = 0 ;
23128   int res1 = 0 ;
23129   int val2 ;
23130   int ecode2 = 0 ;
23131   PyObject * obj0 = 0 ;
23132   PyObject * obj1 = 0 ;
23133   Hex::Vertex *result = 0 ;
23134
23135   if (!PyArg_ParseTuple(args,(char *)"OO:Edge_getVertex",&obj0,&obj1)) SWIG_fail;
23136   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
23137   if (!SWIG_IsOK(res1)) {
23138     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getVertex" "', argument " "1"" of type '" "Hex::Edge *""'");
23139   }
23140   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23141   ecode2 = SWIG_AsVal_int(obj1, &val2);
23142   if (!SWIG_IsOK(ecode2)) {
23143     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Edge_getVertex" "', argument " "2"" of type '" "int""'");
23144   }
23145   arg2 = static_cast< int >(val2);
23146   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
23147   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23148   return resultobj;
23149 fail:
23150   return NULL;
23151 }
23152
23153
23154 SWIGINTERN PyObject *_wrap_Edge_addAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23155   PyObject *resultobj = 0;
23156   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23157   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
23158   int arg3 ;
23159   double arg4 ;
23160   double arg5 ;
23161   void *argp1 = 0 ;
23162   int res1 = 0 ;
23163   void *argp2 = 0 ;
23164   int res2 = 0 ;
23165   int val3 ;
23166   int ecode3 = 0 ;
23167   double val4 ;
23168   int ecode4 = 0 ;
23169   double val5 ;
23170   int ecode5 = 0 ;
23171   PyObject * obj0 = 0 ;
23172   PyObject * obj1 = 0 ;
23173   PyObject * obj2 = 0 ;
23174   PyObject * obj3 = 0 ;
23175   PyObject * obj4 = 0 ;
23176   int result;
23177
23178   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Edge_addAssociation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23179   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
23180   if (!SWIG_IsOK(res1)) {
23181     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_addAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
23182   }
23183   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23184   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
23185   if (!SWIG_IsOK(res2)) {
23186     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_addAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
23187   }
23188   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
23189   ecode3 = SWIG_AsVal_int(obj2, &val3);
23190   if (!SWIG_IsOK(ecode3)) {
23191     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Edge_addAssociation" "', argument " "3"" of type '" "int""'");
23192   }
23193   arg3 = static_cast< int >(val3);
23194   ecode4 = SWIG_AsVal_double(obj3, &val4);
23195   if (!SWIG_IsOK(ecode4)) {
23196     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Edge_addAssociation" "', argument " "4"" of type '" "double""'");
23197   }
23198   arg4 = static_cast< double >(val4);
23199   ecode5 = SWIG_AsVal_double(obj4, &val5);
23200   if (!SWIG_IsOK(ecode5)) {
23201     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Edge_addAssociation" "', argument " "5"" of type '" "double""'");
23202   }
23203   arg5 = static_cast< double >(val5);
23204   result = (int)(arg1)->addAssociation(arg2,arg3,arg4,arg5);
23205   resultobj = SWIG_From_int(static_cast< int >(result));
23206   return resultobj;
23207 fail:
23208   return NULL;
23209 }
23210
23211
23212 SWIGINTERN PyObject *_wrap_Edge_setAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23213   PyObject *resultobj = 0;
23214   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23215   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
23216   int arg3 ;
23217   void *argp1 = 0 ;
23218   int res1 = 0 ;
23219   void *argp2 = 0 ;
23220   int res2 = 0 ;
23221   int val3 ;
23222   int ecode3 = 0 ;
23223   PyObject * obj0 = 0 ;
23224   PyObject * obj1 = 0 ;
23225   PyObject * obj2 = 0 ;
23226   int result;
23227
23228   if (!PyArg_ParseTuple(args,(char *)"OOO:Edge_setAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
23229   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
23230   if (!SWIG_IsOK(res1)) {
23231     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_setAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
23232   }
23233   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23234   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
23235   if (!SWIG_IsOK(res2)) {
23236     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_setAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
23237   }
23238   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
23239   ecode3 = SWIG_AsVal_int(obj2, &val3);
23240   if (!SWIG_IsOK(ecode3)) {
23241     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Edge_setAssociation" "', argument " "3"" of type '" "int""'");
23242   }
23243   arg3 = static_cast< int >(val3);
23244   result = (int)(arg1)->setAssociation(arg2,arg3);
23245   resultobj = SWIG_From_int(static_cast< int >(result));
23246   return resultobj;
23247 fail:
23248   return NULL;
23249 }
23250
23251
23252 SWIGINTERN PyObject *_wrap_Edge_findAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23253   PyObject *resultobj = 0;
23254   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23255   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
23256   void *argp1 = 0 ;
23257   int res1 = 0 ;
23258   void *argp2 = 0 ;
23259   int res2 = 0 ;
23260   PyObject * obj0 = 0 ;
23261   PyObject * obj1 = 0 ;
23262   int result;
23263
23264   if (!PyArg_ParseTuple(args,(char *)"OO:Edge_findAssociation",&obj0,&obj1)) SWIG_fail;
23265   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
23266   if (!SWIG_IsOK(res1)) {
23267     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_findAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
23268   }
23269   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23270   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
23271   if (!SWIG_IsOK(res2)) {
23272     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Edge_findAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
23273   }
23274   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
23275   result = (int)(arg1)->findAssociation(arg2);
23276   resultobj = SWIG_From_int(static_cast< int >(result));
23277   return resultobj;
23278 fail:
23279   return NULL;
23280 }
23281
23282
23283 SWIGINTERN PyObject *_wrap_Edge_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23284   PyObject *resultobj = 0;
23285   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23286   void *argp1 = 0 ;
23287   int res1 = 0 ;
23288   PyObject * obj0 = 0 ;
23289
23290   if (!PyArg_ParseTuple(args,(char *)"O:Edge_clearAssociation",&obj0)) SWIG_fail;
23291   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
23292   if (!SWIG_IsOK(res1)) {
23293     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_clearAssociation" "', argument " "1"" of type '" "Hex::Edge *""'");
23294   }
23295   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23296   (arg1)->clearAssociation();
23297   resultobj = SWIG_Py_Void();
23298   return resultobj;
23299 fail:
23300   return NULL;
23301 }
23302
23303
23304 SWIGINTERN PyObject *_wrap_Edge_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23305   PyObject *resultobj = 0;
23306   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23307   double arg2 ;
23308   void *argp1 = 0 ;
23309   int res1 = 0 ;
23310   double val2 ;
23311   int ecode2 = 0 ;
23312   PyObject * obj0 = 0 ;
23313   PyObject * obj1 = 0 ;
23314
23315   if (!PyArg_ParseTuple(args,(char *)"OO:Edge_setColor",&obj0,&obj1)) SWIG_fail;
23316   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
23317   if (!SWIG_IsOK(res1)) {
23318     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_setColor" "', argument " "1"" of type '" "Hex::Edge *""'");
23319   }
23320   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23321   ecode2 = SWIG_AsVal_double(obj1, &val2);
23322   if (!SWIG_IsOK(ecode2)) {
23323     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Edge_setColor" "', argument " "2"" of type '" "double""'");
23324   }
23325   arg2 = static_cast< double >(val2);
23326   (arg1)->setColor(arg2);
23327   resultobj = SWIG_Py_Void();
23328   return resultobj;
23329 fail:
23330   return NULL;
23331 }
23332
23333
23334 SWIGINTERN PyObject *_wrap_Edge_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23335   PyObject *resultobj = 0;
23336   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23337   void *argp1 = 0 ;
23338   int res1 = 0 ;
23339   PyObject * obj0 = 0 ;
23340   bool result;
23341
23342   if (!PyArg_ParseTuple(args,(char *)"O:Edge_getWay",&obj0)) SWIG_fail;
23343   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
23344   if (!SWIG_IsOK(res1)) {
23345     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getWay" "', argument " "1"" of type '" "Hex::Edge *""'");
23346   }
23347   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23348   result = (bool)(arg1)->getWay();
23349   resultobj = SWIG_From_bool(static_cast< bool >(result));
23350   return resultobj;
23351 fail:
23352   return NULL;
23353 }
23354
23355
23356 SWIGINTERN PyObject *_wrap_Edge_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23357   PyObject *resultobj = 0;
23358   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23359   void *argp1 = 0 ;
23360   int res1 = 0 ;
23361   PyObject * obj0 = 0 ;
23362   double result;
23363
23364   if (!PyArg_ParseTuple(args,(char *)"O:Edge_getLength",&obj0)) SWIG_fail;
23365   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, 0 |  0 );
23366   if (!SWIG_IsOK(res1)) {
23367     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge_getLength" "', argument " "1"" of type '" "Hex::Edge *""'");
23368   }
23369   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23370   result = (double)(arg1)->getLength();
23371   resultobj = SWIG_From_double(static_cast< double >(result));
23372   return resultobj;
23373 fail:
23374   return NULL;
23375 }
23376
23377
23378 SWIGINTERN PyObject *_wrap_new_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23379   PyObject *resultobj = 0;
23380   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
23381   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
23382   void *argp1 = 0 ;
23383   int res1 = 0 ;
23384   void *argp2 = 0 ;
23385   int res2 = 0 ;
23386   PyObject * obj0 = 0 ;
23387   PyObject * obj1 = 0 ;
23388   Hex::Edge *result = 0 ;
23389
23390   if (!PyArg_ParseTuple(args,(char *)"OO:new_Edge",&obj0,&obj1)) SWIG_fail;
23391   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23392   if (!SWIG_IsOK(res1)) {
23393     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Edge" "', argument " "1"" of type '" "Hex::Vertex *""'");
23394   }
23395   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
23396   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23397   if (!SWIG_IsOK(res2)) {
23398     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Edge" "', argument " "2"" of type '" "Hex::Vertex *""'");
23399   }
23400   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
23401   result = (Hex::Edge *)new Hex::Edge(arg1,arg2);
23402   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, SWIG_POINTER_NEW |  0 );
23403   return resultobj;
23404 fail:
23405   return NULL;
23406 }
23407
23408
23409 SWIGINTERN PyObject *_wrap_delete_Edge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23410   PyObject *resultobj = 0;
23411   Hex::Edge *arg1 = (Hex::Edge *) 0 ;
23412   void *argp1 = 0 ;
23413   int res1 = 0 ;
23414   PyObject * obj0 = 0 ;
23415
23416   if (!PyArg_ParseTuple(args,(char *)"O:delete_Edge",&obj0)) SWIG_fail;
23417   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Edge, SWIG_POINTER_DISOWN |  0 );
23418   if (!SWIG_IsOK(res1)) {
23419     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Edge" "', argument " "1"" of type '" "Hex::Edge *""'");
23420   }
23421   arg1 = reinterpret_cast< Hex::Edge * >(argp1);
23422   delete arg1;
23423   resultobj = SWIG_Py_Void();
23424   return resultobj;
23425 fail:
23426   return NULL;
23427 }
23428
23429
23430 SWIGINTERN PyObject *Edge_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23431   PyObject *obj;
23432   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
23433   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Edge, SWIG_NewClientData(obj));
23434   return SWIG_Py_Void();
23435 }
23436
23437 SWIGINTERN PyObject *_wrap_Quad_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23438   PyObject *resultobj = 0;
23439   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23440   int arg2 ;
23441   void *argp1 = 0 ;
23442   int res1 = 0 ;
23443   int val2 ;
23444   int ecode2 = 0 ;
23445   PyObject * obj0 = 0 ;
23446   PyObject * obj1 = 0 ;
23447   Hex::Edge *result = 0 ;
23448
23449   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getEdge",&obj0,&obj1)) SWIG_fail;
23450   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23451   if (!SWIG_IsOK(res1)) {
23452     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getEdge" "', argument " "1"" of type '" "Hex::Quad *""'");
23453   }
23454   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23455   ecode2 = SWIG_AsVal_int(obj1, &val2);
23456   if (!SWIG_IsOK(ecode2)) {
23457     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_getEdge" "', argument " "2"" of type '" "int""'");
23458   }
23459   arg2 = static_cast< int >(val2);
23460   result = (Hex::Edge *)(arg1)->getEdge(arg2);
23461   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
23462   return resultobj;
23463 fail:
23464   return NULL;
23465 }
23466
23467
23468 SWIGINTERN PyObject *_wrap_Quad_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23469   PyObject *resultobj = 0;
23470   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23471   int arg2 ;
23472   void *argp1 = 0 ;
23473   int res1 = 0 ;
23474   int val2 ;
23475   int ecode2 = 0 ;
23476   PyObject * obj0 = 0 ;
23477   PyObject * obj1 = 0 ;
23478   Hex::Vertex *result = 0 ;
23479
23480   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getVertex",&obj0,&obj1)) SWIG_fail;
23481   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23482   if (!SWIG_IsOK(res1)) {
23483     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getVertex" "', argument " "1"" of type '" "Hex::Quad *""'");
23484   }
23485   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23486   ecode2 = SWIG_AsVal_int(obj1, &val2);
23487   if (!SWIG_IsOK(ecode2)) {
23488     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_getVertex" "', argument " "2"" of type '" "int""'");
23489   }
23490   arg2 = static_cast< int >(val2);
23491   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
23492   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23493   return resultobj;
23494 fail:
23495   return NULL;
23496 }
23497
23498
23499 SWIGINTERN PyObject *_wrap_Quad_addAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23500   PyObject *resultobj = 0;
23501   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23502   Hex::NewShape *arg2 = (Hex::NewShape *) 0 ;
23503   int arg3 ;
23504   void *argp1 = 0 ;
23505   int res1 = 0 ;
23506   void *argp2 = 0 ;
23507   int res2 = 0 ;
23508   int val3 ;
23509   int ecode3 = 0 ;
23510   PyObject * obj0 = 0 ;
23511   PyObject * obj1 = 0 ;
23512   PyObject * obj2 = 0 ;
23513   int result;
23514
23515   if (!PyArg_ParseTuple(args,(char *)"OOO:Quad_addAssociation",&obj0,&obj1,&obj2)) SWIG_fail;
23516   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23517   if (!SWIG_IsOK(res1)) {
23518     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_addAssociation" "', argument " "1"" of type '" "Hex::Quad *""'");
23519   }
23520   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23521   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
23522   if (!SWIG_IsOK(res2)) {
23523     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_addAssociation" "', argument " "2"" of type '" "Hex::NewShape *""'");
23524   }
23525   arg2 = reinterpret_cast< Hex::NewShape * >(argp2);
23526   ecode3 = SWIG_AsVal_int(obj2, &val3);
23527   if (!SWIG_IsOK(ecode3)) {
23528     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quad_addAssociation" "', argument " "3"" of type '" "int""'");
23529   }
23530   arg3 = static_cast< int >(val3);
23531   result = (int)(arg1)->addAssociation(arg2,arg3);
23532   resultobj = SWIG_From_int(static_cast< int >(result));
23533   return resultobj;
23534 fail:
23535   return NULL;
23536 }
23537
23538
23539 SWIGINTERN PyObject *_wrap_Quad_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23540   PyObject *resultobj = 0;
23541   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23542   void *argp1 = 0 ;
23543   int res1 = 0 ;
23544   PyObject * obj0 = 0 ;
23545
23546   if (!PyArg_ParseTuple(args,(char *)"O:Quad_clearAssociation",&obj0)) SWIG_fail;
23547   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23548   if (!SWIG_IsOK(res1)) {
23549     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_clearAssociation" "', argument " "1"" of type '" "Hex::Quad *""'");
23550   }
23551   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23552   (arg1)->clearAssociation();
23553   resultobj = SWIG_Py_Void();
23554   return resultobj;
23555 fail:
23556   return NULL;
23557 }
23558
23559
23560 SWIGINTERN PyObject *_wrap_Quad_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23561   PyObject *resultobj = 0;
23562   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23563   double arg2 ;
23564   void *argp1 = 0 ;
23565   int res1 = 0 ;
23566   double val2 ;
23567   int ecode2 = 0 ;
23568   PyObject * obj0 = 0 ;
23569   PyObject * obj1 = 0 ;
23570
23571   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_setColor",&obj0,&obj1)) SWIG_fail;
23572   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23573   if (!SWIG_IsOK(res1)) {
23574     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_setColor" "', argument " "1"" of type '" "Hex::Quad *""'");
23575   }
23576   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23577   ecode2 = SWIG_AsVal_double(obj1, &val2);
23578   if (!SWIG_IsOK(ecode2)) {
23579     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Quad_setColor" "', argument " "2"" of type '" "double""'");
23580   }
23581   arg2 = static_cast< double >(val2);
23582   (arg1)->setColor(arg2);
23583   resultobj = SWIG_Py_Void();
23584   return resultobj;
23585 fail:
23586   return NULL;
23587 }
23588
23589
23590 SWIGINTERN PyObject *_wrap_Quad_nearestVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23591   PyObject *resultobj = 0;
23592   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23593   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
23594   void *argp1 = 0 ;
23595   int res1 = 0 ;
23596   void *argp2 = 0 ;
23597   int res2 = 0 ;
23598   PyObject * obj0 = 0 ;
23599   PyObject * obj1 = 0 ;
23600   Hex::Vertex *result = 0 ;
23601
23602   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_nearestVertex",&obj0,&obj1)) SWIG_fail;
23603   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23604   if (!SWIG_IsOK(res1)) {
23605     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_nearestVertex" "', argument " "1"" of type '" "Hex::Quad *""'");
23606   }
23607   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23608   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23609   if (!SWIG_IsOK(res2)) {
23610     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_nearestVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
23611   }
23612   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
23613   result = (Hex::Vertex *)(arg1)->nearestVertex(arg2);
23614   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23615   return resultobj;
23616 fail:
23617   return NULL;
23618 }
23619
23620
23621 SWIGINTERN PyObject *_wrap_Quad_getCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23622   PyObject *resultobj = 0;
23623   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23624   double *arg2 = (double *) 0 ;
23625   void *argp1 = 0 ;
23626   int res1 = 0 ;
23627   void *argp2 = 0 ;
23628   int res2 = 0 ;
23629   PyObject * obj0 = 0 ;
23630   PyObject * obj1 = 0 ;
23631   double *result = 0 ;
23632
23633   if (!PyArg_ParseTuple(args,(char *)"OO:Quad_getCenter",&obj0,&obj1)) SWIG_fail;
23634   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23635   if (!SWIG_IsOK(res1)) {
23636     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad_getCenter" "', argument " "1"" of type '" "Hex::Quad *""'");
23637   }
23638   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23639   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
23640   if (!SWIG_IsOK(res2)) {
23641     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad_getCenter" "', argument " "2"" of type '" "double *""'");
23642   }
23643   arg2 = reinterpret_cast< double * >(argp2);
23644   result = (double *)(arg1)->getCenter(arg2);
23645   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
23646   return resultobj;
23647 fail:
23648   return NULL;
23649 }
23650
23651
23652 SWIGINTERN PyObject *_wrap_new_Quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23653   PyObject *resultobj = 0;
23654   Hex::Vertex *arg1 = (Hex::Vertex *) 0 ;
23655   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
23656   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
23657   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
23658   void *argp1 = 0 ;
23659   int res1 = 0 ;
23660   void *argp2 = 0 ;
23661   int res2 = 0 ;
23662   void *argp3 = 0 ;
23663   int res3 = 0 ;
23664   void *argp4 = 0 ;
23665   int res4 = 0 ;
23666   PyObject * obj0 = 0 ;
23667   PyObject * obj1 = 0 ;
23668   PyObject * obj2 = 0 ;
23669   PyObject * obj3 = 0 ;
23670   Hex::Quad *result = 0 ;
23671
23672   if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Quad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23673   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23674   if (!SWIG_IsOK(res1)) {
23675     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Quad" "', argument " "1"" of type '" "Hex::Vertex *""'");
23676   }
23677   arg1 = reinterpret_cast< Hex::Vertex * >(argp1);
23678   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23679   if (!SWIG_IsOK(res2)) {
23680     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Quad" "', argument " "2"" of type '" "Hex::Vertex *""'");
23681   }
23682   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
23683   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23684   if (!SWIG_IsOK(res3)) {
23685     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Quad" "', argument " "3"" of type '" "Hex::Vertex *""'");
23686   }
23687   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
23688   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23689   if (!SWIG_IsOK(res4)) {
23690     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Quad" "', argument " "4"" of type '" "Hex::Vertex *""'");
23691   }
23692   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
23693   result = (Hex::Quad *)new Hex::Quad(arg1,arg2,arg3,arg4);
23694   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, SWIG_POINTER_NEW |  0 );
23695   return resultobj;
23696 fail:
23697   return NULL;
23698 }
23699
23700
23701 SWIGINTERN PyObject *_wrap_delete_Quad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23702   PyObject *resultobj = 0;
23703   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23704   void *argp1 = 0 ;
23705   int res1 = 0 ;
23706   PyObject * obj0 = 0 ;
23707
23708   if (!PyArg_ParseTuple(args,(char *)"O:delete_Quad",&obj0)) SWIG_fail;
23709   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, SWIG_POINTER_DISOWN |  0 );
23710   if (!SWIG_IsOK(res1)) {
23711     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Quad" "', argument " "1"" of type '" "Hex::Quad *""'");
23712   }
23713   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23714   delete arg1;
23715   resultobj = SWIG_Py_Void();
23716   return resultobj;
23717 fail:
23718   return NULL;
23719 }
23720
23721
23722 SWIGINTERN PyObject *Quad_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23723   PyObject *obj;
23724   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
23725   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Quad, SWIG_NewClientData(obj));
23726   return SWIG_Py_Void();
23727 }
23728
23729 SWIGINTERN PyObject *_wrap_Hexa_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23730   PyObject *resultobj = 0;
23731   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
23732   int arg2 ;
23733   void *argp1 = 0 ;
23734   int res1 = 0 ;
23735   int val2 ;
23736   int ecode2 = 0 ;
23737   PyObject * obj0 = 0 ;
23738   PyObject * obj1 = 0 ;
23739   Hex::Quad *result = 0 ;
23740
23741   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getQuad",&obj0,&obj1)) SWIG_fail;
23742   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
23743   if (!SWIG_IsOK(res1)) {
23744     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getQuad" "', argument " "1"" of type '" "Hex::Hexa *""'");
23745   }
23746   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
23747   ecode2 = SWIG_AsVal_int(obj1, &val2);
23748   if (!SWIG_IsOK(ecode2)) {
23749     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getQuad" "', argument " "2"" of type '" "int""'");
23750   }
23751   arg2 = static_cast< int >(val2);
23752   result = (Hex::Quad *)(arg1)->getQuad(arg2);
23753   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
23754   return resultobj;
23755 fail:
23756   return NULL;
23757 }
23758
23759
23760 SWIGINTERN PyObject *_wrap_Hexa_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23761   PyObject *resultobj = 0;
23762   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
23763   int arg2 ;
23764   void *argp1 = 0 ;
23765   int res1 = 0 ;
23766   int val2 ;
23767   int ecode2 = 0 ;
23768   PyObject * obj0 = 0 ;
23769   PyObject * obj1 = 0 ;
23770   Hex::Edge *result = 0 ;
23771
23772   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getEdge",&obj0,&obj1)) SWIG_fail;
23773   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
23774   if (!SWIG_IsOK(res1)) {
23775     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getEdge" "', argument " "1"" of type '" "Hex::Hexa *""'");
23776   }
23777   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
23778   ecode2 = SWIG_AsVal_int(obj1, &val2);
23779   if (!SWIG_IsOK(ecode2)) {
23780     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getEdge" "', argument " "2"" of type '" "int""'");
23781   }
23782   arg2 = static_cast< int >(val2);
23783   result = (Hex::Edge *)(arg1)->getEdge(arg2);
23784   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
23785   return resultobj;
23786 fail:
23787   return NULL;
23788 }
23789
23790
23791 SWIGINTERN PyObject *_wrap_Hexa_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23792   PyObject *resultobj = 0;
23793   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
23794   int arg2 ;
23795   void *argp1 = 0 ;
23796   int res1 = 0 ;
23797   int val2 ;
23798   int ecode2 = 0 ;
23799   PyObject * obj0 = 0 ;
23800   PyObject * obj1 = 0 ;
23801   Hex::Vertex *result = 0 ;
23802
23803   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_getVertex",&obj0,&obj1)) SWIG_fail;
23804   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
23805   if (!SWIG_IsOK(res1)) {
23806     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_getVertex" "', argument " "1"" of type '" "Hex::Hexa *""'");
23807   }
23808   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
23809   ecode2 = SWIG_AsVal_int(obj1, &val2);
23810   if (!SWIG_IsOK(ecode2)) {
23811     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_getVertex" "', argument " "2"" of type '" "int""'");
23812   }
23813   arg2 = static_cast< int >(val2);
23814   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
23815   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
23816   return resultobj;
23817 fail:
23818   return NULL;
23819 }
23820
23821
23822 SWIGINTERN PyObject *_wrap_Hexa_setColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23823   PyObject *resultobj = 0;
23824   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
23825   double arg2 ;
23826   void *argp1 = 0 ;
23827   int res1 = 0 ;
23828   double val2 ;
23829   int ecode2 = 0 ;
23830   PyObject * obj0 = 0 ;
23831   PyObject * obj1 = 0 ;
23832
23833   if (!PyArg_ParseTuple(args,(char *)"OO:Hexa_setColor",&obj0,&obj1)) SWIG_fail;
23834   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
23835   if (!SWIG_IsOK(res1)) {
23836     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hexa_setColor" "', argument " "1"" of type '" "Hex::Hexa *""'");
23837   }
23838   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
23839   ecode2 = SWIG_AsVal_double(obj1, &val2);
23840   if (!SWIG_IsOK(ecode2)) {
23841     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hexa_setColor" "', argument " "2"" of type '" "double""'");
23842   }
23843   arg2 = static_cast< double >(val2);
23844   (arg1)->setColor(arg2);
23845   resultobj = SWIG_Py_Void();
23846   return resultobj;
23847 fail:
23848   return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_new_Hexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853   PyObject *resultobj = 0;
23854   Hex::Quad *arg1 = (Hex::Quad *) 0 ;
23855   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
23856   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
23857   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
23858   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
23859   Hex::Quad *arg6 = (Hex::Quad *) 0 ;
23860   void *argp1 = 0 ;
23861   int res1 = 0 ;
23862   void *argp2 = 0 ;
23863   int res2 = 0 ;
23864   void *argp3 = 0 ;
23865   int res3 = 0 ;
23866   void *argp4 = 0 ;
23867   int res4 = 0 ;
23868   void *argp5 = 0 ;
23869   int res5 = 0 ;
23870   void *argp6 = 0 ;
23871   int res6 = 0 ;
23872   PyObject * obj0 = 0 ;
23873   PyObject * obj1 = 0 ;
23874   PyObject * obj2 = 0 ;
23875   PyObject * obj3 = 0 ;
23876   PyObject * obj4 = 0 ;
23877   PyObject * obj5 = 0 ;
23878   Hex::Hexa *result = 0 ;
23879
23880   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_Hexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
23881   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23882   if (!SWIG_IsOK(res1)) {
23883     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Hexa" "', argument " "1"" of type '" "Hex::Quad *""'");
23884   }
23885   arg1 = reinterpret_cast< Hex::Quad * >(argp1);
23886   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23887   if (!SWIG_IsOK(res2)) {
23888     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Hexa" "', argument " "2"" of type '" "Hex::Quad *""'");
23889   }
23890   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
23891   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23892   if (!SWIG_IsOK(res3)) {
23893     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Hexa" "', argument " "3"" of type '" "Hex::Quad *""'");
23894   }
23895   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
23896   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23897   if (!SWIG_IsOK(res4)) {
23898     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Hexa" "', argument " "4"" of type '" "Hex::Quad *""'");
23899   }
23900   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
23901   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23902   if (!SWIG_IsOK(res5)) {
23903     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Hexa" "', argument " "5"" of type '" "Hex::Quad *""'");
23904   }
23905   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
23906   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 |  0 );
23907   if (!SWIG_IsOK(res6)) {
23908     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Hexa" "', argument " "6"" of type '" "Hex::Quad *""'");
23909   }
23910   arg6 = reinterpret_cast< Hex::Quad * >(argp6);
23911   result = (Hex::Hexa *)new Hex::Hexa(arg1,arg2,arg3,arg4,arg5,arg6);
23912   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, SWIG_POINTER_NEW |  0 );
23913   return resultobj;
23914 fail:
23915   return NULL;
23916 }
23917
23918
23919 SWIGINTERN PyObject *_wrap_delete_Hexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23920   PyObject *resultobj = 0;
23921   Hex::Hexa *arg1 = (Hex::Hexa *) 0 ;
23922   void *argp1 = 0 ;
23923   int res1 = 0 ;
23924   PyObject * obj0 = 0 ;
23925
23926   if (!PyArg_ParseTuple(args,(char *)"O:delete_Hexa",&obj0)) SWIG_fail;
23927   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hexa, SWIG_POINTER_DISOWN |  0 );
23928   if (!SWIG_IsOK(res1)) {
23929     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hexa" "', argument " "1"" of type '" "Hex::Hexa *""'");
23930   }
23931   arg1 = reinterpret_cast< Hex::Hexa * >(argp1);
23932   delete arg1;
23933   resultobj = SWIG_Py_Void();
23934   return resultobj;
23935 fail:
23936   return NULL;
23937 }
23938
23939
23940 SWIGINTERN PyObject *Hexa_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23941   PyObject *obj;
23942   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
23943   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hexa, SWIG_NewClientData(obj));
23944   return SWIG_Py_Void();
23945 }
23946
23947 SWIGINTERN PyObject *_wrap_Vector_getDx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23948   PyObject *resultobj = 0;
23949   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
23950   void *argp1 = 0 ;
23951   int res1 = 0 ;
23952   PyObject * obj0 = 0 ;
23953   double result;
23954
23955   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDx",&obj0)) SWIG_fail;
23956   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
23957   if (!SWIG_IsOK(res1)) {
23958     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDx" "', argument " "1"" of type '" "Hex::Vector *""'");
23959   }
23960   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
23961   result = (double)(arg1)->getDx();
23962   resultobj = SWIG_From_double(static_cast< double >(result));
23963   return resultobj;
23964 fail:
23965   return NULL;
23966 }
23967
23968
23969 SWIGINTERN PyObject *_wrap_Vector_getDy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23970   PyObject *resultobj = 0;
23971   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
23972   void *argp1 = 0 ;
23973   int res1 = 0 ;
23974   PyObject * obj0 = 0 ;
23975   double result;
23976
23977   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDy",&obj0)) SWIG_fail;
23978   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
23979   if (!SWIG_IsOK(res1)) {
23980     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDy" "', argument " "1"" of type '" "Hex::Vector *""'");
23981   }
23982   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
23983   result = (double)(arg1)->getDy();
23984   resultobj = SWIG_From_double(static_cast< double >(result));
23985   return resultobj;
23986 fail:
23987   return NULL;
23988 }
23989
23990
23991 SWIGINTERN PyObject *_wrap_Vector_getDz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23992   PyObject *resultobj = 0;
23993   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
23994   void *argp1 = 0 ;
23995   int res1 = 0 ;
23996   PyObject * obj0 = 0 ;
23997   double result;
23998
23999   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getDz",&obj0)) SWIG_fail;
24000   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
24001   if (!SWIG_IsOK(res1)) {
24002     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getDz" "', argument " "1"" of type '" "Hex::Vector *""'");
24003   }
24004   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
24005   result = (double)(arg1)->getDz();
24006   resultobj = SWIG_From_double(static_cast< double >(result));
24007   return resultobj;
24008 fail:
24009   return NULL;
24010 }
24011
24012
24013 SWIGINTERN PyObject *_wrap_Vector_getNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24014   PyObject *resultobj = 0;
24015   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
24016   void *argp1 = 0 ;
24017   int res1 = 0 ;
24018   PyObject * obj0 = 0 ;
24019   double result;
24020
24021   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getNorm",&obj0)) SWIG_fail;
24022   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
24023   if (!SWIG_IsOK(res1)) {
24024     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getNorm" "', argument " "1"" of type '" "Hex::Vector *""'");
24025   }
24026   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
24027   result = (double)(arg1)->getNorm();
24028   resultobj = SWIG_From_double(static_cast< double >(result));
24029   return resultobj;
24030 fail:
24031   return NULL;
24032 }
24033
24034
24035 SWIGINTERN PyObject *_wrap_Vector_getAngleX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24036   PyObject *resultobj = 0;
24037   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
24038   void *argp1 = 0 ;
24039   int res1 = 0 ;
24040   PyObject * obj0 = 0 ;
24041   double result;
24042
24043   if (!PyArg_ParseTuple(args,(char *)"O:Vector_getAngleX",&obj0)) SWIG_fail;
24044   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, 0 |  0 );
24045   if (!SWIG_IsOK(res1)) {
24046     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_getAngleX" "', argument " "1"" of type '" "Hex::Vector *""'");
24047   }
24048   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
24049   result = (double)(arg1)->getAngleX();
24050   resultobj = SWIG_From_double(static_cast< double >(result));
24051   return resultobj;
24052 fail:
24053   return NULL;
24054 }
24055
24056
24057 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24058   PyObject *resultobj = 0;
24059   Hex::Document *arg1 = (Hex::Document *) 0 ;
24060   double arg2 ;
24061   double arg3 ;
24062   double arg4 ;
24063   void *argp1 = 0 ;
24064   int res1 = 0 ;
24065   double val2 ;
24066   int ecode2 = 0 ;
24067   double val3 ;
24068   int ecode3 = 0 ;
24069   double val4 ;
24070   int ecode4 = 0 ;
24071   PyObject * obj0 = 0 ;
24072   PyObject * obj1 = 0 ;
24073   PyObject * obj2 = 0 ;
24074   PyObject * obj3 = 0 ;
24075   Hex::Vector *result = 0 ;
24076
24077   if (!PyArg_ParseTuple(args,(char *)"OOOO:new_Vector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24078   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24079   if (!SWIG_IsOK(res1)) {
24080     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
24081   }
24082   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24083   ecode2 = SWIG_AsVal_double(obj1, &val2);
24084   if (!SWIG_IsOK(ecode2)) {
24085     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
24086   }
24087   arg2 = static_cast< double >(val2);
24088   ecode3 = SWIG_AsVal_double(obj2, &val3);
24089   if (!SWIG_IsOK(ecode3)) {
24090     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vector" "', argument " "3"" of type '" "double""'");
24091   }
24092   arg3 = static_cast< double >(val3);
24093   ecode4 = SWIG_AsVal_double(obj3, &val4);
24094   if (!SWIG_IsOK(ecode4)) {
24095     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Vector" "', argument " "4"" of type '" "double""'");
24096   }
24097   arg4 = static_cast< double >(val4);
24098   result = (Hex::Vector *)new Hex::Vector(arg1,arg2,arg3,arg4);
24099   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
24100   return resultobj;
24101 fail:
24102   return NULL;
24103 }
24104
24105
24106 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24107   PyObject *resultobj = 0;
24108   Hex::Document *arg1 = (Hex::Document *) 0 ;
24109   double arg2 ;
24110   double arg3 ;
24111   void *argp1 = 0 ;
24112   int res1 = 0 ;
24113   double val2 ;
24114   int ecode2 = 0 ;
24115   double val3 ;
24116   int ecode3 = 0 ;
24117   PyObject * obj0 = 0 ;
24118   PyObject * obj1 = 0 ;
24119   PyObject * obj2 = 0 ;
24120   Hex::Vector *result = 0 ;
24121
24122   if (!PyArg_ParseTuple(args,(char *)"OOO:new_Vector",&obj0,&obj1,&obj2)) SWIG_fail;
24123   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24124   if (!SWIG_IsOK(res1)) {
24125     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
24126   }
24127   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24128   ecode2 = SWIG_AsVal_double(obj1, &val2);
24129   if (!SWIG_IsOK(ecode2)) {
24130     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
24131   }
24132   arg2 = static_cast< double >(val2);
24133   ecode3 = SWIG_AsVal_double(obj2, &val3);
24134   if (!SWIG_IsOK(ecode3)) {
24135     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Vector" "', argument " "3"" of type '" "double""'");
24136   }
24137   arg3 = static_cast< double >(val3);
24138   result = (Hex::Vector *)new Hex::Vector(arg1,arg2,arg3);
24139   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
24140   return resultobj;
24141 fail:
24142   return NULL;
24143 }
24144
24145
24146 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24147   PyObject *resultobj = 0;
24148   Hex::Document *arg1 = (Hex::Document *) 0 ;
24149   double arg2 ;
24150   void *argp1 = 0 ;
24151   int res1 = 0 ;
24152   double val2 ;
24153   int ecode2 = 0 ;
24154   PyObject * obj0 = 0 ;
24155   PyObject * obj1 = 0 ;
24156   Hex::Vector *result = 0 ;
24157
24158   if (!PyArg_ParseTuple(args,(char *)"OO:new_Vector",&obj0,&obj1)) SWIG_fail;
24159   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24160   if (!SWIG_IsOK(res1)) {
24161     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
24162   }
24163   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24164   ecode2 = SWIG_AsVal_double(obj1, &val2);
24165   if (!SWIG_IsOK(ecode2)) {
24166     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector" "', argument " "2"" of type '" "double""'");
24167   }
24168   arg2 = static_cast< double >(val2);
24169   result = (Hex::Vector *)new Hex::Vector(arg1,arg2);
24170   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
24171   return resultobj;
24172 fail:
24173   return NULL;
24174 }
24175
24176
24177 SWIGINTERN PyObject *_wrap_new_Vector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24178   PyObject *resultobj = 0;
24179   Hex::Document *arg1 = (Hex::Document *) 0 ;
24180   void *argp1 = 0 ;
24181   int res1 = 0 ;
24182   PyObject * obj0 = 0 ;
24183   Hex::Vector *result = 0 ;
24184
24185   if (!PyArg_ParseTuple(args,(char *)"O:new_Vector",&obj0)) SWIG_fail;
24186   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24187   if (!SWIG_IsOK(res1)) {
24188     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector" "', argument " "1"" of type '" "Hex::Document *""'");
24189   }
24190   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24191   result = (Hex::Vector *)new Hex::Vector(arg1);
24192   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, SWIG_POINTER_NEW |  0 );
24193   return resultobj;
24194 fail:
24195   return NULL;
24196 }
24197
24198
24199 SWIGINTERN PyObject *_wrap_new_Vector(PyObject *self, PyObject *args) {
24200   Py_ssize_t argc;
24201   PyObject *argv[5] = {
24202     0
24203   };
24204   Py_ssize_t ii;
24205
24206   if (!PyTuple_Check(args)) SWIG_fail;
24207   argc = args ? PyObject_Length(args) : 0;
24208   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
24209     argv[ii] = PyTuple_GET_ITEM(args,ii);
24210   }
24211   if (argc == 1) {
24212     int _v;
24213     void *vptr = 0;
24214     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24215     _v = SWIG_CheckState(res);
24216     if (_v) {
24217       return _wrap_new_Vector__SWIG_3(self, args);
24218     }
24219   }
24220   if (argc == 2) {
24221     int _v;
24222     void *vptr = 0;
24223     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24224     _v = SWIG_CheckState(res);
24225     if (_v) {
24226       {
24227         int res = SWIG_AsVal_double(argv[1], NULL);
24228         _v = SWIG_CheckState(res);
24229       }
24230       if (_v) {
24231         return _wrap_new_Vector__SWIG_2(self, args);
24232       }
24233     }
24234   }
24235   if (argc == 3) {
24236     int _v;
24237     void *vptr = 0;
24238     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24239     _v = SWIG_CheckState(res);
24240     if (_v) {
24241       {
24242         int res = SWIG_AsVal_double(argv[1], NULL);
24243         _v = SWIG_CheckState(res);
24244       }
24245       if (_v) {
24246         {
24247           int res = SWIG_AsVal_double(argv[2], NULL);
24248           _v = SWIG_CheckState(res);
24249         }
24250         if (_v) {
24251           return _wrap_new_Vector__SWIG_1(self, args);
24252         }
24253       }
24254     }
24255   }
24256   if (argc == 4) {
24257     int _v;
24258     void *vptr = 0;
24259     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24260     _v = SWIG_CheckState(res);
24261     if (_v) {
24262       {
24263         int res = SWIG_AsVal_double(argv[1], NULL);
24264         _v = SWIG_CheckState(res);
24265       }
24266       if (_v) {
24267         {
24268           int res = SWIG_AsVal_double(argv[2], NULL);
24269           _v = SWIG_CheckState(res);
24270         }
24271         if (_v) {
24272           {
24273             int res = SWIG_AsVal_double(argv[3], NULL);
24274             _v = SWIG_CheckState(res);
24275           }
24276           if (_v) {
24277             return _wrap_new_Vector__SWIG_0(self, args);
24278           }
24279         }
24280       }
24281     }
24282   }
24283
24284 fail:
24285   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Vector'.\n"
24286     "  Possible C/C++ prototypes are:\n"
24287     "    Hex::Vector::Vector(Hex::Document *,double,double,double)\n"
24288     "    Hex::Vector::Vector(Hex::Document *,double,double)\n"
24289     "    Hex::Vector::Vector(Hex::Document *,double)\n"
24290     "    Hex::Vector::Vector(Hex::Document *)\n");
24291   return 0;
24292 }
24293
24294
24295 SWIGINTERN PyObject *_wrap_delete_Vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24296   PyObject *resultobj = 0;
24297   Hex::Vector *arg1 = (Hex::Vector *) 0 ;
24298   void *argp1 = 0 ;
24299   int res1 = 0 ;
24300   PyObject * obj0 = 0 ;
24301
24302   if (!PyArg_ParseTuple(args,(char *)"O:delete_Vector",&obj0)) SWIG_fail;
24303   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Vector, SWIG_POINTER_DISOWN |  0 );
24304   if (!SWIG_IsOK(res1)) {
24305     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector" "', argument " "1"" of type '" "Hex::Vector *""'");
24306   }
24307   arg1 = reinterpret_cast< Hex::Vector * >(argp1);
24308   delete arg1;
24309   resultobj = SWIG_Py_Void();
24310   return resultobj;
24311 fail:
24312   return NULL;
24313 }
24314
24315
24316 SWIGINTERN PyObject *Vector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24317   PyObject *obj;
24318   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
24319   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Vector, SWIG_NewClientData(obj));
24320   return SWIG_Py_Void();
24321 }
24322
24323 SWIGINTERN PyObject *_wrap_new_Document__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24324   PyObject *resultobj = 0;
24325   cpchar arg1 = (cpchar) 0 ;
24326   Hex::Hex *arg2 = (Hex::Hex *) 0 ;
24327   int res1 ;
24328   char *buf1 = 0 ;
24329   int alloc1 = 0 ;
24330   void *argp2 = 0 ;
24331   int res2 = 0 ;
24332   PyObject * obj0 = 0 ;
24333   PyObject * obj1 = 0 ;
24334   Hex::Document *result = 0 ;
24335
24336   if (!PyArg_ParseTuple(args,(char *)"OO:new_Document",&obj0,&obj1)) SWIG_fail;
24337   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
24338   if (!SWIG_IsOK(res1)) {
24339     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Document" "', argument " "1"" of type '" "cpchar""'");
24340   }
24341   arg1 = reinterpret_cast< cpchar >(buf1);
24342   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hex, 0 |  0 );
24343   if (!SWIG_IsOK(res2)) {
24344     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Document" "', argument " "2"" of type '" "Hex::Hex *""'");
24345   }
24346   arg2 = reinterpret_cast< Hex::Hex * >(argp2);
24347   result = (Hex::Document *)new Hex::Document(arg1,arg2);
24348   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, SWIG_POINTER_NEW |  0 );
24349   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24350   return resultobj;
24351 fail:
24352   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24353   return NULL;
24354 }
24355
24356
24357 SWIGINTERN PyObject *_wrap_new_Document__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24358   PyObject *resultobj = 0;
24359   cpchar arg1 = (cpchar) 0 ;
24360   int res1 ;
24361   char *buf1 = 0 ;
24362   int alloc1 = 0 ;
24363   PyObject * obj0 = 0 ;
24364   Hex::Document *result = 0 ;
24365
24366   if (!PyArg_ParseTuple(args,(char *)"O:new_Document",&obj0)) SWIG_fail;
24367   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
24368   if (!SWIG_IsOK(res1)) {
24369     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Document" "', argument " "1"" of type '" "cpchar""'");
24370   }
24371   arg1 = reinterpret_cast< cpchar >(buf1);
24372   result = (Hex::Document *)new Hex::Document(arg1);
24373   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, SWIG_POINTER_NEW |  0 );
24374   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24375   return resultobj;
24376 fail:
24377   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24378   return NULL;
24379 }
24380
24381
24382 SWIGINTERN PyObject *_wrap_new_Document(PyObject *self, PyObject *args) {
24383   Py_ssize_t argc;
24384   PyObject *argv[3] = {
24385     0
24386   };
24387   Py_ssize_t ii;
24388
24389   if (!PyTuple_Check(args)) SWIG_fail;
24390   argc = args ? PyObject_Length(args) : 0;
24391   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
24392     argv[ii] = PyTuple_GET_ITEM(args,ii);
24393   }
24394   if (argc == 1) {
24395     int _v;
24396     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
24397     _v = SWIG_CheckState(res);
24398     if (_v) {
24399       return _wrap_new_Document__SWIG_1(self, args);
24400     }
24401   }
24402   if (argc == 2) {
24403     int _v;
24404     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
24405     _v = SWIG_CheckState(res);
24406     if (_v) {
24407       void *vptr = 0;
24408       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Hex, 0);
24409       _v = SWIG_CheckState(res);
24410       if (_v) {
24411         return _wrap_new_Document__SWIG_0(self, args);
24412       }
24413     }
24414   }
24415
24416 fail:
24417   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Document'.\n"
24418     "  Possible C/C++ prototypes are:\n"
24419     "    Hex::Document::Document(cpchar,Hex::Hex *)\n"
24420     "    Hex::Document::Document(cpchar)\n");
24421   return 0;
24422 }
24423
24424
24425 SWIGINTERN PyObject *_wrap_Document_dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24426   PyObject *resultobj = 0;
24427   Hex::Document *arg1 = (Hex::Document *) 0 ;
24428   void *argp1 = 0 ;
24429   int res1 = 0 ;
24430   PyObject * obj0 = 0 ;
24431
24432   if (!PyArg_ParseTuple(args,(char *)"O:Document_dump",&obj0)) SWIG_fail;
24433   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24434   if (!SWIG_IsOK(res1)) {
24435     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_dump" "', argument " "1"" of type '" "Hex::Document *""'");
24436   }
24437   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24438   (arg1)->dump();
24439   resultobj = SWIG_Py_Void();
24440   return resultobj;
24441 fail:
24442   return NULL;
24443 }
24444
24445
24446 SWIGINTERN PyObject *_wrap_Document_setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24447   PyObject *resultobj = 0;
24448   Hex::Document *arg1 = (Hex::Document *) 0 ;
24449   char *arg2 = (char *) 0 ;
24450   void *argp1 = 0 ;
24451   int res1 = 0 ;
24452   int res2 ;
24453   char *buf2 = 0 ;
24454   int alloc2 = 0 ;
24455   PyObject * obj0 = 0 ;
24456   PyObject * obj1 = 0 ;
24457   int result;
24458
24459   if (!PyArg_ParseTuple(args,(char *)"OO:Document_setName",&obj0,&obj1)) SWIG_fail;
24460   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24461   if (!SWIG_IsOK(res1)) {
24462     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setName" "', argument " "1"" of type '" "Hex::Document *""'");
24463   }
24464   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24465   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24466   if (!SWIG_IsOK(res2)) {
24467     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_setName" "', argument " "2"" of type '" "char const *""'");
24468   }
24469   arg2 = reinterpret_cast< char * >(buf2);
24470   result = (int)(arg1)->setName((char const *)arg2);
24471   resultobj = SWIG_From_int(static_cast< int >(result));
24472   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24473   return resultobj;
24474 fail:
24475   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24476   return NULL;
24477 }
24478
24479
24480 SWIGINTERN PyObject *_wrap_Document_setLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24481   PyObject *resultobj = 0;
24482   Hex::Document *arg1 = (Hex::Document *) 0 ;
24483   int arg2 ;
24484   void *argp1 = 0 ;
24485   int res1 = 0 ;
24486   int val2 ;
24487   int ecode2 = 0 ;
24488   PyObject * obj0 = 0 ;
24489   PyObject * obj1 = 0 ;
24490
24491   if (!PyArg_ParseTuple(args,(char *)"OO:Document_setLevel",&obj0,&obj1)) SWIG_fail;
24492   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24493   if (!SWIG_IsOK(res1)) {
24494     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setLevel" "', argument " "1"" of type '" "Hex::Document *""'");
24495   }
24496   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24497   ecode2 = SWIG_AsVal_int(obj1, &val2);
24498   if (!SWIG_IsOK(ecode2)) {
24499     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_setLevel" "', argument " "2"" of type '" "int""'");
24500   }
24501   arg2 = static_cast< int >(val2);
24502   (arg1)->setLevel(arg2);
24503   resultobj = SWIG_Py_Void();
24504   return resultobj;
24505 fail:
24506   return NULL;
24507 }
24508
24509
24510 SWIGINTERN PyObject *_wrap_Document_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24511   PyObject *resultobj = 0;
24512   Hex::Document *arg1 = (Hex::Document *) 0 ;
24513   char *arg2 = (char *) 0 ;
24514   void *argp1 = 0 ;
24515   int res1 = 0 ;
24516   int res2 ;
24517   char *buf2 = 0 ;
24518   int alloc2 = 0 ;
24519   PyObject * obj0 = 0 ;
24520   PyObject * obj1 = 0 ;
24521   int result;
24522
24523   if (!PyArg_ParseTuple(args,(char *)"OO:Document_save",&obj0,&obj1)) SWIG_fail;
24524   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24525   if (!SWIG_IsOK(res1)) {
24526     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_save" "', argument " "1"" of type '" "Hex::Document *""'");
24527   }
24528   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24529   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24530   if (!SWIG_IsOK(res2)) {
24531     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_save" "', argument " "2"" of type '" "char const *""'");
24532   }
24533   arg2 = reinterpret_cast< char * >(buf2);
24534   result = (int)(arg1)->save((char const *)arg2);
24535   resultobj = SWIG_From_int(static_cast< int >(result));
24536   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24537   return resultobj;
24538 fail:
24539   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24540   return NULL;
24541 }
24542
24543
24544 SWIGINTERN PyObject *_wrap_Document_saveVtk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24545   PyObject *resultobj = 0;
24546   Hex::Document *arg1 = (Hex::Document *) 0 ;
24547   cpchar arg2 = (cpchar) 0 ;
24548   void *argp1 = 0 ;
24549   int res1 = 0 ;
24550   int res2 ;
24551   char *buf2 = 0 ;
24552   int alloc2 = 0 ;
24553   PyObject * obj0 = 0 ;
24554   PyObject * obj1 = 0 ;
24555   int result;
24556
24557   if (!PyArg_ParseTuple(args,(char *)"OO:Document_saveVtk",&obj0,&obj1)) SWIG_fail;
24558   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24559   if (!SWIG_IsOK(res1)) {
24560     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_saveVtk" "', argument " "1"" of type '" "Hex::Document *""'");
24561   }
24562   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24563   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24564   if (!SWIG_IsOK(res2)) {
24565     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_saveVtk" "', argument " "2"" of type '" "cpchar""'");
24566   }
24567   arg2 = reinterpret_cast< cpchar >(buf2);
24568   result = (int)(arg1)->saveVtk(arg2);
24569   resultobj = SWIG_From_int(static_cast< int >(result));
24570   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24571   return resultobj;
24572 fail:
24573   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24574   return NULL;
24575 }
24576
24577
24578 SWIGINTERN PyObject *_wrap_Document_purge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24579   PyObject *resultobj = 0;
24580   Hex::Document *arg1 = (Hex::Document *) 0 ;
24581   void *argp1 = 0 ;
24582   int res1 = 0 ;
24583   PyObject * obj0 = 0 ;
24584
24585   if (!PyArg_ParseTuple(args,(char *)"O:Document_purge",&obj0)) SWIG_fail;
24586   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24587   if (!SWIG_IsOK(res1)) {
24588     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_purge" "', argument " "1"" of type '" "Hex::Document *""'");
24589   }
24590   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24591   (arg1)->purge();
24592   resultobj = SWIG_Py_Void();
24593   return resultobj;
24594 fail:
24595   return NULL;
24596 }
24597
24598
24599 SWIGINTERN PyObject *_wrap_Document_setTolerance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600   PyObject *resultobj = 0;
24601   Hex::Document *arg1 = (Hex::Document *) 0 ;
24602   double arg2 ;
24603   void *argp1 = 0 ;
24604   int res1 = 0 ;
24605   double val2 ;
24606   int ecode2 = 0 ;
24607   PyObject * obj0 = 0 ;
24608   PyObject * obj1 = 0 ;
24609
24610   if (!PyArg_ParseTuple(args,(char *)"OO:Document_setTolerance",&obj0,&obj1)) SWIG_fail;
24611   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24612   if (!SWIG_IsOK(res1)) {
24613     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_setTolerance" "', argument " "1"" of type '" "Hex::Document *""'");
24614   }
24615   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24616   ecode2 = SWIG_AsVal_double(obj1, &val2);
24617   if (!SWIG_IsOK(ecode2)) {
24618     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_setTolerance" "', argument " "2"" of type '" "double""'");
24619   }
24620   arg2 = static_cast< double >(val2);
24621   (arg1)->setTolerance(arg2);
24622   resultobj = SWIG_Py_Void();
24623   return resultobj;
24624 fail:
24625   return NULL;
24626 }
24627
24628
24629 SWIGINTERN PyObject *_wrap_Document_getTolerance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24630   PyObject *resultobj = 0;
24631   Hex::Document *arg1 = (Hex::Document *) 0 ;
24632   void *argp1 = 0 ;
24633   int res1 = 0 ;
24634   PyObject * obj0 = 0 ;
24635   double result;
24636
24637   if (!PyArg_ParseTuple(args,(char *)"O:Document_getTolerance",&obj0)) SWIG_fail;
24638   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24639   if (!SWIG_IsOK(res1)) {
24640     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getTolerance" "', argument " "1"" of type '" "Hex::Document *""'");
24641   }
24642   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24643   result = (double)(arg1)->getTolerance();
24644   resultobj = SWIG_From_double(static_cast< double >(result));
24645   return resultobj;
24646 fail:
24647   return NULL;
24648 }
24649
24650
24651 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24652   PyObject *resultobj = 0;
24653   Hex::Document *arg1 = (Hex::Document *) 0 ;
24654   double arg2 ;
24655   double arg3 ;
24656   double arg4 ;
24657   void *argp1 = 0 ;
24658   int res1 = 0 ;
24659   double val2 ;
24660   int ecode2 = 0 ;
24661   double val3 ;
24662   int ecode3 = 0 ;
24663   double val4 ;
24664   int ecode4 = 0 ;
24665   PyObject * obj0 = 0 ;
24666   PyObject * obj1 = 0 ;
24667   PyObject * obj2 = 0 ;
24668   PyObject * obj3 = 0 ;
24669   Hex::Vertex *result = 0 ;
24670
24671   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24672   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24673   if (!SWIG_IsOK(res1)) {
24674     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24675   }
24676   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24677   ecode2 = SWIG_AsVal_double(obj1, &val2);
24678   if (!SWIG_IsOK(ecode2)) {
24679     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
24680   }
24681   arg2 = static_cast< double >(val2);
24682   ecode3 = SWIG_AsVal_double(obj2, &val3);
24683   if (!SWIG_IsOK(ecode3)) {
24684     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVertex" "', argument " "3"" of type '" "double""'");
24685   }
24686   arg3 = static_cast< double >(val3);
24687   ecode4 = SWIG_AsVal_double(obj3, &val4);
24688   if (!SWIG_IsOK(ecode4)) {
24689     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_addVertex" "', argument " "4"" of type '" "double""'");
24690   }
24691   arg4 = static_cast< double >(val4);
24692   result = (Hex::Vertex *)(arg1)->addVertex(arg2,arg3,arg4);
24693   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24694   return resultobj;
24695 fail:
24696   return NULL;
24697 }
24698
24699
24700 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24701   PyObject *resultobj = 0;
24702   Hex::Document *arg1 = (Hex::Document *) 0 ;
24703   double arg2 ;
24704   double arg3 ;
24705   void *argp1 = 0 ;
24706   int res1 = 0 ;
24707   double val2 ;
24708   int ecode2 = 0 ;
24709   double val3 ;
24710   int ecode3 = 0 ;
24711   PyObject * obj0 = 0 ;
24712   PyObject * obj1 = 0 ;
24713   PyObject * obj2 = 0 ;
24714   Hex::Vertex *result = 0 ;
24715
24716   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVertex",&obj0,&obj1,&obj2)) SWIG_fail;
24717   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24718   if (!SWIG_IsOK(res1)) {
24719     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24720   }
24721   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24722   ecode2 = SWIG_AsVal_double(obj1, &val2);
24723   if (!SWIG_IsOK(ecode2)) {
24724     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
24725   }
24726   arg2 = static_cast< double >(val2);
24727   ecode3 = SWIG_AsVal_double(obj2, &val3);
24728   if (!SWIG_IsOK(ecode3)) {
24729     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVertex" "', argument " "3"" of type '" "double""'");
24730   }
24731   arg3 = static_cast< double >(val3);
24732   result = (Hex::Vertex *)(arg1)->addVertex(arg2,arg3);
24733   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24734   return resultobj;
24735 fail:
24736   return NULL;
24737 }
24738
24739
24740 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24741   PyObject *resultobj = 0;
24742   Hex::Document *arg1 = (Hex::Document *) 0 ;
24743   double arg2 ;
24744   void *argp1 = 0 ;
24745   int res1 = 0 ;
24746   double val2 ;
24747   int ecode2 = 0 ;
24748   PyObject * obj0 = 0 ;
24749   PyObject * obj1 = 0 ;
24750   Hex::Vertex *result = 0 ;
24751
24752   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertex",&obj0,&obj1)) SWIG_fail;
24753   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24754   if (!SWIG_IsOK(res1)) {
24755     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24756   }
24757   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24758   ecode2 = SWIG_AsVal_double(obj1, &val2);
24759   if (!SWIG_IsOK(ecode2)) {
24760     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVertex" "', argument " "2"" of type '" "double""'");
24761   }
24762   arg2 = static_cast< double >(val2);
24763   result = (Hex::Vertex *)(arg1)->addVertex(arg2);
24764   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24765   return resultobj;
24766 fail:
24767   return NULL;
24768 }
24769
24770
24771 SWIGINTERN PyObject *_wrap_Document_addVertex__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24772   PyObject *resultobj = 0;
24773   Hex::Document *arg1 = (Hex::Document *) 0 ;
24774   void *argp1 = 0 ;
24775   int res1 = 0 ;
24776   PyObject * obj0 = 0 ;
24777   Hex::Vertex *result = 0 ;
24778
24779   if (!PyArg_ParseTuple(args,(char *)"O:Document_addVertex",&obj0)) SWIG_fail;
24780   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24781   if (!SWIG_IsOK(res1)) {
24782     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVertex" "', argument " "1"" of type '" "Hex::Document *""'");
24783   }
24784   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24785   result = (Hex::Vertex *)(arg1)->addVertex();
24786   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24787   return resultobj;
24788 fail:
24789   return NULL;
24790 }
24791
24792
24793 SWIGINTERN PyObject *_wrap_Document_addVertex(PyObject *self, PyObject *args) {
24794   Py_ssize_t argc;
24795   PyObject *argv[5] = {
24796     0
24797   };
24798   Py_ssize_t ii;
24799
24800   if (!PyTuple_Check(args)) SWIG_fail;
24801   argc = args ? PyObject_Length(args) : 0;
24802   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
24803     argv[ii] = PyTuple_GET_ITEM(args,ii);
24804   }
24805   if (argc == 1) {
24806     int _v;
24807     void *vptr = 0;
24808     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24809     _v = SWIG_CheckState(res);
24810     if (_v) {
24811       return _wrap_Document_addVertex__SWIG_3(self, args);
24812     }
24813   }
24814   if (argc == 2) {
24815     int _v;
24816     void *vptr = 0;
24817     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24818     _v = SWIG_CheckState(res);
24819     if (_v) {
24820       {
24821         int res = SWIG_AsVal_double(argv[1], NULL);
24822         _v = SWIG_CheckState(res);
24823       }
24824       if (_v) {
24825         return _wrap_Document_addVertex__SWIG_2(self, args);
24826       }
24827     }
24828   }
24829   if (argc == 3) {
24830     int _v;
24831     void *vptr = 0;
24832     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24833     _v = SWIG_CheckState(res);
24834     if (_v) {
24835       {
24836         int res = SWIG_AsVal_double(argv[1], NULL);
24837         _v = SWIG_CheckState(res);
24838       }
24839       if (_v) {
24840         {
24841           int res = SWIG_AsVal_double(argv[2], NULL);
24842           _v = SWIG_CheckState(res);
24843         }
24844         if (_v) {
24845           return _wrap_Document_addVertex__SWIG_1(self, args);
24846         }
24847       }
24848     }
24849   }
24850   if (argc == 4) {
24851     int _v;
24852     void *vptr = 0;
24853     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
24854     _v = SWIG_CheckState(res);
24855     if (_v) {
24856       {
24857         int res = SWIG_AsVal_double(argv[1], NULL);
24858         _v = SWIG_CheckState(res);
24859       }
24860       if (_v) {
24861         {
24862           int res = SWIG_AsVal_double(argv[2], NULL);
24863           _v = SWIG_CheckState(res);
24864         }
24865         if (_v) {
24866           {
24867             int res = SWIG_AsVal_double(argv[3], NULL);
24868             _v = SWIG_CheckState(res);
24869           }
24870           if (_v) {
24871             return _wrap_Document_addVertex__SWIG_0(self, args);
24872           }
24873         }
24874       }
24875     }
24876   }
24877
24878 fail:
24879   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_addVertex'.\n"
24880     "  Possible C/C++ prototypes are:\n"
24881     "    Hex::Document::addVertex(double,double,double)\n"
24882     "    Hex::Document::addVertex(double,double)\n"
24883     "    Hex::Document::addVertex(double)\n"
24884     "    Hex::Document::addVertex()\n");
24885   return 0;
24886 }
24887
24888
24889 SWIGINTERN PyObject *_wrap_Document_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24890   PyObject *resultobj = 0;
24891   Hex::Document *arg1 = (Hex::Document *) 0 ;
24892   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24893   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
24894   void *argp1 = 0 ;
24895   int res1 = 0 ;
24896   void *argp2 = 0 ;
24897   int res2 = 0 ;
24898   void *argp3 = 0 ;
24899   int res3 = 0 ;
24900   PyObject * obj0 = 0 ;
24901   PyObject * obj1 = 0 ;
24902   PyObject * obj2 = 0 ;
24903   Hex::Edge *result = 0 ;
24904
24905   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdge",&obj0,&obj1,&obj2)) SWIG_fail;
24906   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24907   if (!SWIG_IsOK(res1)) {
24908     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdge" "', argument " "1"" of type '" "Hex::Document *""'");
24909   }
24910   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24911   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24912   if (!SWIG_IsOK(res2)) {
24913     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdge" "', argument " "2"" of type '" "Hex::Vertex *""'");
24914   }
24915   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24916   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24917   if (!SWIG_IsOK(res3)) {
24918     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addEdge" "', argument " "3"" of type '" "Hex::Vertex *""'");
24919   }
24920   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
24921   result = (Hex::Edge *)(arg1)->addEdge(arg2,arg3);
24922   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
24923   return resultobj;
24924 fail:
24925   return NULL;
24926 }
24927
24928
24929 SWIGINTERN PyObject *_wrap_Document_addEdgeVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24930   PyObject *resultobj = 0;
24931   Hex::Document *arg1 = (Hex::Document *) 0 ;
24932   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
24933   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
24934   void *argp1 = 0 ;
24935   int res1 = 0 ;
24936   void *argp2 = 0 ;
24937   int res2 = 0 ;
24938   void *argp3 = 0 ;
24939   int res3 = 0 ;
24940   PyObject * obj0 = 0 ;
24941   PyObject * obj1 = 0 ;
24942   PyObject * obj2 = 0 ;
24943   Hex::Edge *result = 0 ;
24944
24945   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addEdgeVector",&obj0,&obj1,&obj2)) SWIG_fail;
24946   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24947   if (!SWIG_IsOK(res1)) {
24948     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeVector" "', argument " "1"" of type '" "Hex::Document *""'");
24949   }
24950   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24951   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
24952   if (!SWIG_IsOK(res2)) {
24953     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeVector" "', argument " "2"" of type '" "Hex::Vertex *""'");
24954   }
24955   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
24956   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
24957   if (!SWIG_IsOK(res3)) {
24958     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addEdgeVector" "', argument " "3"" of type '" "Hex::Vector *""'");
24959   }
24960   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
24961   result = (Hex::Edge *)(arg1)->addEdgeVector(arg2,arg3);
24962   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
24963   return resultobj;
24964 fail:
24965   return NULL;
24966 }
24967
24968
24969 SWIGINTERN PyObject *_wrap_Document_addQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24970   PyObject *resultobj = 0;
24971   Hex::Document *arg1 = (Hex::Document *) 0 ;
24972   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
24973   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
24974   Hex::Edge *arg4 = (Hex::Edge *) 0 ;
24975   Hex::Edge *arg5 = (Hex::Edge *) 0 ;
24976   void *argp1 = 0 ;
24977   int res1 = 0 ;
24978   void *argp2 = 0 ;
24979   int res2 = 0 ;
24980   void *argp3 = 0 ;
24981   int res3 = 0 ;
24982   void *argp4 = 0 ;
24983   int res4 = 0 ;
24984   void *argp5 = 0 ;
24985   int res5 = 0 ;
24986   PyObject * obj0 = 0 ;
24987   PyObject * obj1 = 0 ;
24988   PyObject * obj2 = 0 ;
24989   PyObject * obj3 = 0 ;
24990   PyObject * obj4 = 0 ;
24991   Hex::Quad *result = 0 ;
24992
24993   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24994   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
24995   if (!SWIG_IsOK(res1)) {
24996     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuad" "', argument " "1"" of type '" "Hex::Document *""'");
24997   }
24998   arg1 = reinterpret_cast< Hex::Document * >(argp1);
24999   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
25000   if (!SWIG_IsOK(res2)) {
25001     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuad" "', argument " "2"" of type '" "Hex::Edge *""'");
25002   }
25003   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
25004   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
25005   if (!SWIG_IsOK(res3)) {
25006     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addQuad" "', argument " "3"" of type '" "Hex::Edge *""'");
25007   }
25008   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
25009   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Edge, 0 |  0 );
25010   if (!SWIG_IsOK(res4)) {
25011     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addQuad" "', argument " "4"" of type '" "Hex::Edge *""'");
25012   }
25013   arg4 = reinterpret_cast< Hex::Edge * >(argp4);
25014   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Edge, 0 |  0 );
25015   if (!SWIG_IsOK(res5)) {
25016     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addQuad" "', argument " "5"" of type '" "Hex::Edge *""'");
25017   }
25018   arg5 = reinterpret_cast< Hex::Edge * >(argp5);
25019   result = (Hex::Quad *)(arg1)->addQuad(arg2,arg3,arg4,arg5);
25020   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
25021   return resultobj;
25022 fail:
25023   return NULL;
25024 }
25025
25026
25027 SWIGINTERN PyObject *_wrap_Document_addQuadVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25028   PyObject *resultobj = 0;
25029   Hex::Document *arg1 = (Hex::Document *) 0 ;
25030   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25031   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
25032   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
25033   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
25034   void *argp1 = 0 ;
25035   int res1 = 0 ;
25036   void *argp2 = 0 ;
25037   int res2 = 0 ;
25038   void *argp3 = 0 ;
25039   int res3 = 0 ;
25040   void *argp4 = 0 ;
25041   int res4 = 0 ;
25042   void *argp5 = 0 ;
25043   int res5 = 0 ;
25044   PyObject * obj0 = 0 ;
25045   PyObject * obj1 = 0 ;
25046   PyObject * obj2 = 0 ;
25047   PyObject * obj3 = 0 ;
25048   PyObject * obj4 = 0 ;
25049   Hex::Quad *result = 0 ;
25050
25051   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addQuadVertices",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25052   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25053   if (!SWIG_IsOK(res1)) {
25054     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadVertices" "', argument " "1"" of type '" "Hex::Document *""'");
25055   }
25056   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25057   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25058   if (!SWIG_IsOK(res2)) {
25059     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
25060   }
25061   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25062   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25063   if (!SWIG_IsOK(res3)) {
25064     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addQuadVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
25065   }
25066   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
25067   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25068   if (!SWIG_IsOK(res4)) {
25069     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addQuadVertices" "', argument " "4"" of type '" "Hex::Vertex *""'");
25070   }
25071   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
25072   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25073   if (!SWIG_IsOK(res5)) {
25074     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addQuadVertices" "', argument " "5"" of type '" "Hex::Vertex *""'");
25075   }
25076   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
25077   result = (Hex::Quad *)(arg1)->addQuadVertices(arg2,arg3,arg4,arg5);
25078   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
25079   return resultobj;
25080 fail:
25081   return NULL;
25082 }
25083
25084
25085 SWIGINTERN PyObject *_wrap_Document_addHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25086   PyObject *resultobj = 0;
25087   Hex::Document *arg1 = (Hex::Document *) 0 ;
25088   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25089   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
25090   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
25091   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
25092   Hex::Quad *arg6 = (Hex::Quad *) 0 ;
25093   Hex::Quad *arg7 = (Hex::Quad *) 0 ;
25094   void *argp1 = 0 ;
25095   int res1 = 0 ;
25096   void *argp2 = 0 ;
25097   int res2 = 0 ;
25098   void *argp3 = 0 ;
25099   int res3 = 0 ;
25100   void *argp4 = 0 ;
25101   int res4 = 0 ;
25102   void *argp5 = 0 ;
25103   int res5 = 0 ;
25104   void *argp6 = 0 ;
25105   int res6 = 0 ;
25106   void *argp7 = 0 ;
25107   int res7 = 0 ;
25108   PyObject * obj0 = 0 ;
25109   PyObject * obj1 = 0 ;
25110   PyObject * obj2 = 0 ;
25111   PyObject * obj3 = 0 ;
25112   PyObject * obj4 = 0 ;
25113   PyObject * obj5 = 0 ;
25114   PyObject * obj6 = 0 ;
25115   Hex::Hexa *result = 0 ;
25116
25117   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_addHexa",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
25118   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25119   if (!SWIG_IsOK(res1)) {
25120     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa" "', argument " "1"" of type '" "Hex::Document *""'");
25121   }
25122   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25123   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25124   if (!SWIG_IsOK(res2)) {
25125     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa" "', argument " "2"" of type '" "Hex::Quad *""'");
25126   }
25127   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25128   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25129   if (!SWIG_IsOK(res3)) {
25130     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa" "', argument " "3"" of type '" "Hex::Quad *""'");
25131   }
25132   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
25133   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25134   if (!SWIG_IsOK(res4)) {
25135     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa" "', argument " "4"" of type '" "Hex::Quad *""'");
25136   }
25137   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
25138   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25139   if (!SWIG_IsOK(res5)) {
25140     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa" "', argument " "5"" of type '" "Hex::Quad *""'");
25141   }
25142   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
25143   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25144   if (!SWIG_IsOK(res6)) {
25145     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexa" "', argument " "6"" of type '" "Hex::Quad *""'");
25146   }
25147   arg6 = reinterpret_cast< Hex::Quad * >(argp6);
25148   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25149   if (!SWIG_IsOK(res7)) {
25150     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_addHexa" "', argument " "7"" of type '" "Hex::Quad *""'");
25151   }
25152   arg7 = reinterpret_cast< Hex::Quad * >(argp7);
25153   result = (Hex::Hexa *)(arg1)->addHexa(arg2,arg3,arg4,arg5,arg6,arg7);
25154   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25155   return resultobj;
25156 fail:
25157   return NULL;
25158 }
25159
25160
25161 SWIGINTERN PyObject *_wrap_Document_addHexaVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25162   PyObject *resultobj = 0;
25163   Hex::Document *arg1 = (Hex::Document *) 0 ;
25164   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25165   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
25166   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
25167   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
25168   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
25169   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
25170   Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
25171   Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
25172   void *argp1 = 0 ;
25173   int res1 = 0 ;
25174   void *argp2 = 0 ;
25175   int res2 = 0 ;
25176   void *argp3 = 0 ;
25177   int res3 = 0 ;
25178   void *argp4 = 0 ;
25179   int res4 = 0 ;
25180   void *argp5 = 0 ;
25181   int res5 = 0 ;
25182   void *argp6 = 0 ;
25183   int res6 = 0 ;
25184   void *argp7 = 0 ;
25185   int res7 = 0 ;
25186   void *argp8 = 0 ;
25187   int res8 = 0 ;
25188   void *argp9 = 0 ;
25189   int res9 = 0 ;
25190   PyObject * obj0 = 0 ;
25191   PyObject * obj1 = 0 ;
25192   PyObject * obj2 = 0 ;
25193   PyObject * obj3 = 0 ;
25194   PyObject * obj4 = 0 ;
25195   PyObject * obj5 = 0 ;
25196   PyObject * obj6 = 0 ;
25197   PyObject * obj7 = 0 ;
25198   PyObject * obj8 = 0 ;
25199   Hex::Hexa *result = 0 ;
25200
25201   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_addHexaVertices",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
25202   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25203   if (!SWIG_IsOK(res1)) {
25204     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaVertices" "', argument " "1"" of type '" "Hex::Document *""'");
25205   }
25206   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25207   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25208   if (!SWIG_IsOK(res2)) {
25209     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
25210   }
25211   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25212   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25213   if (!SWIG_IsOK(res3)) {
25214     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexaVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
25215   }
25216   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
25217   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25218   if (!SWIG_IsOK(res4)) {
25219     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexaVertices" "', argument " "4"" of type '" "Hex::Vertex *""'");
25220   }
25221   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
25222   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25223   if (!SWIG_IsOK(res5)) {
25224     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexaVertices" "', argument " "5"" of type '" "Hex::Vertex *""'");
25225   }
25226   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
25227   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25228   if (!SWIG_IsOK(res6)) {
25229     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexaVertices" "', argument " "6"" of type '" "Hex::Vertex *""'");
25230   }
25231   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
25232   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25233   if (!SWIG_IsOK(res7)) {
25234     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_addHexaVertices" "', argument " "7"" of type '" "Hex::Vertex *""'");
25235   }
25236   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
25237   res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25238   if (!SWIG_IsOK(res8)) {
25239     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_addHexaVertices" "', argument " "8"" of type '" "Hex::Vertex *""'");
25240   }
25241   arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
25242   res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25243   if (!SWIG_IsOK(res9)) {
25244     SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Document_addHexaVertices" "', argument " "9"" of type '" "Hex::Vertex *""'");
25245   }
25246   arg9 = reinterpret_cast< Hex::Vertex * >(argp9);
25247   result = (Hex::Hexa *)(arg1)->addHexaVertices(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
25248   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25249   return resultobj;
25250 fail:
25251   return NULL;
25252 }
25253
25254
25255 SWIGINTERN PyObject *_wrap_Document_addHexa2Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25256   PyObject *resultobj = 0;
25257   Hex::Document *arg1 = (Hex::Document *) 0 ;
25258   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25259   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
25260   void *argp1 = 0 ;
25261   int res1 = 0 ;
25262   void *argp2 = 0 ;
25263   int res2 = 0 ;
25264   void *argp3 = 0 ;
25265   int res3 = 0 ;
25266   PyObject * obj0 = 0 ;
25267   PyObject * obj1 = 0 ;
25268   PyObject * obj2 = 0 ;
25269   Hex::Hexa *result = 0 ;
25270
25271   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addHexa2Quads",&obj0,&obj1,&obj2)) SWIG_fail;
25272   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25273   if (!SWIG_IsOK(res1)) {
25274     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa2Quads" "', argument " "1"" of type '" "Hex::Document *""'");
25275   }
25276   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25277   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25278   if (!SWIG_IsOK(res2)) {
25279     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa2Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
25280   }
25281   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25282   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25283   if (!SWIG_IsOK(res3)) {
25284     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa2Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
25285   }
25286   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
25287   result = (Hex::Hexa *)(arg1)->addHexa2Quads(arg2,arg3);
25288   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25289   return resultobj;
25290 fail:
25291   return NULL;
25292 }
25293
25294
25295 SWIGINTERN PyObject *_wrap_Document_addHexa3Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25296   PyObject *resultobj = 0;
25297   Hex::Document *arg1 = (Hex::Document *) 0 ;
25298   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25299   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
25300   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
25301   void *argp1 = 0 ;
25302   int res1 = 0 ;
25303   void *argp2 = 0 ;
25304   int res2 = 0 ;
25305   void *argp3 = 0 ;
25306   int res3 = 0 ;
25307   void *argp4 = 0 ;
25308   int res4 = 0 ;
25309   PyObject * obj0 = 0 ;
25310   PyObject * obj1 = 0 ;
25311   PyObject * obj2 = 0 ;
25312   PyObject * obj3 = 0 ;
25313   Hex::Hexa *result = 0 ;
25314
25315   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addHexa3Quads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25316   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25317   if (!SWIG_IsOK(res1)) {
25318     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa3Quads" "', argument " "1"" of type '" "Hex::Document *""'");
25319   }
25320   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25321   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25322   if (!SWIG_IsOK(res2)) {
25323     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa3Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
25324   }
25325   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25326   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25327   if (!SWIG_IsOK(res3)) {
25328     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa3Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
25329   }
25330   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
25331   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25332   if (!SWIG_IsOK(res4)) {
25333     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa3Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
25334   }
25335   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
25336   result = (Hex::Hexa *)(arg1)->addHexa3Quads(arg2,arg3,arg4);
25337   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25338   return resultobj;
25339 fail:
25340   return NULL;
25341 }
25342
25343
25344 SWIGINTERN PyObject *_wrap_Document_addHexa4Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25345   PyObject *resultobj = 0;
25346   Hex::Document *arg1 = (Hex::Document *) 0 ;
25347   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25348   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
25349   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
25350   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
25351   void *argp1 = 0 ;
25352   int res1 = 0 ;
25353   void *argp2 = 0 ;
25354   int res2 = 0 ;
25355   void *argp3 = 0 ;
25356   int res3 = 0 ;
25357   void *argp4 = 0 ;
25358   int res4 = 0 ;
25359   void *argp5 = 0 ;
25360   int res5 = 0 ;
25361   PyObject * obj0 = 0 ;
25362   PyObject * obj1 = 0 ;
25363   PyObject * obj2 = 0 ;
25364   PyObject * obj3 = 0 ;
25365   PyObject * obj4 = 0 ;
25366   Hex::Hexa *result = 0 ;
25367
25368   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_addHexa4Quads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25369   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25370   if (!SWIG_IsOK(res1)) {
25371     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa4Quads" "', argument " "1"" of type '" "Hex::Document *""'");
25372   }
25373   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25374   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25375   if (!SWIG_IsOK(res2)) {
25376     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa4Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
25377   }
25378   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25379   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25380   if (!SWIG_IsOK(res3)) {
25381     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa4Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
25382   }
25383   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
25384   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25385   if (!SWIG_IsOK(res4)) {
25386     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa4Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
25387   }
25388   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
25389   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25390   if (!SWIG_IsOK(res5)) {
25391     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa4Quads" "', argument " "5"" of type '" "Hex::Quad *""'");
25392   }
25393   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
25394   result = (Hex::Hexa *)(arg1)->addHexa4Quads(arg2,arg3,arg4,arg5);
25395   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25396   return resultobj;
25397 fail:
25398   return NULL;
25399 }
25400
25401
25402 SWIGINTERN PyObject *_wrap_Document_addHexa5Quads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25403   PyObject *resultobj = 0;
25404   Hex::Document *arg1 = (Hex::Document *) 0 ;
25405   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
25406   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
25407   Hex::Quad *arg4 = (Hex::Quad *) 0 ;
25408   Hex::Quad *arg5 = (Hex::Quad *) 0 ;
25409   Hex::Quad *arg6 = (Hex::Quad *) 0 ;
25410   void *argp1 = 0 ;
25411   int res1 = 0 ;
25412   void *argp2 = 0 ;
25413   int res2 = 0 ;
25414   void *argp3 = 0 ;
25415   int res3 = 0 ;
25416   void *argp4 = 0 ;
25417   int res4 = 0 ;
25418   void *argp5 = 0 ;
25419   int res5 = 0 ;
25420   void *argp6 = 0 ;
25421   int res6 = 0 ;
25422   PyObject * obj0 = 0 ;
25423   PyObject * obj1 = 0 ;
25424   PyObject * obj2 = 0 ;
25425   PyObject * obj3 = 0 ;
25426   PyObject * obj4 = 0 ;
25427   PyObject * obj5 = 0 ;
25428   Hex::Hexa *result = 0 ;
25429
25430   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_addHexa5Quads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
25431   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25432   if (!SWIG_IsOK(res1)) {
25433     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexa5Quads" "', argument " "1"" of type '" "Hex::Document *""'");
25434   }
25435   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25436   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25437   if (!SWIG_IsOK(res2)) {
25438     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexa5Quads" "', argument " "2"" of type '" "Hex::Quad *""'");
25439   }
25440   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
25441   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25442   if (!SWIG_IsOK(res3)) {
25443     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addHexa5Quads" "', argument " "3"" of type '" "Hex::Quad *""'");
25444   }
25445   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
25446   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25447   if (!SWIG_IsOK(res4)) {
25448     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_addHexa5Quads" "', argument " "4"" of type '" "Hex::Quad *""'");
25449   }
25450   arg4 = reinterpret_cast< Hex::Quad * >(argp4);
25451   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25452   if (!SWIG_IsOK(res5)) {
25453     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_addHexa5Quads" "', argument " "5"" of type '" "Hex::Quad *""'");
25454   }
25455   arg5 = reinterpret_cast< Hex::Quad * >(argp5);
25456   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Quad, 0 |  0 );
25457   if (!SWIG_IsOK(res6)) {
25458     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_addHexa5Quads" "', argument " "6"" of type '" "Hex::Quad *""'");
25459   }
25460   arg6 = reinterpret_cast< Hex::Quad * >(argp6);
25461   result = (Hex::Hexa *)(arg1)->addHexa5Quads(arg2,arg3,arg4,arg5,arg6);
25462   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
25463   return resultobj;
25464 fail:
25465   return NULL;
25466 }
25467
25468
25469 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25470   PyObject *resultobj = 0;
25471   Hex::Document *arg1 = (Hex::Document *) 0 ;
25472   double arg2 ;
25473   double arg3 ;
25474   double arg4 ;
25475   void *argp1 = 0 ;
25476   int res1 = 0 ;
25477   double val2 ;
25478   int ecode2 = 0 ;
25479   double val3 ;
25480   int ecode3 = 0 ;
25481   double val4 ;
25482   int ecode4 = 0 ;
25483   PyObject * obj0 = 0 ;
25484   PyObject * obj1 = 0 ;
25485   PyObject * obj2 = 0 ;
25486   PyObject * obj3 = 0 ;
25487   Hex::Vector *result = 0 ;
25488
25489   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_addVector",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25490   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25491   if (!SWIG_IsOK(res1)) {
25492     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
25493   }
25494   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25495   ecode2 = SWIG_AsVal_double(obj1, &val2);
25496   if (!SWIG_IsOK(ecode2)) {
25497     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
25498   }
25499   arg2 = static_cast< double >(val2);
25500   ecode3 = SWIG_AsVal_double(obj2, &val3);
25501   if (!SWIG_IsOK(ecode3)) {
25502     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVector" "', argument " "3"" of type '" "double""'");
25503   }
25504   arg3 = static_cast< double >(val3);
25505   ecode4 = SWIG_AsVal_double(obj3, &val4);
25506   if (!SWIG_IsOK(ecode4)) {
25507     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_addVector" "', argument " "4"" of type '" "double""'");
25508   }
25509   arg4 = static_cast< double >(val4);
25510   result = (Hex::Vector *)(arg1)->addVector(arg2,arg3,arg4);
25511   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
25512   return resultobj;
25513 fail:
25514   return NULL;
25515 }
25516
25517
25518 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25519   PyObject *resultobj = 0;
25520   Hex::Document *arg1 = (Hex::Document *) 0 ;
25521   double arg2 ;
25522   double arg3 ;
25523   void *argp1 = 0 ;
25524   int res1 = 0 ;
25525   double val2 ;
25526   int ecode2 = 0 ;
25527   double val3 ;
25528   int ecode3 = 0 ;
25529   PyObject * obj0 = 0 ;
25530   PyObject * obj1 = 0 ;
25531   PyObject * obj2 = 0 ;
25532   Hex::Vector *result = 0 ;
25533
25534   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVector",&obj0,&obj1,&obj2)) SWIG_fail;
25535   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25536   if (!SWIG_IsOK(res1)) {
25537     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
25538   }
25539   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25540   ecode2 = SWIG_AsVal_double(obj1, &val2);
25541   if (!SWIG_IsOK(ecode2)) {
25542     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
25543   }
25544   arg2 = static_cast< double >(val2);
25545   ecode3 = SWIG_AsVal_double(obj2, &val3);
25546   if (!SWIG_IsOK(ecode3)) {
25547     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addVector" "', argument " "3"" of type '" "double""'");
25548   }
25549   arg3 = static_cast< double >(val3);
25550   result = (Hex::Vector *)(arg1)->addVector(arg2,arg3);
25551   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
25552   return resultobj;
25553 fail:
25554   return NULL;
25555 }
25556
25557
25558 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25559   PyObject *resultobj = 0;
25560   Hex::Document *arg1 = (Hex::Document *) 0 ;
25561   double arg2 ;
25562   void *argp1 = 0 ;
25563   int res1 = 0 ;
25564   double val2 ;
25565   int ecode2 = 0 ;
25566   PyObject * obj0 = 0 ;
25567   PyObject * obj1 = 0 ;
25568   Hex::Vector *result = 0 ;
25569
25570   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVector",&obj0,&obj1)) SWIG_fail;
25571   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25572   if (!SWIG_IsOK(res1)) {
25573     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
25574   }
25575   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25576   ecode2 = SWIG_AsVal_double(obj1, &val2);
25577   if (!SWIG_IsOK(ecode2)) {
25578     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addVector" "', argument " "2"" of type '" "double""'");
25579   }
25580   arg2 = static_cast< double >(val2);
25581   result = (Hex::Vector *)(arg1)->addVector(arg2);
25582   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
25583   return resultobj;
25584 fail:
25585   return NULL;
25586 }
25587
25588
25589 SWIGINTERN PyObject *_wrap_Document_addVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25590   PyObject *resultobj = 0;
25591   Hex::Document *arg1 = (Hex::Document *) 0 ;
25592   void *argp1 = 0 ;
25593   int res1 = 0 ;
25594   PyObject * obj0 = 0 ;
25595   Hex::Vector *result = 0 ;
25596
25597   if (!PyArg_ParseTuple(args,(char *)"O:Document_addVector",&obj0)) SWIG_fail;
25598   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25599   if (!SWIG_IsOK(res1)) {
25600     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVector" "', argument " "1"" of type '" "Hex::Document *""'");
25601   }
25602   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25603   result = (Hex::Vector *)(arg1)->addVector();
25604   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
25605   return resultobj;
25606 fail:
25607   return NULL;
25608 }
25609
25610
25611 SWIGINTERN PyObject *_wrap_Document_addVector(PyObject *self, PyObject *args) {
25612   Py_ssize_t argc;
25613   PyObject *argv[5] = {
25614     0
25615   };
25616   Py_ssize_t ii;
25617
25618   if (!PyTuple_Check(args)) SWIG_fail;
25619   argc = args ? PyObject_Length(args) : 0;
25620   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
25621     argv[ii] = PyTuple_GET_ITEM(args,ii);
25622   }
25623   if (argc == 1) {
25624     int _v;
25625     void *vptr = 0;
25626     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25627     _v = SWIG_CheckState(res);
25628     if (_v) {
25629       return _wrap_Document_addVector__SWIG_3(self, args);
25630     }
25631   }
25632   if (argc == 2) {
25633     int _v;
25634     void *vptr = 0;
25635     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25636     _v = SWIG_CheckState(res);
25637     if (_v) {
25638       {
25639         int res = SWIG_AsVal_double(argv[1], NULL);
25640         _v = SWIG_CheckState(res);
25641       }
25642       if (_v) {
25643         return _wrap_Document_addVector__SWIG_2(self, args);
25644       }
25645     }
25646   }
25647   if (argc == 3) {
25648     int _v;
25649     void *vptr = 0;
25650     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25651     _v = SWIG_CheckState(res);
25652     if (_v) {
25653       {
25654         int res = SWIG_AsVal_double(argv[1], NULL);
25655         _v = SWIG_CheckState(res);
25656       }
25657       if (_v) {
25658         {
25659           int res = SWIG_AsVal_double(argv[2], NULL);
25660           _v = SWIG_CheckState(res);
25661         }
25662         if (_v) {
25663           return _wrap_Document_addVector__SWIG_1(self, args);
25664         }
25665       }
25666     }
25667   }
25668   if (argc == 4) {
25669     int _v;
25670     void *vptr = 0;
25671     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25672     _v = SWIG_CheckState(res);
25673     if (_v) {
25674       {
25675         int res = SWIG_AsVal_double(argv[1], NULL);
25676         _v = SWIG_CheckState(res);
25677       }
25678       if (_v) {
25679         {
25680           int res = SWIG_AsVal_double(argv[2], NULL);
25681           _v = SWIG_CheckState(res);
25682         }
25683         if (_v) {
25684           {
25685             int res = SWIG_AsVal_double(argv[3], NULL);
25686             _v = SWIG_CheckState(res);
25687           }
25688           if (_v) {
25689             return _wrap_Document_addVector__SWIG_0(self, args);
25690           }
25691         }
25692       }
25693     }
25694   }
25695
25696 fail:
25697   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_addVector'.\n"
25698     "  Possible C/C++ prototypes are:\n"
25699     "    Hex::Document::addVector(double,double,double)\n"
25700     "    Hex::Document::addVector(double,double)\n"
25701     "    Hex::Document::addVector(double)\n"
25702     "    Hex::Document::addVector()\n");
25703   return 0;
25704 }
25705
25706
25707 SWIGINTERN PyObject *_wrap_Document_addVectorVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25708   PyObject *resultobj = 0;
25709   Hex::Document *arg1 = (Hex::Document *) 0 ;
25710   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
25711   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
25712   void *argp1 = 0 ;
25713   int res1 = 0 ;
25714   void *argp2 = 0 ;
25715   int res2 = 0 ;
25716   void *argp3 = 0 ;
25717   int res3 = 0 ;
25718   PyObject * obj0 = 0 ;
25719   PyObject * obj1 = 0 ;
25720   PyObject * obj2 = 0 ;
25721   Hex::Vector *result = 0 ;
25722
25723   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addVectorVertices",&obj0,&obj1,&obj2)) SWIG_fail;
25724   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25725   if (!SWIG_IsOK(res1)) {
25726     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addVectorVertices" "', argument " "1"" of type '" "Hex::Document *""'");
25727   }
25728   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25729   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25730   if (!SWIG_IsOK(res2)) {
25731     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addVectorVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
25732   }
25733   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
25734   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
25735   if (!SWIG_IsOK(res3)) {
25736     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addVectorVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
25737   }
25738   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
25739   result = (Hex::Vector *)(arg1)->addVectorVertices(arg2,arg3);
25740   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
25741   return resultobj;
25742 fail:
25743   return NULL;
25744 }
25745
25746
25747 SWIGINTERN PyObject *_wrap_Document_addLaw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25748   PyObject *resultobj = 0;
25749   Hex::Document *arg1 = (Hex::Document *) 0 ;
25750   char *arg2 = (char *) 0 ;
25751   int arg3 ;
25752   void *argp1 = 0 ;
25753   int res1 = 0 ;
25754   int res2 ;
25755   char *buf2 = 0 ;
25756   int alloc2 = 0 ;
25757   int val3 ;
25758   int ecode3 = 0 ;
25759   PyObject * obj0 = 0 ;
25760   PyObject * obj1 = 0 ;
25761   PyObject * obj2 = 0 ;
25762   Hex::Law *result = 0 ;
25763
25764   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaw",&obj0,&obj1,&obj2)) SWIG_fail;
25765   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25766   if (!SWIG_IsOK(res1)) {
25767     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaw" "', argument " "1"" of type '" "Hex::Document *""'");
25768   }
25769   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25770   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25771   if (!SWIG_IsOK(res2)) {
25772     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addLaw" "', argument " "2"" of type '" "char const *""'");
25773   }
25774   arg2 = reinterpret_cast< char * >(buf2);
25775   ecode3 = SWIG_AsVal_int(obj2, &val3);
25776   if (!SWIG_IsOK(ecode3)) {
25777     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addLaw" "', argument " "3"" of type '" "int""'");
25778   }
25779   arg3 = static_cast< int >(val3);
25780   result = (Hex::Law *)(arg1)->addLaw((char const *)arg2,arg3);
25781   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
25782   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25783   return resultobj;
25784 fail:
25785   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25786   return NULL;
25787 }
25788
25789
25790 SWIGINTERN PyObject *_wrap_Document_addLaws__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25791   PyObject *resultobj = 0;
25792   Hex::Document *arg1 = (Hex::Document *) 0 ;
25793   double arg2 ;
25794   bool arg3 ;
25795   void *argp1 = 0 ;
25796   int res1 = 0 ;
25797   double val2 ;
25798   int ecode2 = 0 ;
25799   bool val3 ;
25800   int ecode3 = 0 ;
25801   PyObject * obj0 = 0 ;
25802   PyObject * obj1 = 0 ;
25803   PyObject * obj2 = 0 ;
25804   int result;
25805
25806   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addLaws",&obj0,&obj1,&obj2)) SWIG_fail;
25807   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25808   if (!SWIG_IsOK(res1)) {
25809     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaws" "', argument " "1"" of type '" "Hex::Document *""'");
25810   }
25811   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25812   ecode2 = SWIG_AsVal_double(obj1, &val2);
25813   if (!SWIG_IsOK(ecode2)) {
25814     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addLaws" "', argument " "2"" of type '" "double""'");
25815   }
25816   arg2 = static_cast< double >(val2);
25817   ecode3 = SWIG_AsVal_bool(obj2, &val3);
25818   if (!SWIG_IsOK(ecode3)) {
25819     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addLaws" "', argument " "3"" of type '" "bool""'");
25820   }
25821   arg3 = static_cast< bool >(val3);
25822   result = (int)(arg1)->addLaws(arg2,arg3);
25823   resultobj = SWIG_From_int(static_cast< int >(result));
25824   return resultobj;
25825 fail:
25826   return NULL;
25827 }
25828
25829
25830 SWIGINTERN PyObject *_wrap_Document_addLaws__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25831   PyObject *resultobj = 0;
25832   Hex::Document *arg1 = (Hex::Document *) 0 ;
25833   double arg2 ;
25834   void *argp1 = 0 ;
25835   int res1 = 0 ;
25836   double val2 ;
25837   int ecode2 = 0 ;
25838   PyObject * obj0 = 0 ;
25839   PyObject * obj1 = 0 ;
25840   int result;
25841
25842   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaws",&obj0,&obj1)) SWIG_fail;
25843   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25844   if (!SWIG_IsOK(res1)) {
25845     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaws" "', argument " "1"" of type '" "Hex::Document *""'");
25846   }
25847   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25848   ecode2 = SWIG_AsVal_double(obj1, &val2);
25849   if (!SWIG_IsOK(ecode2)) {
25850     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addLaws" "', argument " "2"" of type '" "double""'");
25851   }
25852   arg2 = static_cast< double >(val2);
25853   result = (int)(arg1)->addLaws(arg2);
25854   resultobj = SWIG_From_int(static_cast< int >(result));
25855   return resultobj;
25856 fail:
25857   return NULL;
25858 }
25859
25860
25861 SWIGINTERN PyObject *_wrap_Document_addLaws(PyObject *self, PyObject *args) {
25862   Py_ssize_t argc;
25863   PyObject *argv[4] = {
25864     0
25865   };
25866   Py_ssize_t ii;
25867
25868   if (!PyTuple_Check(args)) SWIG_fail;
25869   argc = args ? PyObject_Length(args) : 0;
25870   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
25871     argv[ii] = PyTuple_GET_ITEM(args,ii);
25872   }
25873   if (argc == 2) {
25874     int _v;
25875     void *vptr = 0;
25876     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25877     _v = SWIG_CheckState(res);
25878     if (_v) {
25879       {
25880         int res = SWIG_AsVal_double(argv[1], NULL);
25881         _v = SWIG_CheckState(res);
25882       }
25883       if (_v) {
25884         return _wrap_Document_addLaws__SWIG_1(self, args);
25885       }
25886     }
25887   }
25888   if (argc == 3) {
25889     int _v;
25890     void *vptr = 0;
25891     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
25892     _v = SWIG_CheckState(res);
25893     if (_v) {
25894       {
25895         int res = SWIG_AsVal_double(argv[1], NULL);
25896         _v = SWIG_CheckState(res);
25897       }
25898       if (_v) {
25899         {
25900           int res = SWIG_AsVal_bool(argv[2], NULL);
25901           _v = SWIG_CheckState(res);
25902         }
25903         if (_v) {
25904           return _wrap_Document_addLaws__SWIG_0(self, args);
25905         }
25906       }
25907     }
25908   }
25909
25910 fail:
25911   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_addLaws'.\n"
25912     "  Possible C/C++ prototypes are:\n"
25913     "    Hex::Document::addLaws(double,bool)\n"
25914     "    Hex::Document::addLaws(double)\n");
25915   return 0;
25916 }
25917
25918
25919 SWIGINTERN PyObject *_wrap_Document_addHexaGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25920   PyObject *resultobj = 0;
25921   Hex::Document *arg1 = (Hex::Document *) 0 ;
25922   cpchar arg2 = (cpchar) 0 ;
25923   void *argp1 = 0 ;
25924   int res1 = 0 ;
25925   int res2 ;
25926   char *buf2 = 0 ;
25927   int alloc2 = 0 ;
25928   PyObject * obj0 = 0 ;
25929   PyObject * obj1 = 0 ;
25930   Hex::Group *result = 0 ;
25931
25932   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaGroup",&obj0,&obj1)) SWIG_fail;
25933   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25934   if (!SWIG_IsOK(res1)) {
25935     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaGroup" "', argument " "1"" of type '" "Hex::Document *""'");
25936   }
25937   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25938   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25939   if (!SWIG_IsOK(res2)) {
25940     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaGroup" "', argument " "2"" of type '" "cpchar""'");
25941   }
25942   arg2 = reinterpret_cast< cpchar >(buf2);
25943   result = (Hex::Group *)(arg1)->addHexaGroup(arg2);
25944   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
25945   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25946   return resultobj;
25947 fail:
25948   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25949   return NULL;
25950 }
25951
25952
25953 SWIGINTERN PyObject *_wrap_Document_addQuadGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25954   PyObject *resultobj = 0;
25955   Hex::Document *arg1 = (Hex::Document *) 0 ;
25956   cpchar arg2 = (cpchar) 0 ;
25957   void *argp1 = 0 ;
25958   int res1 = 0 ;
25959   int res2 ;
25960   char *buf2 = 0 ;
25961   int alloc2 = 0 ;
25962   PyObject * obj0 = 0 ;
25963   PyObject * obj1 = 0 ;
25964   Hex::Group *result = 0 ;
25965
25966   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadGroup",&obj0,&obj1)) SWIG_fail;
25967   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
25968   if (!SWIG_IsOK(res1)) {
25969     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadGroup" "', argument " "1"" of type '" "Hex::Document *""'");
25970   }
25971   arg1 = reinterpret_cast< Hex::Document * >(argp1);
25972   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25973   if (!SWIG_IsOK(res2)) {
25974     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadGroup" "', argument " "2"" of type '" "cpchar""'");
25975   }
25976   arg2 = reinterpret_cast< cpchar >(buf2);
25977   result = (Hex::Group *)(arg1)->addQuadGroup(arg2);
25978   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
25979   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25980   return resultobj;
25981 fail:
25982   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25983   return NULL;
25984 }
25985
25986
25987 SWIGINTERN PyObject *_wrap_Document_addQuadNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25988   PyObject *resultobj = 0;
25989   Hex::Document *arg1 = (Hex::Document *) 0 ;
25990   cpchar arg2 = (cpchar) 0 ;
25991   void *argp1 = 0 ;
25992   int res1 = 0 ;
25993   int res2 ;
25994   char *buf2 = 0 ;
25995   int alloc2 = 0 ;
25996   PyObject * obj0 = 0 ;
25997   PyObject * obj1 = 0 ;
25998   Hex::Group *result = 0 ;
25999
26000   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addQuadNodeGroup",&obj0,&obj1)) SWIG_fail;
26001   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26002   if (!SWIG_IsOK(res1)) {
26003     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addQuadNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
26004   }
26005   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26006   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26007   if (!SWIG_IsOK(res2)) {
26008     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addQuadNodeGroup" "', argument " "2"" of type '" "cpchar""'");
26009   }
26010   arg2 = reinterpret_cast< cpchar >(buf2);
26011   result = (Hex::Group *)(arg1)->addQuadNodeGroup(arg2);
26012   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
26013   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26014   return resultobj;
26015 fail:
26016   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26017   return NULL;
26018 }
26019
26020
26021 SWIGINTERN PyObject *_wrap_Document_addHexaNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26022   PyObject *resultobj = 0;
26023   Hex::Document *arg1 = (Hex::Document *) 0 ;
26024   cpchar arg2 = (cpchar) 0 ;
26025   void *argp1 = 0 ;
26026   int res1 = 0 ;
26027   int res2 ;
26028   char *buf2 = 0 ;
26029   int alloc2 = 0 ;
26030   PyObject * obj0 = 0 ;
26031   PyObject * obj1 = 0 ;
26032   Hex::Group *result = 0 ;
26033
26034   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addHexaNodeGroup",&obj0,&obj1)) SWIG_fail;
26035   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26036   if (!SWIG_IsOK(res1)) {
26037     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addHexaNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
26038   }
26039   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26040   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26041   if (!SWIG_IsOK(res2)) {
26042     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addHexaNodeGroup" "', argument " "2"" of type '" "cpchar""'");
26043   }
26044   arg2 = reinterpret_cast< cpchar >(buf2);
26045   result = (Hex::Group *)(arg1)->addHexaNodeGroup(arg2);
26046   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
26047   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26048   return resultobj;
26049 fail:
26050   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26051   return NULL;
26052 }
26053
26054
26055 SWIGINTERN PyObject *_wrap_Document_addEdgeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26056   PyObject *resultobj = 0;
26057   Hex::Document *arg1 = (Hex::Document *) 0 ;
26058   cpchar arg2 = (cpchar) 0 ;
26059   void *argp1 = 0 ;
26060   int res1 = 0 ;
26061   int res2 ;
26062   char *buf2 = 0 ;
26063   int alloc2 = 0 ;
26064   PyObject * obj0 = 0 ;
26065   PyObject * obj1 = 0 ;
26066   Hex::Group *result = 0 ;
26067
26068   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeGroup",&obj0,&obj1)) SWIG_fail;
26069   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26070   if (!SWIG_IsOK(res1)) {
26071     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
26072   }
26073   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26074   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26075   if (!SWIG_IsOK(res2)) {
26076     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeGroup" "', argument " "2"" of type '" "cpchar""'");
26077   }
26078   arg2 = reinterpret_cast< cpchar >(buf2);
26079   result = (Hex::Group *)(arg1)->addEdgeGroup(arg2);
26080   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
26081   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26082   return resultobj;
26083 fail:
26084   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26085   return NULL;
26086 }
26087
26088
26089 SWIGINTERN PyObject *_wrap_Document_addEdgeNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26090   PyObject *resultobj = 0;
26091   Hex::Document *arg1 = (Hex::Document *) 0 ;
26092   cpchar arg2 = (cpchar) 0 ;
26093   void *argp1 = 0 ;
26094   int res1 = 0 ;
26095   int res2 ;
26096   char *buf2 = 0 ;
26097   int alloc2 = 0 ;
26098   PyObject * obj0 = 0 ;
26099   PyObject * obj1 = 0 ;
26100   Hex::Group *result = 0 ;
26101
26102   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addEdgeNodeGroup",&obj0,&obj1)) SWIG_fail;
26103   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26104   if (!SWIG_IsOK(res1)) {
26105     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addEdgeNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
26106   }
26107   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26108   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26109   if (!SWIG_IsOK(res2)) {
26110     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addEdgeNodeGroup" "', argument " "2"" of type '" "cpchar""'");
26111   }
26112   arg2 = reinterpret_cast< cpchar >(buf2);
26113   result = (Hex::Group *)(arg1)->addEdgeNodeGroup(arg2);
26114   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
26115   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26116   return resultobj;
26117 fail:
26118   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26119   return NULL;
26120 }
26121
26122
26123 SWIGINTERN PyObject *_wrap_Document_addVertexNodeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26124   PyObject *resultobj = 0;
26125   Hex::Document *arg1 = (Hex::Document *) 0 ;
26126   cpchar arg2 = (cpchar) 0 ;
26127   void *argp1 = 0 ;
26128   int res1 = 0 ;
26129   int res2 ;
26130   char *buf2 = 0 ;
26131   int alloc2 = 0 ;
26132   PyObject * obj0 = 0 ;
26133   PyObject * obj1 = 0 ;
26134   Hex::Group *result = 0 ;
26135
26136   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addVertexNodeGroup",&obj0,&obj1)) 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_addVertexNodeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
26140   }
26141   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26142   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26143   if (!SWIG_IsOK(res2)) {
26144     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addVertexNodeGroup" "', argument " "2"" of type '" "cpchar""'");
26145   }
26146   arg2 = reinterpret_cast< cpchar >(buf2);
26147   result = (Hex::Group *)(arg1)->addVertexNodeGroup(arg2);
26148   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
26149   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26150   return resultobj;
26151 fail:
26152   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26153   return NULL;
26154 }
26155
26156
26157 SWIGINTERN PyObject *_wrap_Document_makeTranslation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26158   PyObject *resultobj = 0;
26159   Hex::Document *arg1 = (Hex::Document *) 0 ;
26160   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26161   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26162   void *argp1 = 0 ;
26163   int res1 = 0 ;
26164   void *argp2 = 0 ;
26165   int res2 = 0 ;
26166   void *argp3 = 0 ;
26167   int res3 = 0 ;
26168   PyObject * obj0 = 0 ;
26169   PyObject * obj1 = 0 ;
26170   PyObject * obj2 = 0 ;
26171   Hex::Elements *result = 0 ;
26172
26173   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
26174   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26175   if (!SWIG_IsOK(res1)) {
26176     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeTranslation" "', argument " "1"" of type '" "Hex::Document *""'");
26177   }
26178   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26179   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26180   if (!SWIG_IsOK(res2)) {
26181     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeTranslation" "', argument " "2"" of type '" "Hex::Elements *""'");
26182   }
26183   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26184   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26185   if (!SWIG_IsOK(res3)) {
26186     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeTranslation" "', argument " "3"" of type '" "Hex::Vector *""'");
26187   }
26188   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26189   result = (Hex::Elements *)(arg1)->makeTranslation(arg2,arg3);
26190   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26191   return resultobj;
26192 fail:
26193   return NULL;
26194 }
26195
26196
26197 SWIGINTERN PyObject *_wrap_Document_makeScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26198   PyObject *resultobj = 0;
26199   Hex::Document *arg1 = (Hex::Document *) 0 ;
26200   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26201   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26202   double arg4 ;
26203   void *argp1 = 0 ;
26204   int res1 = 0 ;
26205   void *argp2 = 0 ;
26206   int res2 = 0 ;
26207   void *argp3 = 0 ;
26208   int res3 = 0 ;
26209   double val4 ;
26210   int ecode4 = 0 ;
26211   PyObject * obj0 = 0 ;
26212   PyObject * obj1 = 0 ;
26213   PyObject * obj2 = 0 ;
26214   PyObject * obj3 = 0 ;
26215   Hex::Elements *result = 0 ;
26216
26217   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26218   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26219   if (!SWIG_IsOK(res1)) {
26220     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeScale" "', argument " "1"" of type '" "Hex::Document *""'");
26221   }
26222   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26223   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26224   if (!SWIG_IsOK(res2)) {
26225     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeScale" "', argument " "2"" of type '" "Hex::Elements *""'");
26226   }
26227   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26228   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26229   if (!SWIG_IsOK(res3)) {
26230     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeScale" "', argument " "3"" of type '" "Hex::Vertex *""'");
26231   }
26232   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26233   ecode4 = SWIG_AsVal_double(obj3, &val4);
26234   if (!SWIG_IsOK(ecode4)) {
26235     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeScale" "', argument " "4"" of type '" "double""'");
26236   }
26237   arg4 = static_cast< double >(val4);
26238   result = (Hex::Elements *)(arg1)->makeScale(arg2,arg3,arg4);
26239   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26240   return resultobj;
26241 fail:
26242   return NULL;
26243 }
26244
26245
26246 SWIGINTERN PyObject *_wrap_Document_makeRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26247   PyObject *resultobj = 0;
26248   Hex::Document *arg1 = (Hex::Document *) 0 ;
26249   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26250   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26251   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26252   double arg5 ;
26253   void *argp1 = 0 ;
26254   int res1 = 0 ;
26255   void *argp2 = 0 ;
26256   int res2 = 0 ;
26257   void *argp3 = 0 ;
26258   int res3 = 0 ;
26259   void *argp4 = 0 ;
26260   int res4 = 0 ;
26261   double val5 ;
26262   int ecode5 = 0 ;
26263   PyObject * obj0 = 0 ;
26264   PyObject * obj1 = 0 ;
26265   PyObject * obj2 = 0 ;
26266   PyObject * obj3 = 0 ;
26267   PyObject * obj4 = 0 ;
26268   Hex::Elements *result = 0 ;
26269
26270   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26271   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26272   if (!SWIG_IsOK(res1)) {
26273     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRotation" "', argument " "1"" of type '" "Hex::Document *""'");
26274   }
26275   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26276   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26277   if (!SWIG_IsOK(res2)) {
26278     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRotation" "', argument " "2"" of type '" "Hex::Elements *""'");
26279   }
26280   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26281   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26282   if (!SWIG_IsOK(res3)) {
26283     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRotation" "', argument " "3"" of type '" "Hex::Vertex *""'");
26284   }
26285   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26286   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26287   if (!SWIG_IsOK(res4)) {
26288     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRotation" "', argument " "4"" of type '" "Hex::Vector *""'");
26289   }
26290   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26291   ecode5 = SWIG_AsVal_double(obj4, &val5);
26292   if (!SWIG_IsOK(ecode5)) {
26293     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeRotation" "', argument " "5"" of type '" "double""'");
26294   }
26295   arg5 = static_cast< double >(val5);
26296   result = (Hex::Elements *)(arg1)->makeRotation(arg2,arg3,arg4,arg5);
26297   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26298   return resultobj;
26299 fail:
26300   return NULL;
26301 }
26302
26303
26304 SWIGINTERN PyObject *_wrap_Document_makeSymmetryPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305   PyObject *resultobj = 0;
26306   Hex::Document *arg1 = (Hex::Document *) 0 ;
26307   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26308   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26309   void *argp1 = 0 ;
26310   int res1 = 0 ;
26311   void *argp2 = 0 ;
26312   int res2 = 0 ;
26313   void *argp3 = 0 ;
26314   int res3 = 0 ;
26315   PyObject * obj0 = 0 ;
26316   PyObject * obj1 = 0 ;
26317   PyObject * obj2 = 0 ;
26318   Hex::Elements *result = 0 ;
26319
26320   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
26321   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26322   if (!SWIG_IsOK(res1)) {
26323     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryPoint" "', argument " "1"" of type '" "Hex::Document *""'");
26324   }
26325   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26326   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26327   if (!SWIG_IsOK(res2)) {
26328     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryPoint" "', argument " "2"" of type '" "Hex::Elements *""'");
26329   }
26330   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26331   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26332   if (!SWIG_IsOK(res3)) {
26333     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryPoint" "', argument " "3"" of type '" "Hex::Vertex *""'");
26334   }
26335   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26336   result = (Hex::Elements *)(arg1)->makeSymmetryPoint(arg2,arg3);
26337   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26338   return resultobj;
26339 fail:
26340   return NULL;
26341 }
26342
26343
26344 SWIGINTERN PyObject *_wrap_Document_makeSymmetryLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26345   PyObject *resultobj = 0;
26346   Hex::Document *arg1 = (Hex::Document *) 0 ;
26347   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26348   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26349   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26350   void *argp1 = 0 ;
26351   int res1 = 0 ;
26352   void *argp2 = 0 ;
26353   int res2 = 0 ;
26354   void *argp3 = 0 ;
26355   int res3 = 0 ;
26356   void *argp4 = 0 ;
26357   int res4 = 0 ;
26358   PyObject * obj0 = 0 ;
26359   PyObject * obj1 = 0 ;
26360   PyObject * obj2 = 0 ;
26361   PyObject * obj3 = 0 ;
26362   Hex::Elements *result = 0 ;
26363
26364   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26365   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26366   if (!SWIG_IsOK(res1)) {
26367     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryLine" "', argument " "1"" of type '" "Hex::Document *""'");
26368   }
26369   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26370   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26371   if (!SWIG_IsOK(res2)) {
26372     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryLine" "', argument " "2"" of type '" "Hex::Elements *""'");
26373   }
26374   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26375   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26376   if (!SWIG_IsOK(res3)) {
26377     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryLine" "', argument " "3"" of type '" "Hex::Vertex *""'");
26378   }
26379   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26380   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26381   if (!SWIG_IsOK(res4)) {
26382     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSymmetryLine" "', argument " "4"" of type '" "Hex::Vector *""'");
26383   }
26384   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26385   result = (Hex::Elements *)(arg1)->makeSymmetryLine(arg2,arg3,arg4);
26386   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26387   return resultobj;
26388 fail:
26389   return NULL;
26390 }
26391
26392
26393 SWIGINTERN PyObject *_wrap_Document_makeSymmetryPlane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26394   PyObject *resultobj = 0;
26395   Hex::Document *arg1 = (Hex::Document *) 0 ;
26396   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26397   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26398   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26399   void *argp1 = 0 ;
26400   int res1 = 0 ;
26401   void *argp2 = 0 ;
26402   int res2 = 0 ;
26403   void *argp3 = 0 ;
26404   int res3 = 0 ;
26405   void *argp4 = 0 ;
26406   int res4 = 0 ;
26407   PyObject * obj0 = 0 ;
26408   PyObject * obj1 = 0 ;
26409   PyObject * obj2 = 0 ;
26410   PyObject * obj3 = 0 ;
26411   Hex::Elements *result = 0 ;
26412
26413   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26414   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26415   if (!SWIG_IsOK(res1)) {
26416     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSymmetryPlane" "', argument " "1"" of type '" "Hex::Document *""'");
26417   }
26418   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26419   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26420   if (!SWIG_IsOK(res2)) {
26421     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSymmetryPlane" "', argument " "2"" of type '" "Hex::Elements *""'");
26422   }
26423   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26424   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26425   if (!SWIG_IsOK(res3)) {
26426     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSymmetryPlane" "', argument " "3"" of type '" "Hex::Vertex *""'");
26427   }
26428   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26429   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26430   if (!SWIG_IsOK(res4)) {
26431     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSymmetryPlane" "', argument " "4"" of type '" "Hex::Vector *""'");
26432   }
26433   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26434   result = (Hex::Elements *)(arg1)->makeSymmetryPlane(arg2,arg3,arg4);
26435   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26436   return resultobj;
26437 fail:
26438   return NULL;
26439 }
26440
26441
26442 SWIGINTERN PyObject *_wrap_Document_performTranslation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26443   PyObject *resultobj = 0;
26444   Hex::Document *arg1 = (Hex::Document *) 0 ;
26445   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26446   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
26447   void *argp1 = 0 ;
26448   int res1 = 0 ;
26449   void *argp2 = 0 ;
26450   int res2 = 0 ;
26451   void *argp3 = 0 ;
26452   int res3 = 0 ;
26453   PyObject * obj0 = 0 ;
26454   PyObject * obj1 = 0 ;
26455   PyObject * obj2 = 0 ;
26456   int result;
26457
26458   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performTranslation",&obj0,&obj1,&obj2)) SWIG_fail;
26459   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26460   if (!SWIG_IsOK(res1)) {
26461     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performTranslation" "', argument " "1"" of type '" "Hex::Document *""'");
26462   }
26463   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26464   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26465   if (!SWIG_IsOK(res2)) {
26466     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performTranslation" "', argument " "2"" of type '" "Hex::Elements *""'");
26467   }
26468   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26469   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26470   if (!SWIG_IsOK(res3)) {
26471     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performTranslation" "', argument " "3"" of type '" "Hex::Vector *""'");
26472   }
26473   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
26474   result = (int)(arg1)->performTranslation(arg2,arg3);
26475   resultobj = SWIG_From_int(static_cast< int >(result));
26476   return resultobj;
26477 fail:
26478   return NULL;
26479 }
26480
26481
26482 SWIGINTERN PyObject *_wrap_Document_performScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26483   PyObject *resultobj = 0;
26484   Hex::Document *arg1 = (Hex::Document *) 0 ;
26485   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26486   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26487   double arg4 ;
26488   void *argp1 = 0 ;
26489   int res1 = 0 ;
26490   void *argp2 = 0 ;
26491   int res2 = 0 ;
26492   void *argp3 = 0 ;
26493   int res3 = 0 ;
26494   double val4 ;
26495   int ecode4 = 0 ;
26496   PyObject * obj0 = 0 ;
26497   PyObject * obj1 = 0 ;
26498   PyObject * obj2 = 0 ;
26499   PyObject * obj3 = 0 ;
26500   int result;
26501
26502   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performScale",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26503   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26504   if (!SWIG_IsOK(res1)) {
26505     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performScale" "', argument " "1"" of type '" "Hex::Document *""'");
26506   }
26507   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26508   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26509   if (!SWIG_IsOK(res2)) {
26510     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performScale" "', argument " "2"" of type '" "Hex::Elements *""'");
26511   }
26512   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26513   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26514   if (!SWIG_IsOK(res3)) {
26515     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performScale" "', argument " "3"" of type '" "Hex::Vertex *""'");
26516   }
26517   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26518   ecode4 = SWIG_AsVal_double(obj3, &val4);
26519   if (!SWIG_IsOK(ecode4)) {
26520     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_performScale" "', argument " "4"" of type '" "double""'");
26521   }
26522   arg4 = static_cast< double >(val4);
26523   result = (int)(arg1)->performScale(arg2,arg3,arg4);
26524   resultobj = SWIG_From_int(static_cast< int >(result));
26525   return resultobj;
26526 fail:
26527   return NULL;
26528 }
26529
26530
26531 SWIGINTERN PyObject *_wrap_Document_performRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26532   PyObject *resultobj = 0;
26533   Hex::Document *arg1 = (Hex::Document *) 0 ;
26534   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26535   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26536   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26537   double arg5 ;
26538   void *argp1 = 0 ;
26539   int res1 = 0 ;
26540   void *argp2 = 0 ;
26541   int res2 = 0 ;
26542   void *argp3 = 0 ;
26543   int res3 = 0 ;
26544   void *argp4 = 0 ;
26545   int res4 = 0 ;
26546   double val5 ;
26547   int ecode5 = 0 ;
26548   PyObject * obj0 = 0 ;
26549   PyObject * obj1 = 0 ;
26550   PyObject * obj2 = 0 ;
26551   PyObject * obj3 = 0 ;
26552   PyObject * obj4 = 0 ;
26553   int result;
26554
26555   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_performRotation",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
26556   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26557   if (!SWIG_IsOK(res1)) {
26558     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performRotation" "', argument " "1"" of type '" "Hex::Document *""'");
26559   }
26560   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26561   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26562   if (!SWIG_IsOK(res2)) {
26563     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performRotation" "', argument " "2"" of type '" "Hex::Elements *""'");
26564   }
26565   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26566   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26567   if (!SWIG_IsOK(res3)) {
26568     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performRotation" "', argument " "3"" of type '" "Hex::Vertex *""'");
26569   }
26570   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26571   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26572   if (!SWIG_IsOK(res4)) {
26573     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performRotation" "', argument " "4"" of type '" "Hex::Vector *""'");
26574   }
26575   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26576   ecode5 = SWIG_AsVal_double(obj4, &val5);
26577   if (!SWIG_IsOK(ecode5)) {
26578     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_performRotation" "', argument " "5"" of type '" "double""'");
26579   }
26580   arg5 = static_cast< double >(val5);
26581   result = (int)(arg1)->performRotation(arg2,arg3,arg4,arg5);
26582   resultobj = SWIG_From_int(static_cast< int >(result));
26583   return resultobj;
26584 fail:
26585   return NULL;
26586 }
26587
26588
26589 SWIGINTERN PyObject *_wrap_Document_performSymmetryPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26590   PyObject *resultobj = 0;
26591   Hex::Document *arg1 = (Hex::Document *) 0 ;
26592   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26593   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26594   void *argp1 = 0 ;
26595   int res1 = 0 ;
26596   void *argp2 = 0 ;
26597   int res2 = 0 ;
26598   void *argp3 = 0 ;
26599   int res3 = 0 ;
26600   PyObject * obj0 = 0 ;
26601   PyObject * obj1 = 0 ;
26602   PyObject * obj2 = 0 ;
26603   int result;
26604
26605   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_performSymmetryPoint",&obj0,&obj1,&obj2)) SWIG_fail;
26606   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26607   if (!SWIG_IsOK(res1)) {
26608     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryPoint" "', argument " "1"" of type '" "Hex::Document *""'");
26609   }
26610   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26611   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26612   if (!SWIG_IsOK(res2)) {
26613     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryPoint" "', argument " "2"" of type '" "Hex::Elements *""'");
26614   }
26615   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26616   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26617   if (!SWIG_IsOK(res3)) {
26618     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryPoint" "', argument " "3"" of type '" "Hex::Vertex *""'");
26619   }
26620   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26621   result = (int)(arg1)->performSymmetryPoint(arg2,arg3);
26622   resultobj = SWIG_From_int(static_cast< int >(result));
26623   return resultobj;
26624 fail:
26625   return NULL;
26626 }
26627
26628
26629 SWIGINTERN PyObject *_wrap_Document_performSymmetryLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26630   PyObject *resultobj = 0;
26631   Hex::Document *arg1 = (Hex::Document *) 0 ;
26632   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26633   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26634   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26635   void *argp1 = 0 ;
26636   int res1 = 0 ;
26637   void *argp2 = 0 ;
26638   int res2 = 0 ;
26639   void *argp3 = 0 ;
26640   int res3 = 0 ;
26641   void *argp4 = 0 ;
26642   int res4 = 0 ;
26643   PyObject * obj0 = 0 ;
26644   PyObject * obj1 = 0 ;
26645   PyObject * obj2 = 0 ;
26646   PyObject * obj3 = 0 ;
26647   int result;
26648
26649   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryLine",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26650   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26651   if (!SWIG_IsOK(res1)) {
26652     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryLine" "', argument " "1"" of type '" "Hex::Document *""'");
26653   }
26654   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26655   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26656   if (!SWIG_IsOK(res2)) {
26657     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryLine" "', argument " "2"" of type '" "Hex::Elements *""'");
26658   }
26659   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26660   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26661   if (!SWIG_IsOK(res3)) {
26662     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryLine" "', argument " "3"" of type '" "Hex::Vertex *""'");
26663   }
26664   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26665   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26666   if (!SWIG_IsOK(res4)) {
26667     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performSymmetryLine" "', argument " "4"" of type '" "Hex::Vector *""'");
26668   }
26669   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26670   result = (int)(arg1)->performSymmetryLine(arg2,arg3,arg4);
26671   resultobj = SWIG_From_int(static_cast< int >(result));
26672   return resultobj;
26673 fail:
26674   return NULL;
26675 }
26676
26677
26678 SWIGINTERN PyObject *_wrap_Document_performSymmetryPlane(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26679   PyObject *resultobj = 0;
26680   Hex::Document *arg1 = (Hex::Document *) 0 ;
26681   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
26682   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26683   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
26684   void *argp1 = 0 ;
26685   int res1 = 0 ;
26686   void *argp2 = 0 ;
26687   int res2 = 0 ;
26688   void *argp3 = 0 ;
26689   int res3 = 0 ;
26690   void *argp4 = 0 ;
26691   int res4 = 0 ;
26692   PyObject * obj0 = 0 ;
26693   PyObject * obj1 = 0 ;
26694   PyObject * obj2 = 0 ;
26695   PyObject * obj3 = 0 ;
26696   int result;
26697
26698   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_performSymmetryPlane",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26699   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26700   if (!SWIG_IsOK(res1)) {
26701     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_performSymmetryPlane" "', argument " "1"" of type '" "Hex::Document *""'");
26702   }
26703   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26704   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
26705   if (!SWIG_IsOK(res2)) {
26706     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_performSymmetryPlane" "', argument " "2"" of type '" "Hex::Elements *""'");
26707   }
26708   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
26709   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26710   if (!SWIG_IsOK(res3)) {
26711     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_performSymmetryPlane" "', argument " "3"" of type '" "Hex::Vertex *""'");
26712   }
26713   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26714   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
26715   if (!SWIG_IsOK(res4)) {
26716     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_performSymmetryPlane" "', argument " "4"" of type '" "Hex::Vector *""'");
26717   }
26718   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
26719   result = (int)(arg1)->performSymmetryPlane(arg2,arg3,arg4);
26720   resultobj = SWIG_From_int(static_cast< int >(result));
26721   return resultobj;
26722 fail:
26723   return NULL;
26724 }
26725
26726
26727 SWIGINTERN PyObject *_wrap_Document_disconnectQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26728   PyObject *resultobj = 0;
26729   Hex::Document *arg1 = (Hex::Document *) 0 ;
26730   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
26731   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
26732   void *argp1 = 0 ;
26733   int res1 = 0 ;
26734   void *argp2 = 0 ;
26735   int res2 = 0 ;
26736   void *argp3 = 0 ;
26737   int res3 = 0 ;
26738   PyObject * obj0 = 0 ;
26739   PyObject * obj1 = 0 ;
26740   PyObject * obj2 = 0 ;
26741   Hex::Elements *result = 0 ;
26742
26743   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectQuad",&obj0,&obj1,&obj2)) SWIG_fail;
26744   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26745   if (!SWIG_IsOK(res1)) {
26746     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectQuad" "', argument " "1"" of type '" "Hex::Document *""'");
26747   }
26748   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26749   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
26750   if (!SWIG_IsOK(res2)) {
26751     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectQuad" "', argument " "2"" of type '" "Hex::Hexa *""'");
26752   }
26753   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
26754   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
26755   if (!SWIG_IsOK(res3)) {
26756     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectQuad" "', argument " "3"" of type '" "Hex::Quad *""'");
26757   }
26758   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
26759   result = (Hex::Elements *)(arg1)->disconnectQuad(arg2,arg3);
26760   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26761   return resultobj;
26762 fail:
26763   return NULL;
26764 }
26765
26766
26767 SWIGINTERN PyObject *_wrap_Document_disconnectEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26768   PyObject *resultobj = 0;
26769   Hex::Document *arg1 = (Hex::Document *) 0 ;
26770   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
26771   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
26772   void *argp1 = 0 ;
26773   int res1 = 0 ;
26774   void *argp2 = 0 ;
26775   int res2 = 0 ;
26776   void *argp3 = 0 ;
26777   int res3 = 0 ;
26778   PyObject * obj0 = 0 ;
26779   PyObject * obj1 = 0 ;
26780   PyObject * obj2 = 0 ;
26781   Hex::Elements *result = 0 ;
26782
26783   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdge",&obj0,&obj1,&obj2)) SWIG_fail;
26784   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26785   if (!SWIG_IsOK(res1)) {
26786     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectEdge" "', argument " "1"" of type '" "Hex::Document *""'");
26787   }
26788   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26789   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
26790   if (!SWIG_IsOK(res2)) {
26791     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectEdge" "', argument " "2"" of type '" "Hex::Hexa *""'");
26792   }
26793   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
26794   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
26795   if (!SWIG_IsOK(res3)) {
26796     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectEdge" "', argument " "3"" of type '" "Hex::Edge *""'");
26797   }
26798   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
26799   result = (Hex::Elements *)(arg1)->disconnectEdge(arg2,arg3);
26800   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26801   return resultobj;
26802 fail:
26803   return NULL;
26804 }
26805
26806
26807 SWIGINTERN PyObject *_wrap_Document_disconnectVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26808   PyObject *resultobj = 0;
26809   Hex::Document *arg1 = (Hex::Document *) 0 ;
26810   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
26811   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26812   void *argp1 = 0 ;
26813   int res1 = 0 ;
26814   void *argp2 = 0 ;
26815   int res2 = 0 ;
26816   void *argp3 = 0 ;
26817   int res3 = 0 ;
26818   PyObject * obj0 = 0 ;
26819   PyObject * obj1 = 0 ;
26820   PyObject * obj2 = 0 ;
26821   Hex::Elements *result = 0 ;
26822
26823   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectVertex",&obj0,&obj1,&obj2)) SWIG_fail;
26824   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26825   if (!SWIG_IsOK(res1)) {
26826     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectVertex" "', argument " "1"" of type '" "Hex::Document *""'");
26827   }
26828   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26829   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
26830   if (!SWIG_IsOK(res2)) {
26831     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_disconnectVertex" "', argument " "2"" of type '" "Hex::Hexa *""'");
26832   }
26833   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
26834   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26835   if (!SWIG_IsOK(res3)) {
26836     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_disconnectVertex" "', argument " "3"" of type '" "Hex::Vertex *""'");
26837   }
26838   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
26839   result = (Hex::Elements *)(arg1)->disconnectVertex(arg2,arg3);
26840   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26841   return resultobj;
26842 fail:
26843   return NULL;
26844 }
26845
26846
26847 SWIGINTERN PyObject *_wrap_Document_disconnectEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26848   PyObject *resultobj = 0;
26849   Hex::Document *arg1 = (Hex::Document *) 0 ;
26850   Hex::Hexas arg2 ;
26851   Hex::Edges arg3 ;
26852   void *argp1 = 0 ;
26853   int res1 = 0 ;
26854   PyObject * obj0 = 0 ;
26855   PyObject * obj1 = 0 ;
26856   PyObject * obj2 = 0 ;
26857   Hex::Elements *result = 0 ;
26858
26859   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_disconnectEdges",&obj0,&obj1,&obj2)) SWIG_fail;
26860   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26861   if (!SWIG_IsOK(res1)) {
26862     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_disconnectEdges" "', argument " "1"" of type '" "Hex::Document *""'");
26863   }
26864   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26865   {
26866     std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *ptr = (std::vector< Hex::Hexa*,std::allocator< Hex::Hexa * > > *)0;
26867     int res = swig::asptr(obj1, &ptr);
26868     if (!SWIG_IsOK(res) || !ptr) {
26869       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "2"" of type '" "Hex::Hexas""'");
26870     }
26871     arg2 = *ptr;
26872     if (SWIG_IsNewObj(res)) delete ptr;
26873   }
26874   {
26875     std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
26876     int res = swig::asptr(obj2, &ptr);
26877     if (!SWIG_IsOK(res) || !ptr) {
26878       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_disconnectEdges" "', argument " "3"" of type '" "Hex::Edges""'");
26879     }
26880     arg3 = *ptr;
26881     if (SWIG_IsNewObj(res)) delete ptr;
26882   }
26883   result = (Hex::Elements *)(arg1)->disconnectEdges(arg2,arg3);
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_replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26892   PyObject *resultobj = 0;
26893   Hex::Document *arg1 = (Hex::Document *) 0 ;
26894   Hex::Quads arg2 ;
26895   Hex::Quads arg3 ;
26896   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
26897   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
26898   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
26899   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
26900   void *argp1 = 0 ;
26901   int res1 = 0 ;
26902   void *argp4 = 0 ;
26903   int res4 = 0 ;
26904   void *argp5 = 0 ;
26905   int res5 = 0 ;
26906   void *argp6 = 0 ;
26907   int res6 = 0 ;
26908   void *argp7 = 0 ;
26909   int res7 = 0 ;
26910   PyObject * obj0 = 0 ;
26911   PyObject * obj1 = 0 ;
26912   PyObject * obj2 = 0 ;
26913   PyObject * obj3 = 0 ;
26914   PyObject * obj4 = 0 ;
26915   PyObject * obj5 = 0 ;
26916   PyObject * obj6 = 0 ;
26917   Hex::Elements *result = 0 ;
26918
26919   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_replace",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
26920   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26921   if (!SWIG_IsOK(res1)) {
26922     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_replace" "', argument " "1"" of type '" "Hex::Document *""'");
26923   }
26924   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26925   {
26926     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
26927     int res = swig::asptr(obj1, &ptr);
26928     if (!SWIG_IsOK(res) || !ptr) {
26929       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "2"" of type '" "Hex::Quads""'");
26930     }
26931     arg2 = *ptr;
26932     if (SWIG_IsNewObj(res)) delete ptr;
26933   }
26934   {
26935     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
26936     int res = swig::asptr(obj2, &ptr);
26937     if (!SWIG_IsOK(res) || !ptr) {
26938       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_replace" "', argument " "3"" of type '" "Hex::Quads""'");
26939     }
26940     arg3 = *ptr;
26941     if (SWIG_IsNewObj(res)) delete ptr;
26942   }
26943   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26944   if (!SWIG_IsOK(res4)) {
26945     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_replace" "', argument " "4"" of type '" "Hex::Vertex *""'");
26946   }
26947   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
26948   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26949   if (!SWIG_IsOK(res5)) {
26950     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_replace" "', argument " "5"" of type '" "Hex::Vertex *""'");
26951   }
26952   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
26953   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26954   if (!SWIG_IsOK(res6)) {
26955     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_replace" "', argument " "6"" of type '" "Hex::Vertex *""'");
26956   }
26957   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
26958   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26959   if (!SWIG_IsOK(res7)) {
26960     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_replace" "', argument " "7"" of type '" "Hex::Vertex *""'");
26961   }
26962   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
26963   result = (Hex::Elements *)(arg1)->replace(arg2,arg3,arg4,arg5,arg6,arg7);
26964   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
26965   return resultobj;
26966 fail:
26967   return NULL;
26968 }
26969
26970
26971 SWIGINTERN PyObject *_wrap_Document_mergeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26972   PyObject *resultobj = 0;
26973   Hex::Document *arg1 = (Hex::Document *) 0 ;
26974   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
26975   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
26976   void *argp1 = 0 ;
26977   int res1 = 0 ;
26978   void *argp2 = 0 ;
26979   int res2 = 0 ;
26980   void *argp3 = 0 ;
26981   int res3 = 0 ;
26982   PyObject * obj0 = 0 ;
26983   PyObject * obj1 = 0 ;
26984   PyObject * obj2 = 0 ;
26985   int result;
26986
26987   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_mergeVertices",&obj0,&obj1,&obj2)) SWIG_fail;
26988   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
26989   if (!SWIG_IsOK(res1)) {
26990     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeVertices" "', argument " "1"" of type '" "Hex::Document *""'");
26991   }
26992   arg1 = reinterpret_cast< Hex::Document * >(argp1);
26993   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26994   if (!SWIG_IsOK(res2)) {
26995     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeVertices" "', argument " "2"" of type '" "Hex::Vertex *""'");
26996   }
26997   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
26998   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
26999   if (!SWIG_IsOK(res3)) {
27000     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeVertices" "', argument " "3"" of type '" "Hex::Vertex *""'");
27001   }
27002   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
27003   result = (int)(arg1)->mergeVertices(arg2,arg3);
27004   resultobj = SWIG_From_int(static_cast< int >(result));
27005   return resultobj;
27006 fail:
27007   return NULL;
27008 }
27009
27010
27011 SWIGINTERN PyObject *_wrap_Document_mergeEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27012   PyObject *resultobj = 0;
27013   Hex::Document *arg1 = (Hex::Document *) 0 ;
27014   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
27015   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
27016   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27017   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27018   void *argp1 = 0 ;
27019   int res1 = 0 ;
27020   void *argp2 = 0 ;
27021   int res2 = 0 ;
27022   void *argp3 = 0 ;
27023   int res3 = 0 ;
27024   void *argp4 = 0 ;
27025   int res4 = 0 ;
27026   void *argp5 = 0 ;
27027   int res5 = 0 ;
27028   PyObject * obj0 = 0 ;
27029   PyObject * obj1 = 0 ;
27030   PyObject * obj2 = 0 ;
27031   PyObject * obj3 = 0 ;
27032   PyObject * obj4 = 0 ;
27033   int result;
27034
27035   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_mergeEdges",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
27036   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27037   if (!SWIG_IsOK(res1)) {
27038     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeEdges" "', argument " "1"" of type '" "Hex::Document *""'");
27039   }
27040   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27041   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
27042   if (!SWIG_IsOK(res2)) {
27043     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeEdges" "', argument " "2"" of type '" "Hex::Edge *""'");
27044   }
27045   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
27046   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
27047   if (!SWIG_IsOK(res3)) {
27048     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeEdges" "', argument " "3"" of type '" "Hex::Edge *""'");
27049   }
27050   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
27051   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27052   if (!SWIG_IsOK(res4)) {
27053     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_mergeEdges" "', argument " "4"" of type '" "Hex::Vertex *""'");
27054   }
27055   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27056   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27057   if (!SWIG_IsOK(res5)) {
27058     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_mergeEdges" "', argument " "5"" of type '" "Hex::Vertex *""'");
27059   }
27060   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27061   result = (int)(arg1)->mergeEdges(arg2,arg3,arg4,arg5);
27062   resultobj = SWIG_From_int(static_cast< int >(result));
27063   return resultobj;
27064 fail:
27065   return NULL;
27066 }
27067
27068
27069 SWIGINTERN PyObject *_wrap_Document_mergeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27070   PyObject *resultobj = 0;
27071   Hex::Document *arg1 = (Hex::Document *) 0 ;
27072   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
27073   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
27074   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
27075   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
27076   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
27077   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
27078   void *argp1 = 0 ;
27079   int res1 = 0 ;
27080   void *argp2 = 0 ;
27081   int res2 = 0 ;
27082   void *argp3 = 0 ;
27083   int res3 = 0 ;
27084   void *argp4 = 0 ;
27085   int res4 = 0 ;
27086   void *argp5 = 0 ;
27087   int res5 = 0 ;
27088   void *argp6 = 0 ;
27089   int res6 = 0 ;
27090   void *argp7 = 0 ;
27091   int res7 = 0 ;
27092   PyObject * obj0 = 0 ;
27093   PyObject * obj1 = 0 ;
27094   PyObject * obj2 = 0 ;
27095   PyObject * obj3 = 0 ;
27096   PyObject * obj4 = 0 ;
27097   PyObject * obj5 = 0 ;
27098   PyObject * obj6 = 0 ;
27099   int result;
27100
27101   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_mergeQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
27102   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27103   if (!SWIG_IsOK(res1)) {
27104     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_mergeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
27105   }
27106   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27107   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27108   if (!SWIG_IsOK(res2)) {
27109     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_mergeQuads" "', argument " "2"" of type '" "Hex::Quad *""'");
27110   }
27111   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
27112   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
27113   if (!SWIG_IsOK(res3)) {
27114     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_mergeQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
27115   }
27116   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
27117   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27118   if (!SWIG_IsOK(res4)) {
27119     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_mergeQuads" "', argument " "4"" of type '" "Hex::Vertex *""'");
27120   }
27121   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
27122   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27123   if (!SWIG_IsOK(res5)) {
27124     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_mergeQuads" "', argument " "5"" of type '" "Hex::Vertex *""'");
27125   }
27126   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
27127   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27128   if (!SWIG_IsOK(res6)) {
27129     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_mergeQuads" "', argument " "6"" of type '" "Hex::Vertex *""'");
27130   }
27131   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
27132   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27133   if (!SWIG_IsOK(res7)) {
27134     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_mergeQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
27135   }
27136   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
27137   result = (int)(arg1)->mergeQuads(arg2,arg3,arg4,arg5,arg6,arg7);
27138   resultobj = SWIG_From_int(static_cast< int >(result));
27139   return resultobj;
27140 fail:
27141   return NULL;
27142 }
27143
27144
27145 SWIGINTERN PyObject *_wrap_Document_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27146   PyObject *resultobj = 0;
27147   Hex::Document *arg1 = (Hex::Document *) 0 ;
27148   void *argp1 = 0 ;
27149   int res1 = 0 ;
27150   PyObject * obj0 = 0 ;
27151
27152   if (!PyArg_ParseTuple(args,(char *)"O:Document_clearAssociation",&obj0)) SWIG_fail;
27153   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27154   if (!SWIG_IsOK(res1)) {
27155     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_clearAssociation" "', argument " "1"" of type '" "Hex::Document *""'");
27156   }
27157   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27158   (arg1)->clearAssociation();
27159   resultobj = SWIG_Py_Void();
27160   return resultobj;
27161 fail:
27162   return NULL;
27163 }
27164
27165
27166 SWIGINTERN PyObject *_wrap_Document_associateOpenedLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27167   PyObject *resultobj = 0;
27168   Hex::Document *arg1 = (Hex::Document *) 0 ;
27169   Hex::Edges arg2 ;
27170   Hex::NewShapes arg3 ;
27171   Hex::IntVector arg4 ;
27172   double arg5 ;
27173   double arg6 ;
27174   void *argp1 = 0 ;
27175   int res1 = 0 ;
27176   double val5 ;
27177   int ecode5 = 0 ;
27178   double val6 ;
27179   int ecode6 = 0 ;
27180   PyObject * obj0 = 0 ;
27181   PyObject * obj1 = 0 ;
27182   PyObject * obj2 = 0 ;
27183   PyObject * obj3 = 0 ;
27184   PyObject * obj4 = 0 ;
27185   PyObject * obj5 = 0 ;
27186   int result;
27187
27188   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_associateOpenedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
27189   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27190   if (!SWIG_IsOK(res1)) {
27191     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_associateOpenedLine" "', argument " "1"" of type '" "Hex::Document *""'");
27192   }
27193   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27194   {
27195     std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
27196     int res = swig::asptr(obj1, &ptr);
27197     if (!SWIG_IsOK(res) || !ptr) {
27198       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "2"" of type '" "Hex::Edges""'");
27199     }
27200     arg2 = *ptr;
27201     if (SWIG_IsNewObj(res)) delete ptr;
27202   }
27203   {
27204     std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
27205     int res = swig::asptr(obj2, &ptr);
27206     if (!SWIG_IsOK(res) || !ptr) {
27207       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "3"" of type '" "Hex::NewShapes""'");
27208     }
27209     arg3 = *ptr;
27210     if (SWIG_IsNewObj(res)) delete ptr;
27211   }
27212   {
27213     std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
27214     int res = swig::asptr(obj3, &ptr);
27215     if (!SWIG_IsOK(res) || !ptr) {
27216       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateOpenedLine" "', argument " "4"" of type '" "Hex::IntVector""'");
27217     }
27218     arg4 = *ptr;
27219     if (SWIG_IsNewObj(res)) delete ptr;
27220   }
27221   ecode5 = SWIG_AsVal_double(obj4, &val5);
27222   if (!SWIG_IsOK(ecode5)) {
27223     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_associateOpenedLine" "', argument " "5"" of type '" "double""'");
27224   }
27225   arg5 = static_cast< double >(val5);
27226   ecode6 = SWIG_AsVal_double(obj5, &val6);
27227   if (!SWIG_IsOK(ecode6)) {
27228     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_associateOpenedLine" "', argument " "6"" of type '" "double""'");
27229   }
27230   arg6 = static_cast< double >(val6);
27231   result = (int)(arg1)->associateOpenedLine(arg2,arg3,arg4,arg5,arg6);
27232   resultobj = SWIG_From_int(static_cast< int >(result));
27233   return resultobj;
27234 fail:
27235   return NULL;
27236 }
27237
27238
27239 SWIGINTERN PyObject *_wrap_Document_associateClosedLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27240   PyObject *resultobj = 0;
27241   Hex::Document *arg1 = (Hex::Document *) 0 ;
27242   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
27243   Hex::Edges arg3 ;
27244   Hex::NewShapes arg4 ;
27245   Hex::IntVector arg5 ;
27246   double arg6 ;
27247   bool arg7 ;
27248   void *argp1 = 0 ;
27249   int res1 = 0 ;
27250   void *argp2 = 0 ;
27251   int res2 = 0 ;
27252   double val6 ;
27253   int ecode6 = 0 ;
27254   bool val7 ;
27255   int ecode7 = 0 ;
27256   PyObject * obj0 = 0 ;
27257   PyObject * obj1 = 0 ;
27258   PyObject * obj2 = 0 ;
27259   PyObject * obj3 = 0 ;
27260   PyObject * obj4 = 0 ;
27261   PyObject * obj5 = 0 ;
27262   PyObject * obj6 = 0 ;
27263   int result;
27264
27265   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_associateClosedLine",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
27266   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27267   if (!SWIG_IsOK(res1)) {
27268     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_associateClosedLine" "', argument " "1"" of type '" "Hex::Document *""'");
27269   }
27270   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27271   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27272   if (!SWIG_IsOK(res2)) {
27273     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_associateClosedLine" "', argument " "2"" of type '" "Hex::Vertex *""'");
27274   }
27275   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
27276   {
27277     std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *ptr = (std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > *)0;
27278     int res = swig::asptr(obj2, &ptr);
27279     if (!SWIG_IsOK(res) || !ptr) {
27280       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "3"" of type '" "Hex::Edges""'");
27281     }
27282     arg3 = *ptr;
27283     if (SWIG_IsNewObj(res)) delete ptr;
27284   }
27285   {
27286     std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *ptr = (std::vector< Hex::NewShape*,std::allocator< Hex::NewShape * > > *)0;
27287     int res = swig::asptr(obj3, &ptr);
27288     if (!SWIG_IsOK(res) || !ptr) {
27289       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "4"" of type '" "Hex::NewShapes""'");
27290     }
27291     arg4 = *ptr;
27292     if (SWIG_IsNewObj(res)) delete ptr;
27293   }
27294   {
27295     std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
27296     int res = swig::asptr(obj4, &ptr);
27297     if (!SWIG_IsOK(res) || !ptr) {
27298       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_associateClosedLine" "', argument " "5"" of type '" "Hex::IntVector""'");
27299     }
27300     arg5 = *ptr;
27301     if (SWIG_IsNewObj(res)) delete ptr;
27302   }
27303   ecode6 = SWIG_AsVal_double(obj5, &val6);
27304   if (!SWIG_IsOK(ecode6)) {
27305     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_associateClosedLine" "', argument " "6"" of type '" "double""'");
27306   }
27307   arg6 = static_cast< double >(val6);
27308   ecode7 = SWIG_AsVal_bool(obj6, &val7);
27309   if (!SWIG_IsOK(ecode7)) {
27310     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_associateClosedLine" "', argument " "7"" of type '" "bool""'");
27311   }
27312   arg7 = static_cast< bool >(val7);
27313   result = (int)(arg1)->associateClosedLine(arg2,arg3,arg4,arg5,arg6,arg7);
27314   resultobj = SWIG_From_int(static_cast< int >(result));
27315   return resultobj;
27316 fail:
27317   return NULL;
27318 }
27319
27320
27321 SWIGINTERN PyObject *_wrap_Document_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27322   PyObject *resultobj = 0;
27323   Hex::Document *arg1 = (Hex::Document *) 0 ;
27324   void *argp1 = 0 ;
27325   int res1 = 0 ;
27326   PyObject * obj0 = 0 ;
27327   int result;
27328
27329   if (!PyArg_ParseTuple(args,(char *)"O:Document_countHexa",&obj0)) SWIG_fail;
27330   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27331   if (!SWIG_IsOK(res1)) {
27332     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countHexa" "', argument " "1"" of type '" "Hex::Document *""'");
27333   }
27334   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27335   result = (int)(arg1)->countHexa();
27336   resultobj = SWIG_From_int(static_cast< int >(result));
27337   return resultobj;
27338 fail:
27339   return NULL;
27340 }
27341
27342
27343 SWIGINTERN PyObject *_wrap_Document_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27344   PyObject *resultobj = 0;
27345   Hex::Document *arg1 = (Hex::Document *) 0 ;
27346   void *argp1 = 0 ;
27347   int res1 = 0 ;
27348   PyObject * obj0 = 0 ;
27349   int result;
27350
27351   if (!PyArg_ParseTuple(args,(char *)"O:Document_countQuad",&obj0)) SWIG_fail;
27352   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27353   if (!SWIG_IsOK(res1)) {
27354     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27355   }
27356   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27357   result = (int)(arg1)->countQuad();
27358   resultobj = SWIG_From_int(static_cast< int >(result));
27359   return resultobj;
27360 fail:
27361   return NULL;
27362 }
27363
27364
27365 SWIGINTERN PyObject *_wrap_Document_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27366   PyObject *resultobj = 0;
27367   Hex::Document *arg1 = (Hex::Document *) 0 ;
27368   void *argp1 = 0 ;
27369   int res1 = 0 ;
27370   PyObject * obj0 = 0 ;
27371   int result;
27372
27373   if (!PyArg_ParseTuple(args,(char *)"O:Document_countEdge",&obj0)) SWIG_fail;
27374   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27375   if (!SWIG_IsOK(res1)) {
27376     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countEdge" "', argument " "1"" of type '" "Hex::Document *""'");
27377   }
27378   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27379   result = (int)(arg1)->countEdge();
27380   resultobj = SWIG_From_int(static_cast< int >(result));
27381   return resultobj;
27382 fail:
27383   return NULL;
27384 }
27385
27386
27387 SWIGINTERN PyObject *_wrap_Document_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27388   PyObject *resultobj = 0;
27389   Hex::Document *arg1 = (Hex::Document *) 0 ;
27390   void *argp1 = 0 ;
27391   int res1 = 0 ;
27392   PyObject * obj0 = 0 ;
27393   int result;
27394
27395   if (!PyArg_ParseTuple(args,(char *)"O:Document_countVertex",&obj0)) SWIG_fail;
27396   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27397   if (!SWIG_IsOK(res1)) {
27398     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countVertex" "', argument " "1"" of type '" "Hex::Document *""'");
27399   }
27400   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27401   result = (int)(arg1)->countVertex();
27402   resultobj = SWIG_From_int(static_cast< int >(result));
27403   return resultobj;
27404 fail:
27405   return NULL;
27406 }
27407
27408
27409 SWIGINTERN PyObject *_wrap_Document_countVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27410   PyObject *resultobj = 0;
27411   Hex::Document *arg1 = (Hex::Document *) 0 ;
27412   void *argp1 = 0 ;
27413   int res1 = 0 ;
27414   PyObject * obj0 = 0 ;
27415   int result;
27416
27417   if (!PyArg_ParseTuple(args,(char *)"O:Document_countVector",&obj0)) SWIG_fail;
27418   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27419   if (!SWIG_IsOK(res1)) {
27420     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countVector" "', argument " "1"" of type '" "Hex::Document *""'");
27421   }
27422   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27423   result = (int)(arg1)->countVector();
27424   resultobj = SWIG_From_int(static_cast< int >(result));
27425   return resultobj;
27426 fail:
27427   return NULL;
27428 }
27429
27430
27431 SWIGINTERN PyObject *_wrap_Document_countGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27432   PyObject *resultobj = 0;
27433   Hex::Document *arg1 = (Hex::Document *) 0 ;
27434   void *argp1 = 0 ;
27435   int res1 = 0 ;
27436   PyObject * obj0 = 0 ;
27437   int result;
27438
27439   if (!PyArg_ParseTuple(args,(char *)"O:Document_countGroup",&obj0)) SWIG_fail;
27440   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27441   if (!SWIG_IsOK(res1)) {
27442     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countGroup" "', argument " "1"" of type '" "Hex::Document *""'");
27443   }
27444   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27445   result = (int)(arg1)->countGroup();
27446   resultobj = SWIG_From_int(static_cast< int >(result));
27447   return resultobj;
27448 fail:
27449   return NULL;
27450 }
27451
27452
27453 SWIGINTERN PyObject *_wrap_Document_countLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27454   PyObject *resultobj = 0;
27455   Hex::Document *arg1 = (Hex::Document *) 0 ;
27456   void *argp1 = 0 ;
27457   int res1 = 0 ;
27458   PyObject * obj0 = 0 ;
27459   int result;
27460
27461   if (!PyArg_ParseTuple(args,(char *)"O:Document_countLaw",&obj0)) SWIG_fail;
27462   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27463   if (!SWIG_IsOK(res1)) {
27464     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countLaw" "', argument " "1"" of type '" "Hex::Document *""'");
27465   }
27466   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27467   result = (int)(arg1)->countLaw();
27468   resultobj = SWIG_From_int(static_cast< int >(result));
27469   return resultobj;
27470 fail:
27471   return NULL;
27472 }
27473
27474
27475 SWIGINTERN PyObject *_wrap_Document_countPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27476   PyObject *resultobj = 0;
27477   Hex::Document *arg1 = (Hex::Document *) 0 ;
27478   void *argp1 = 0 ;
27479   int res1 = 0 ;
27480   PyObject * obj0 = 0 ;
27481   int result;
27482
27483   if (!PyArg_ParseTuple(args,(char *)"O:Document_countPropagation",&obj0)) SWIG_fail;
27484   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27485   if (!SWIG_IsOK(res1)) {
27486     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
27487   }
27488   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27489   result = (int)(arg1)->countPropagation();
27490   resultobj = SWIG_From_int(static_cast< int >(result));
27491   return resultobj;
27492 fail:
27493   return NULL;
27494 }
27495
27496
27497 SWIGINTERN PyObject *_wrap_Document_countShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27498   PyObject *resultobj = 0;
27499   Hex::Document *arg1 = (Hex::Document *) 0 ;
27500   void *argp1 = 0 ;
27501   int res1 = 0 ;
27502   PyObject * obj0 = 0 ;
27503   int result;
27504
27505   if (!PyArg_ParseTuple(args,(char *)"O:Document_countShape",&obj0)) SWIG_fail;
27506   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27507   if (!SWIG_IsOK(res1)) {
27508     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countShape" "', argument " "1"" of type '" "Hex::Document *""'");
27509   }
27510   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27511   result = (int)(arg1)->countShape();
27512   resultobj = SWIG_From_int(static_cast< int >(result));
27513   return resultobj;
27514 fail:
27515   return NULL;
27516 }
27517
27518
27519 SWIGINTERN PyObject *_wrap_Document_countUsedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27520   PyObject *resultobj = 0;
27521   Hex::Document *arg1 = (Hex::Document *) 0 ;
27522   void *argp1 = 0 ;
27523   int res1 = 0 ;
27524   PyObject * obj0 = 0 ;
27525   int result;
27526
27527   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedHexa",&obj0)) SWIG_fail;
27528   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27529   if (!SWIG_IsOK(res1)) {
27530     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
27531   }
27532   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27533   result = (int)(arg1)->countUsedHexa();
27534   resultobj = SWIG_From_int(static_cast< int >(result));
27535   return resultobj;
27536 fail:
27537   return NULL;
27538 }
27539
27540
27541 SWIGINTERN PyObject *_wrap_Document_countUsedQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27542   PyObject *resultobj = 0;
27543   Hex::Document *arg1 = (Hex::Document *) 0 ;
27544   void *argp1 = 0 ;
27545   int res1 = 0 ;
27546   PyObject * obj0 = 0 ;
27547   int result;
27548
27549   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedQuad",&obj0)) SWIG_fail;
27550   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27551   if (!SWIG_IsOK(res1)) {
27552     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27553   }
27554   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27555   result = (int)(arg1)->countUsedQuad();
27556   resultobj = SWIG_From_int(static_cast< int >(result));
27557   return resultobj;
27558 fail:
27559   return NULL;
27560 }
27561
27562
27563 SWIGINTERN PyObject *_wrap_Document_countUsedEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27564   PyObject *resultobj = 0;
27565   Hex::Document *arg1 = (Hex::Document *) 0 ;
27566   void *argp1 = 0 ;
27567   int res1 = 0 ;
27568   PyObject * obj0 = 0 ;
27569   int result;
27570
27571   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedEdge",&obj0)) SWIG_fail;
27572   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27573   if (!SWIG_IsOK(res1)) {
27574     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedEdge" "', argument " "1"" of type '" "Hex::Document *""'");
27575   }
27576   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27577   result = (int)(arg1)->countUsedEdge();
27578   resultobj = SWIG_From_int(static_cast< int >(result));
27579   return resultobj;
27580 fail:
27581   return NULL;
27582 }
27583
27584
27585 SWIGINTERN PyObject *_wrap_Document_countUsedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27586   PyObject *resultobj = 0;
27587   Hex::Document *arg1 = (Hex::Document *) 0 ;
27588   void *argp1 = 0 ;
27589   int res1 = 0 ;
27590   PyObject * obj0 = 0 ;
27591   int result;
27592
27593   if (!PyArg_ParseTuple(args,(char *)"O:Document_countUsedVertex",&obj0)) SWIG_fail;
27594   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27595   if (!SWIG_IsOK(res1)) {
27596     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_countUsedVertex" "', argument " "1"" of type '" "Hex::Document *""'");
27597   }
27598   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27599   result = (int)(arg1)->countUsedVertex();
27600   resultobj = SWIG_From_int(static_cast< int >(result));
27601   return resultobj;
27602 fail:
27603   return NULL;
27604 }
27605
27606
27607 SWIGINTERN PyObject *_wrap_Document_getHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27608   PyObject *resultobj = 0;
27609   Hex::Document *arg1 = (Hex::Document *) 0 ;
27610   int arg2 ;
27611   void *argp1 = 0 ;
27612   int res1 = 0 ;
27613   int val2 ;
27614   int ecode2 = 0 ;
27615   PyObject * obj0 = 0 ;
27616   PyObject * obj1 = 0 ;
27617   Hex::Hexa *result = 0 ;
27618
27619   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getHexa",&obj0,&obj1)) SWIG_fail;
27620   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27621   if (!SWIG_IsOK(res1)) {
27622     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getHexa" "', argument " "1"" of type '" "Hex::Document *""'");
27623   }
27624   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27625   ecode2 = SWIG_AsVal_int(obj1, &val2);
27626   if (!SWIG_IsOK(ecode2)) {
27627     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getHexa" "', argument " "2"" of type '" "int""'");
27628   }
27629   arg2 = static_cast< int >(val2);
27630   result = (Hex::Hexa *)(arg1)->getHexa(arg2);
27631   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
27632   return resultobj;
27633 fail:
27634   return NULL;
27635 }
27636
27637
27638 SWIGINTERN PyObject *_wrap_Document_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27639   PyObject *resultobj = 0;
27640   Hex::Document *arg1 = (Hex::Document *) 0 ;
27641   int arg2 ;
27642   void *argp1 = 0 ;
27643   int res1 = 0 ;
27644   int val2 ;
27645   int ecode2 = 0 ;
27646   PyObject * obj0 = 0 ;
27647   PyObject * obj1 = 0 ;
27648   Hex::Quad *result = 0 ;
27649
27650   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getQuad",&obj0,&obj1)) SWIG_fail;
27651   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27652   if (!SWIG_IsOK(res1)) {
27653     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27654   }
27655   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27656   ecode2 = SWIG_AsVal_int(obj1, &val2);
27657   if (!SWIG_IsOK(ecode2)) {
27658     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getQuad" "', argument " "2"" of type '" "int""'");
27659   }
27660   arg2 = static_cast< int >(val2);
27661   result = (Hex::Quad *)(arg1)->getQuad(arg2);
27662   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
27663   return resultobj;
27664 fail:
27665   return NULL;
27666 }
27667
27668
27669 SWIGINTERN PyObject *_wrap_Document_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27670   PyObject *resultobj = 0;
27671   Hex::Document *arg1 = (Hex::Document *) 0 ;
27672   int arg2 ;
27673   void *argp1 = 0 ;
27674   int res1 = 0 ;
27675   int val2 ;
27676   int ecode2 = 0 ;
27677   PyObject * obj0 = 0 ;
27678   PyObject * obj1 = 0 ;
27679   Hex::Edge *result = 0 ;
27680
27681   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getEdge",&obj0,&obj1)) SWIG_fail;
27682   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27683   if (!SWIG_IsOK(res1)) {
27684     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getEdge" "', argument " "1"" of type '" "Hex::Document *""'");
27685   }
27686   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27687   ecode2 = SWIG_AsVal_int(obj1, &val2);
27688   if (!SWIG_IsOK(ecode2)) {
27689     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getEdge" "', argument " "2"" of type '" "int""'");
27690   }
27691   arg2 = static_cast< int >(val2);
27692   result = (Hex::Edge *)(arg1)->getEdge(arg2);
27693   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
27694   return resultobj;
27695 fail:
27696   return NULL;
27697 }
27698
27699
27700 SWIGINTERN PyObject *_wrap_Document_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27701   PyObject *resultobj = 0;
27702   Hex::Document *arg1 = (Hex::Document *) 0 ;
27703   int arg2 ;
27704   void *argp1 = 0 ;
27705   int res1 = 0 ;
27706   int val2 ;
27707   int ecode2 = 0 ;
27708   PyObject * obj0 = 0 ;
27709   PyObject * obj1 = 0 ;
27710   Hex::Vertex *result = 0 ;
27711
27712   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVertex",&obj0,&obj1)) SWIG_fail;
27713   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27714   if (!SWIG_IsOK(res1)) {
27715     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getVertex" "', argument " "1"" of type '" "Hex::Document *""'");
27716   }
27717   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27718   ecode2 = SWIG_AsVal_int(obj1, &val2);
27719   if (!SWIG_IsOK(ecode2)) {
27720     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getVertex" "', argument " "2"" of type '" "int""'");
27721   }
27722   arg2 = static_cast< int >(val2);
27723   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
27724   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27725   return resultobj;
27726 fail:
27727   return NULL;
27728 }
27729
27730
27731 SWIGINTERN PyObject *_wrap_Document_getUsedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27732   PyObject *resultobj = 0;
27733   Hex::Document *arg1 = (Hex::Document *) 0 ;
27734   int arg2 ;
27735   void *argp1 = 0 ;
27736   int res1 = 0 ;
27737   int val2 ;
27738   int ecode2 = 0 ;
27739   PyObject * obj0 = 0 ;
27740   PyObject * obj1 = 0 ;
27741   Hex::Hexa *result = 0 ;
27742
27743   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedHexa",&obj0,&obj1)) SWIG_fail;
27744   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27745   if (!SWIG_IsOK(res1)) {
27746     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
27747   }
27748   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27749   ecode2 = SWIG_AsVal_int(obj1, &val2);
27750   if (!SWIG_IsOK(ecode2)) {
27751     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedHexa" "', argument " "2"" of type '" "int""'");
27752   }
27753   arg2 = static_cast< int >(val2);
27754   result = (Hex::Hexa *)(arg1)->getUsedHexa(arg2);
27755   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
27756   return resultobj;
27757 fail:
27758   return NULL;
27759 }
27760
27761
27762 SWIGINTERN PyObject *_wrap_Document_getUsedQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27763   PyObject *resultobj = 0;
27764   Hex::Document *arg1 = (Hex::Document *) 0 ;
27765   int arg2 ;
27766   void *argp1 = 0 ;
27767   int res1 = 0 ;
27768   int val2 ;
27769   int ecode2 = 0 ;
27770   PyObject * obj0 = 0 ;
27771   PyObject * obj1 = 0 ;
27772   Hex::Quad *result = 0 ;
27773
27774   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedQuad",&obj0,&obj1)) SWIG_fail;
27775   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27776   if (!SWIG_IsOK(res1)) {
27777     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedQuad" "', argument " "1"" of type '" "Hex::Document *""'");
27778   }
27779   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27780   ecode2 = SWIG_AsVal_int(obj1, &val2);
27781   if (!SWIG_IsOK(ecode2)) {
27782     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedQuad" "', argument " "2"" of type '" "int""'");
27783   }
27784   arg2 = static_cast< int >(val2);
27785   result = (Hex::Quad *)(arg1)->getUsedQuad(arg2);
27786   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
27787   return resultobj;
27788 fail:
27789   return NULL;
27790 }
27791
27792
27793 SWIGINTERN PyObject *_wrap_Document_getUsedEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27794   PyObject *resultobj = 0;
27795   Hex::Document *arg1 = (Hex::Document *) 0 ;
27796   int arg2 ;
27797   void *argp1 = 0 ;
27798   int res1 = 0 ;
27799   int val2 ;
27800   int ecode2 = 0 ;
27801   PyObject * obj0 = 0 ;
27802   PyObject * obj1 = 0 ;
27803   Hex::Edge *result = 0 ;
27804
27805   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedEdge",&obj0,&obj1)) SWIG_fail;
27806   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27807   if (!SWIG_IsOK(res1)) {
27808     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedEdge" "', argument " "1"" of type '" "Hex::Document *""'");
27809   }
27810   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27811   ecode2 = SWIG_AsVal_int(obj1, &val2);
27812   if (!SWIG_IsOK(ecode2)) {
27813     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedEdge" "', argument " "2"" of type '" "int""'");
27814   }
27815   arg2 = static_cast< int >(val2);
27816   result = (Hex::Edge *)(arg1)->getUsedEdge(arg2);
27817   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
27818   return resultobj;
27819 fail:
27820   return NULL;
27821 }
27822
27823
27824 SWIGINTERN PyObject *_wrap_Document_getUsedVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27825   PyObject *resultobj = 0;
27826   Hex::Document *arg1 = (Hex::Document *) 0 ;
27827   int arg2 ;
27828   void *argp1 = 0 ;
27829   int res1 = 0 ;
27830   int val2 ;
27831   int ecode2 = 0 ;
27832   PyObject * obj0 = 0 ;
27833   PyObject * obj1 = 0 ;
27834   Hex::Vertex *result = 0 ;
27835
27836   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getUsedVertex",&obj0,&obj1)) SWIG_fail;
27837   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27838   if (!SWIG_IsOK(res1)) {
27839     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getUsedVertex" "', argument " "1"" of type '" "Hex::Document *""'");
27840   }
27841   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27842   ecode2 = SWIG_AsVal_int(obj1, &val2);
27843   if (!SWIG_IsOK(ecode2)) {
27844     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getUsedVertex" "', argument " "2"" of type '" "int""'");
27845   }
27846   arg2 = static_cast< int >(val2);
27847   result = (Hex::Vertex *)(arg1)->getUsedVertex(arg2);
27848   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
27849   return resultobj;
27850 fail:
27851   return NULL;
27852 }
27853
27854
27855 SWIGINTERN PyObject *_wrap_Document_getVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27856   PyObject *resultobj = 0;
27857   Hex::Document *arg1 = (Hex::Document *) 0 ;
27858   int arg2 ;
27859   void *argp1 = 0 ;
27860   int res1 = 0 ;
27861   int val2 ;
27862   int ecode2 = 0 ;
27863   PyObject * obj0 = 0 ;
27864   PyObject * obj1 = 0 ;
27865   Hex::Vector *result = 0 ;
27866
27867   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getVector",&obj0,&obj1)) SWIG_fail;
27868   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27869   if (!SWIG_IsOK(res1)) {
27870     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getVector" "', argument " "1"" of type '" "Hex::Document *""'");
27871   }
27872   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27873   ecode2 = SWIG_AsVal_int(obj1, &val2);
27874   if (!SWIG_IsOK(ecode2)) {
27875     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getVector" "', argument " "2"" of type '" "int""'");
27876   }
27877   arg2 = static_cast< int >(val2);
27878   result = (Hex::Vector *)(arg1)->getVector(arg2);
27879   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vector, 0 |  0 );
27880   return resultobj;
27881 fail:
27882   return NULL;
27883 }
27884
27885
27886 SWIGINTERN PyObject *_wrap_Document_getShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27887   PyObject *resultobj = 0;
27888   Hex::Document *arg1 = (Hex::Document *) 0 ;
27889   int arg2 ;
27890   void *argp1 = 0 ;
27891   int res1 = 0 ;
27892   int val2 ;
27893   int ecode2 = 0 ;
27894   PyObject * obj0 = 0 ;
27895   PyObject * obj1 = 0 ;
27896   Hex::NewShape *result = 0 ;
27897
27898   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getShape",&obj0,&obj1)) SWIG_fail;
27899   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27900   if (!SWIG_IsOK(res1)) {
27901     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getShape" "', argument " "1"" of type '" "Hex::Document *""'");
27902   }
27903   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27904   ecode2 = SWIG_AsVal_int(obj1, &val2);
27905   if (!SWIG_IsOK(ecode2)) {
27906     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getShape" "', argument " "2"" of type '" "int""'");
27907   }
27908   arg2 = static_cast< int >(val2);
27909   result = (Hex::NewShape *)(arg1)->getShape(arg2);
27910   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 |  0 );
27911   return resultobj;
27912 fail:
27913   return NULL;
27914 }
27915
27916
27917 SWIGINTERN PyObject *_wrap_Document_getGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27918   PyObject *resultobj = 0;
27919   Hex::Document *arg1 = (Hex::Document *) 0 ;
27920   int arg2 ;
27921   void *argp1 = 0 ;
27922   int res1 = 0 ;
27923   int val2 ;
27924   int ecode2 = 0 ;
27925   PyObject * obj0 = 0 ;
27926   PyObject * obj1 = 0 ;
27927   Hex::Group *result = 0 ;
27928
27929   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getGroup",&obj0,&obj1)) SWIG_fail;
27930   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27931   if (!SWIG_IsOK(res1)) {
27932     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getGroup" "', argument " "1"" of type '" "Hex::Document *""'");
27933   }
27934   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27935   ecode2 = SWIG_AsVal_int(obj1, &val2);
27936   if (!SWIG_IsOK(ecode2)) {
27937     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getGroup" "', argument " "2"" of type '" "int""'");
27938   }
27939   arg2 = static_cast< int >(val2);
27940   result = (Hex::Group *)(arg1)->getGroup(arg2);
27941   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
27942   return resultobj;
27943 fail:
27944   return NULL;
27945 }
27946
27947
27948 SWIGINTERN PyObject *_wrap_Document_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27949   PyObject *resultobj = 0;
27950   Hex::Document *arg1 = (Hex::Document *) 0 ;
27951   int arg2 ;
27952   void *argp1 = 0 ;
27953   int res1 = 0 ;
27954   int val2 ;
27955   int ecode2 = 0 ;
27956   PyObject * obj0 = 0 ;
27957   PyObject * obj1 = 0 ;
27958   Hex::Law *result = 0 ;
27959
27960   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getLaw",&obj0,&obj1)) SWIG_fail;
27961   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27962   if (!SWIG_IsOK(res1)) {
27963     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getLaw" "', argument " "1"" of type '" "Hex::Document *""'");
27964   }
27965   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27966   ecode2 = SWIG_AsVal_int(obj1, &val2);
27967   if (!SWIG_IsOK(ecode2)) {
27968     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getLaw" "', argument " "2"" of type '" "int""'");
27969   }
27970   arg2 = static_cast< int >(val2);
27971   result = (Hex::Law *)(arg1)->getLaw(arg2);
27972   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
27973   return resultobj;
27974 fail:
27975   return NULL;
27976 }
27977
27978
27979 SWIGINTERN PyObject *_wrap_Document_getPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27980   PyObject *resultobj = 0;
27981   Hex::Document *arg1 = (Hex::Document *) 0 ;
27982   int arg2 ;
27983   void *argp1 = 0 ;
27984   int res1 = 0 ;
27985   int val2 ;
27986   int ecode2 = 0 ;
27987   PyObject * obj0 = 0 ;
27988   PyObject * obj1 = 0 ;
27989   Hex::Propagation *result = 0 ;
27990
27991   if (!PyArg_ParseTuple(args,(char *)"OO:Document_getPropagation",&obj0,&obj1)) SWIG_fail;
27992   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
27993   if (!SWIG_IsOK(res1)) {
27994     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
27995   }
27996   arg1 = reinterpret_cast< Hex::Document * >(argp1);
27997   ecode2 = SWIG_AsVal_int(obj1, &val2);
27998   if (!SWIG_IsOK(ecode2)) {
27999     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_getPropagation" "', argument " "2"" of type '" "int""'");
28000   }
28001   arg2 = static_cast< int >(val2);
28002   result = (Hex::Propagation *)(arg1)->getPropagation(arg2);
28003   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28004   return resultobj;
28005 fail:
28006   return NULL;
28007 }
28008
28009
28010 SWIGINTERN PyObject *_wrap_Document_getFirstExplicitShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28011   PyObject *resultobj = 0;
28012   Hex::Document *arg1 = (Hex::Document *) 0 ;
28013   void *argp1 = 0 ;
28014   int res1 = 0 ;
28015   PyObject * obj0 = 0 ;
28016   cpchar result;
28017
28018   if (!PyArg_ParseTuple(args,(char *)"O:Document_getFirstExplicitShape",&obj0)) SWIG_fail;
28019   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28020   if (!SWIG_IsOK(res1)) {
28021     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getFirstExplicitShape" "', argument " "1"" of type '" "Hex::Document *""'");
28022   }
28023   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28024   result = (cpchar)(arg1)->getFirstExplicitShape();
28025   resultobj = SWIG_FromCharPtr((const char *)result);
28026   return resultobj;
28027 fail:
28028   return NULL;
28029 }
28030
28031
28032 SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28033   PyObject *resultobj = 0;
28034   Hex::Document *arg1 = (Hex::Document *) 0 ;
28035   double arg2 ;
28036   double arg3 ;
28037   double arg4 ;
28038   void *argp1 = 0 ;
28039   int res1 = 0 ;
28040   double val2 ;
28041   int ecode2 = 0 ;
28042   double val3 ;
28043   int ecode3 = 0 ;
28044   double val4 ;
28045   int ecode4 = 0 ;
28046   PyObject * obj0 = 0 ;
28047   PyObject * obj1 = 0 ;
28048   PyObject * obj2 = 0 ;
28049   PyObject * obj3 = 0 ;
28050   Hex::Vertex *result = 0 ;
28051
28052   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_findVertex",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28053   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28054   if (!SWIG_IsOK(res1)) {
28055     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
28056   }
28057   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28058   ecode2 = SWIG_AsVal_double(obj1, &val2);
28059   if (!SWIG_IsOK(ecode2)) {
28060     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "double""'");
28061   }
28062   arg2 = static_cast< double >(val2);
28063   ecode3 = SWIG_AsVal_double(obj2, &val3);
28064   if (!SWIG_IsOK(ecode3)) {
28065     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_findVertex" "', argument " "3"" of type '" "double""'");
28066   }
28067   arg3 = static_cast< double >(val3);
28068   ecode4 = SWIG_AsVal_double(obj3, &val4);
28069   if (!SWIG_IsOK(ecode4)) {
28070     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_findVertex" "', argument " "4"" of type '" "double""'");
28071   }
28072   arg4 = static_cast< double >(val4);
28073   result = (Hex::Vertex *)(arg1)->findVertex(arg2,arg3,arg4);
28074   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28075   return resultobj;
28076 fail:
28077   return NULL;
28078 }
28079
28080
28081 SWIGINTERN PyObject *_wrap_Document_findEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28082   PyObject *resultobj = 0;
28083   Hex::Document *arg1 = (Hex::Document *) 0 ;
28084   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28085   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
28086   void *argp1 = 0 ;
28087   int res1 = 0 ;
28088   void *argp2 = 0 ;
28089   int res2 = 0 ;
28090   void *argp3 = 0 ;
28091   int res3 = 0 ;
28092   PyObject * obj0 = 0 ;
28093   PyObject * obj1 = 0 ;
28094   PyObject * obj2 = 0 ;
28095   Hex::Edge *result = 0 ;
28096
28097   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findEdge",&obj0,&obj1,&obj2)) SWIG_fail;
28098   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28099   if (!SWIG_IsOK(res1)) {
28100     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findEdge" "', argument " "1"" of type '" "Hex::Document *""'");
28101   }
28102   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28103   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28104   if (!SWIG_IsOK(res2)) {
28105     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findEdge" "', argument " "2"" of type '" "Hex::Vertex *""'");
28106   }
28107   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28108   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28109   if (!SWIG_IsOK(res3)) {
28110     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findEdge" "', argument " "3"" of type '" "Hex::Vertex *""'");
28111   }
28112   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
28113   result = (Hex::Edge *)(arg1)->findEdge(arg2,arg3);
28114   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
28115   return resultobj;
28116 fail:
28117   return NULL;
28118 }
28119
28120
28121 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28122   PyObject *resultobj = 0;
28123   Hex::Document *arg1 = (Hex::Document *) 0 ;
28124   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28125   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
28126   void *argp1 = 0 ;
28127   int res1 = 0 ;
28128   void *argp2 = 0 ;
28129   int res2 = 0 ;
28130   void *argp3 = 0 ;
28131   int res3 = 0 ;
28132   PyObject * obj0 = 0 ;
28133   PyObject * obj1 = 0 ;
28134   PyObject * obj2 = 0 ;
28135   Hex::Quad *result = 0 ;
28136
28137   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
28138   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28139   if (!SWIG_IsOK(res1)) {
28140     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
28141   }
28142   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28143   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28144   if (!SWIG_IsOK(res2)) {
28145     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Vertex *""'");
28146   }
28147   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28148   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28149   if (!SWIG_IsOK(res3)) {
28150     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
28151   }
28152   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
28153   result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
28154   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
28155   return resultobj;
28156 fail:
28157   return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_Document_findQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28162   PyObject *resultobj = 0;
28163   Hex::Document *arg1 = (Hex::Document *) 0 ;
28164   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28165   Hex::Edge *arg3 = (Hex::Edge *) 0 ;
28166   void *argp1 = 0 ;
28167   int res1 = 0 ;
28168   void *argp2 = 0 ;
28169   int res2 = 0 ;
28170   void *argp3 = 0 ;
28171   int res3 = 0 ;
28172   PyObject * obj0 = 0 ;
28173   PyObject * obj1 = 0 ;
28174   PyObject * obj2 = 0 ;
28175   Hex::Quad *result = 0 ;
28176
28177   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findQuad",&obj0,&obj1,&obj2)) SWIG_fail;
28178   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28179   if (!SWIG_IsOK(res1)) {
28180     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findQuad" "', argument " "1"" of type '" "Hex::Document *""'");
28181   }
28182   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28183   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
28184   if (!SWIG_IsOK(res2)) {
28185     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findQuad" "', argument " "2"" of type '" "Hex::Edge *""'");
28186   }
28187   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28188   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Edge, 0 |  0 );
28189   if (!SWIG_IsOK(res3)) {
28190     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findQuad" "', argument " "3"" of type '" "Hex::Edge *""'");
28191   }
28192   arg3 = reinterpret_cast< Hex::Edge * >(argp3);
28193   result = (Hex::Quad *)(arg1)->findQuad(arg2,arg3);
28194   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
28195   return resultobj;
28196 fail:
28197   return NULL;
28198 }
28199
28200
28201 SWIGINTERN PyObject *_wrap_Document_findQuad(PyObject *self, PyObject *args) {
28202   Py_ssize_t argc;
28203   PyObject *argv[4] = {
28204     0
28205   };
28206   Py_ssize_t ii;
28207
28208   if (!PyTuple_Check(args)) SWIG_fail;
28209   argc = args ? PyObject_Length(args) : 0;
28210   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
28211     argv[ii] = PyTuple_GET_ITEM(args,ii);
28212   }
28213   if (argc == 3) {
28214     int _v;
28215     void *vptr = 0;
28216     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28217     _v = SWIG_CheckState(res);
28218     if (_v) {
28219       void *vptr = 0;
28220       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
28221       _v = SWIG_CheckState(res);
28222       if (_v) {
28223         void *vptr = 0;
28224         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
28225         _v = SWIG_CheckState(res);
28226         if (_v) {
28227           return _wrap_Document_findQuad__SWIG_0(self, args);
28228         }
28229       }
28230     }
28231   }
28232   if (argc == 3) {
28233     int _v;
28234     void *vptr = 0;
28235     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
28236     _v = SWIG_CheckState(res);
28237     if (_v) {
28238       void *vptr = 0;
28239       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Edge, 0);
28240       _v = SWIG_CheckState(res);
28241       if (_v) {
28242         void *vptr = 0;
28243         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Edge, 0);
28244         _v = SWIG_CheckState(res);
28245         if (_v) {
28246           return _wrap_Document_findQuad__SWIG_1(self, args);
28247         }
28248       }
28249     }
28250   }
28251
28252 fail:
28253   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_findQuad'.\n"
28254     "  Possible C/C++ prototypes are:\n"
28255     "    Hex::Document::findQuad(Hex::Vertex *,Hex::Vertex *)\n"
28256     "    Hex::Document::findQuad(Hex::Edge *,Hex::Edge *)\n");
28257   return 0;
28258 }
28259
28260
28261 SWIGINTERN PyObject *_wrap_Document_findHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28262   PyObject *resultobj = 0;
28263   Hex::Document *arg1 = (Hex::Document *) 0 ;
28264   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28265   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
28266   void *argp1 = 0 ;
28267   int res1 = 0 ;
28268   void *argp2 = 0 ;
28269   int res2 = 0 ;
28270   void *argp3 = 0 ;
28271   int res3 = 0 ;
28272   PyObject * obj0 = 0 ;
28273   PyObject * obj1 = 0 ;
28274   PyObject * obj2 = 0 ;
28275   Hex::Hexa *result = 0 ;
28276
28277   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_findHexa",&obj0,&obj1,&obj2)) SWIG_fail;
28278   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28279   if (!SWIG_IsOK(res1)) {
28280     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findHexa" "', argument " "1"" of type '" "Hex::Document *""'");
28281   }
28282   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28283   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28284   if (!SWIG_IsOK(res2)) {
28285     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findHexa" "', argument " "2"" of type '" "Hex::Vertex *""'");
28286   }
28287   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28288   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28289   if (!SWIG_IsOK(res3)) {
28290     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_findHexa" "', argument " "3"" of type '" "Hex::Vertex *""'");
28291   }
28292   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
28293   result = (Hex::Hexa *)(arg1)->findHexa(arg2,arg3);
28294   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
28295   return resultobj;
28296 fail:
28297   return NULL;
28298 }
28299
28300
28301 SWIGINTERN PyObject *_wrap_Document_findGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28302   PyObject *resultobj = 0;
28303   Hex::Document *arg1 = (Hex::Document *) 0 ;
28304   cpchar arg2 = (cpchar) 0 ;
28305   void *argp1 = 0 ;
28306   int res1 = 0 ;
28307   int res2 ;
28308   char *buf2 = 0 ;
28309   int alloc2 = 0 ;
28310   PyObject * obj0 = 0 ;
28311   PyObject * obj1 = 0 ;
28312   Hex::Group *result = 0 ;
28313
28314   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findGroup",&obj0,&obj1)) SWIG_fail;
28315   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28316   if (!SWIG_IsOK(res1)) {
28317     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findGroup" "', argument " "1"" of type '" "Hex::Document *""'");
28318   }
28319   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28320   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28321   if (!SWIG_IsOK(res2)) {
28322     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findGroup" "', argument " "2"" of type '" "cpchar""'");
28323   }
28324   arg2 = reinterpret_cast< cpchar >(buf2);
28325   result = (Hex::Group *)(arg1)->findGroup(arg2);
28326   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
28327   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28328   return resultobj;
28329 fail:
28330   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28331   return NULL;
28332 }
28333
28334
28335 SWIGINTERN PyObject *_wrap_Document_findLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28336   PyObject *resultobj = 0;
28337   Hex::Document *arg1 = (Hex::Document *) 0 ;
28338   cpchar arg2 = (cpchar) 0 ;
28339   void *argp1 = 0 ;
28340   int res1 = 0 ;
28341   int res2 ;
28342   char *buf2 = 0 ;
28343   int alloc2 = 0 ;
28344   PyObject * obj0 = 0 ;
28345   PyObject * obj1 = 0 ;
28346   Hex::Law *result = 0 ;
28347
28348   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findLaw",&obj0,&obj1)) SWIG_fail;
28349   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28350   if (!SWIG_IsOK(res1)) {
28351     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findLaw" "', argument " "1"" of type '" "Hex::Document *""'");
28352   }
28353   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28354   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28355   if (!SWIG_IsOK(res2)) {
28356     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findLaw" "', argument " "2"" of type '" "cpchar""'");
28357   }
28358   arg2 = reinterpret_cast< cpchar >(buf2);
28359   result = (Hex::Law *)(arg1)->findLaw(arg2);
28360   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
28361   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28362   return resultobj;
28363 fail:
28364   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
28365   return NULL;
28366 }
28367
28368
28369 SWIGINTERN PyObject *_wrap_Document_findPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28370   PyObject *resultobj = 0;
28371   Hex::Document *arg1 = (Hex::Document *) 0 ;
28372   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
28373   void *argp1 = 0 ;
28374   int res1 = 0 ;
28375   void *argp2 = 0 ;
28376   int res2 = 0 ;
28377   PyObject * obj0 = 0 ;
28378   PyObject * obj1 = 0 ;
28379   Hex::Propagation *result = 0 ;
28380
28381   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findPropagation",&obj0,&obj1)) SWIG_fail;
28382   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28383   if (!SWIG_IsOK(res1)) {
28384     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findPropagation" "', argument " "1"" of type '" "Hex::Document *""'");
28385   }
28386   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28387   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
28388   if (!SWIG_IsOK(res2)) {
28389     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_findPropagation" "', argument " "2"" of type '" "Hex::Edge *""'");
28390   }
28391   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
28392   result = (Hex::Propagation *)(arg1)->findPropagation(arg2);
28393   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, 0 |  0 );
28394   return resultobj;
28395 fail:
28396   return NULL;
28397 }
28398
28399
28400 SWIGINTERN PyObject *_wrap_Document_removeHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28401   PyObject *resultobj = 0;
28402   Hex::Document *arg1 = (Hex::Document *) 0 ;
28403   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
28404   void *argp1 = 0 ;
28405   int res1 = 0 ;
28406   void *argp2 = 0 ;
28407   int res2 = 0 ;
28408   PyObject * obj0 = 0 ;
28409   PyObject * obj1 = 0 ;
28410   int result;
28411
28412   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeHexa",&obj0,&obj1)) SWIG_fail;
28413   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28414   if (!SWIG_IsOK(res1)) {
28415     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeHexa" "', argument " "1"" of type '" "Hex::Document *""'");
28416   }
28417   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28418   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
28419   if (!SWIG_IsOK(res2)) {
28420     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
28421   }
28422   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
28423   result = (int)(arg1)->removeHexa(arg2);
28424   resultobj = SWIG_From_int(static_cast< int >(result));
28425   return resultobj;
28426 fail:
28427   return NULL;
28428 }
28429
28430
28431 SWIGINTERN PyObject *_wrap_Document_removeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28432   PyObject *resultobj = 0;
28433   Hex::Document *arg1 = (Hex::Document *) 0 ;
28434   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
28435   void *argp1 = 0 ;
28436   int res1 = 0 ;
28437   void *argp2 = 0 ;
28438   int res2 = 0 ;
28439   PyObject * obj0 = 0 ;
28440   PyObject * obj1 = 0 ;
28441   int result;
28442
28443   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeQuad",&obj0,&obj1)) SWIG_fail;
28444   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28445   if (!SWIG_IsOK(res1)) {
28446     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
28447   }
28448   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28449   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
28450   if (!SWIG_IsOK(res2)) {
28451     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
28452   }
28453   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
28454   result = (int)(arg1)->removeQuad(arg2);
28455   resultobj = SWIG_From_int(static_cast< int >(result));
28456   return resultobj;
28457 fail:
28458   return NULL;
28459 }
28460
28461
28462 SWIGINTERN PyObject *_wrap_Document_removeConnectedHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28463   PyObject *resultobj = 0;
28464   Hex::Document *arg1 = (Hex::Document *) 0 ;
28465   Hex::Hexa *arg2 = (Hex::Hexa *) 0 ;
28466   void *argp1 = 0 ;
28467   int res1 = 0 ;
28468   void *argp2 = 0 ;
28469   int res2 = 0 ;
28470   PyObject * obj0 = 0 ;
28471   PyObject * obj1 = 0 ;
28472   int result;
28473
28474   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeConnectedHexa",&obj0,&obj1)) SWIG_fail;
28475   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28476   if (!SWIG_IsOK(res1)) {
28477     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeConnectedHexa" "', argument " "1"" of type '" "Hex::Document *""'");
28478   }
28479   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28480   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Hexa, 0 |  0 );
28481   if (!SWIG_IsOK(res2)) {
28482     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeConnectedHexa" "', argument " "2"" of type '" "Hex::Hexa *""'");
28483   }
28484   arg2 = reinterpret_cast< Hex::Hexa * >(argp2);
28485   result = (int)(arg1)->removeConnectedHexa(arg2);
28486   resultobj = SWIG_From_int(static_cast< int >(result));
28487   return resultobj;
28488 fail:
28489   return NULL;
28490 }
28491
28492
28493 SWIGINTERN PyObject *_wrap_Document_removeElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28494   PyObject *resultobj = 0;
28495   Hex::Document *arg1 = (Hex::Document *) 0 ;
28496   Hex::Elements *arg2 = (Hex::Elements *) 0 ;
28497   void *argp1 = 0 ;
28498   int res1 = 0 ;
28499   void *argp2 = 0 ;
28500   int res2 = 0 ;
28501   PyObject * obj0 = 0 ;
28502   PyObject * obj1 = 0 ;
28503   int result;
28504
28505   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeElements",&obj0,&obj1)) SWIG_fail;
28506   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28507   if (!SWIG_IsOK(res1)) {
28508     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeElements" "', argument " "1"" of type '" "Hex::Document *""'");
28509   }
28510   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28511   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Elements, 0 |  0 );
28512   if (!SWIG_IsOK(res2)) {
28513     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeElements" "', argument " "2"" of type '" "Hex::Elements *""'");
28514   }
28515   arg2 = reinterpret_cast< Hex::Elements * >(argp2);
28516   result = (int)(arg1)->removeElements(arg2);
28517   resultobj = SWIG_From_int(static_cast< int >(result));
28518   return resultobj;
28519 fail:
28520   return NULL;
28521 }
28522
28523
28524 SWIGINTERN PyObject *_wrap_Document_removeGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28525   PyObject *resultobj = 0;
28526   Hex::Document *arg1 = (Hex::Document *) 0 ;
28527   Hex::Group *arg2 = (Hex::Group *) 0 ;
28528   void *argp1 = 0 ;
28529   int res1 = 0 ;
28530   void *argp2 = 0 ;
28531   int res2 = 0 ;
28532   PyObject * obj0 = 0 ;
28533   PyObject * obj1 = 0 ;
28534   int result;
28535
28536   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeGroup",&obj0,&obj1)) SWIG_fail;
28537   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28538   if (!SWIG_IsOK(res1)) {
28539     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeGroup" "', argument " "1"" of type '" "Hex::Document *""'");
28540   }
28541   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28542   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Group, 0 |  0 );
28543   if (!SWIG_IsOK(res2)) {
28544     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeGroup" "', argument " "2"" of type '" "Hex::Group *""'");
28545   }
28546   arg2 = reinterpret_cast< Hex::Group * >(argp2);
28547   result = (int)(arg1)->removeGroup(arg2);
28548   resultobj = SWIG_From_int(static_cast< int >(result));
28549   return resultobj;
28550 fail:
28551   return NULL;
28552 }
28553
28554
28555 SWIGINTERN PyObject *_wrap_Document_removeLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28556   PyObject *resultobj = 0;
28557   Hex::Document *arg1 = (Hex::Document *) 0 ;
28558   Hex::Law *arg2 = (Hex::Law *) 0 ;
28559   void *argp1 = 0 ;
28560   int res1 = 0 ;
28561   void *argp2 = 0 ;
28562   int res2 = 0 ;
28563   PyObject * obj0 = 0 ;
28564   PyObject * obj1 = 0 ;
28565   int result;
28566
28567   if (!PyArg_ParseTuple(args,(char *)"OO:Document_removeLaw",&obj0,&obj1)) SWIG_fail;
28568   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28569   if (!SWIG_IsOK(res1)) {
28570     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_removeLaw" "', argument " "1"" of type '" "Hex::Document *""'");
28571   }
28572   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28573   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
28574   if (!SWIG_IsOK(res2)) {
28575     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_removeLaw" "', argument " "2"" of type '" "Hex::Law *""'");
28576   }
28577   arg2 = reinterpret_cast< Hex::Law * >(argp2);
28578   result = (int)(arg1)->removeLaw(arg2);
28579   resultobj = SWIG_From_int(static_cast< int >(result));
28580   return resultobj;
28581 fail:
28582   return NULL;
28583 }
28584
28585
28586 SWIGINTERN PyObject *_wrap_Document_makeCartesianTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28587   PyObject *resultobj = 0;
28588   Hex::Document *arg1 = (Hex::Document *) 0 ;
28589   int arg2 ;
28590   int arg3 ;
28591   int arg4 ;
28592   void *argp1 = 0 ;
28593   int res1 = 0 ;
28594   int val2 ;
28595   int ecode2 = 0 ;
28596   int val3 ;
28597   int ecode3 = 0 ;
28598   int val4 ;
28599   int ecode4 = 0 ;
28600   PyObject * obj0 = 0 ;
28601   PyObject * obj1 = 0 ;
28602   PyObject * obj2 = 0 ;
28603   PyObject * obj3 = 0 ;
28604   Hex::Elements *result = 0 ;
28605
28606   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCartesianTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28607   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28608   if (!SWIG_IsOK(res1)) {
28609     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianTop" "', argument " "1"" of type '" "Hex::Document *""'");
28610   }
28611   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28612   ecode2 = SWIG_AsVal_int(obj1, &val2);
28613   if (!SWIG_IsOK(ecode2)) {
28614     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCartesianTop" "', argument " "2"" of type '" "int""'");
28615   }
28616   arg2 = static_cast< int >(val2);
28617   ecode3 = SWIG_AsVal_int(obj2, &val3);
28618   if (!SWIG_IsOK(ecode3)) {
28619     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCartesianTop" "', argument " "3"" of type '" "int""'");
28620   }
28621   arg3 = static_cast< int >(val3);
28622   ecode4 = SWIG_AsVal_int(obj3, &val4);
28623   if (!SWIG_IsOK(ecode4)) {
28624     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCartesianTop" "', argument " "4"" of type '" "int""'");
28625   }
28626   arg4 = static_cast< int >(val4);
28627   result = (Hex::Elements *)(arg1)->makeCartesianTop(arg2,arg3,arg4);
28628   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28629   return resultobj;
28630 fail:
28631   return NULL;
28632 }
28633
28634
28635 SWIGINTERN PyObject *_wrap_Document_makeCartesianUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28636   PyObject *resultobj = 0;
28637   Hex::Document *arg1 = (Hex::Document *) 0 ;
28638   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28639   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28640   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
28641   Hex::Vector *arg5 = (Hex::Vector *) 0 ;
28642   double arg6 ;
28643   double arg7 ;
28644   double arg8 ;
28645   int arg9 ;
28646   int arg10 ;
28647   int arg11 ;
28648   void *argp1 = 0 ;
28649   int res1 = 0 ;
28650   void *argp2 = 0 ;
28651   int res2 = 0 ;
28652   void *argp3 = 0 ;
28653   int res3 = 0 ;
28654   void *argp4 = 0 ;
28655   int res4 = 0 ;
28656   void *argp5 = 0 ;
28657   int res5 = 0 ;
28658   double val6 ;
28659   int ecode6 = 0 ;
28660   double val7 ;
28661   int ecode7 = 0 ;
28662   double val8 ;
28663   int ecode8 = 0 ;
28664   int val9 ;
28665   int ecode9 = 0 ;
28666   int val10 ;
28667   int ecode10 = 0 ;
28668   int val11 ;
28669   int ecode11 = 0 ;
28670   PyObject * obj0 = 0 ;
28671   PyObject * obj1 = 0 ;
28672   PyObject * obj2 = 0 ;
28673   PyObject * obj3 = 0 ;
28674   PyObject * obj4 = 0 ;
28675   PyObject * obj5 = 0 ;
28676   PyObject * obj6 = 0 ;
28677   PyObject * obj7 = 0 ;
28678   PyObject * obj8 = 0 ;
28679   PyObject * obj9 = 0 ;
28680   PyObject * obj10 = 0 ;
28681   Hex::Elements *result = 0 ;
28682
28683   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCartesianUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
28684   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28685   if (!SWIG_IsOK(res1)) {
28686     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesianUni" "', argument " "1"" of type '" "Hex::Document *""'");
28687   }
28688   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28689   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28690   if (!SWIG_IsOK(res2)) {
28691     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesianUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
28692   }
28693   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28694   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28695   if (!SWIG_IsOK(res3)) {
28696     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesianUni" "', argument " "3"" of type '" "Hex::Vector *""'");
28697   }
28698   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28699   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28700   if (!SWIG_IsOK(res4)) {
28701     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesianUni" "', argument " "4"" of type '" "Hex::Vector *""'");
28702   }
28703   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
28704   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28705   if (!SWIG_IsOK(res5)) {
28706     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesianUni" "', argument " "5"" of type '" "Hex::Vector *""'");
28707   }
28708   arg5 = reinterpret_cast< Hex::Vector * >(argp5);
28709   ecode6 = SWIG_AsVal_double(obj5, &val6);
28710   if (!SWIG_IsOK(ecode6)) {
28711     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCartesianUni" "', argument " "6"" of type '" "double""'");
28712   }
28713   arg6 = static_cast< double >(val6);
28714   ecode7 = SWIG_AsVal_double(obj6, &val7);
28715   if (!SWIG_IsOK(ecode7)) {
28716     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCartesianUni" "', argument " "7"" of type '" "double""'");
28717   }
28718   arg7 = static_cast< double >(val7);
28719   ecode8 = SWIG_AsVal_double(obj7, &val8);
28720   if (!SWIG_IsOK(ecode8)) {
28721     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCartesianUni" "', argument " "8"" of type '" "double""'");
28722   }
28723   arg8 = static_cast< double >(val8);
28724   ecode9 = SWIG_AsVal_int(obj8, &val9);
28725   if (!SWIG_IsOK(ecode9)) {
28726     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCartesianUni" "', argument " "9"" of type '" "int""'");
28727   }
28728   arg9 = static_cast< int >(val9);
28729   ecode10 = SWIG_AsVal_int(obj9, &val10);
28730   if (!SWIG_IsOK(ecode10)) {
28731     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCartesianUni" "', argument " "10"" of type '" "int""'");
28732   }
28733   arg10 = static_cast< int >(val10);
28734   ecode11 = SWIG_AsVal_int(obj10, &val11);
28735   if (!SWIG_IsOK(ecode11)) {
28736     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCartesianUni" "', argument " "11"" of type '" "int""'");
28737   }
28738   arg11 = static_cast< int >(val11);
28739   result = (Hex::Elements *)(arg1)->makeCartesianUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
28740   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28741   return resultobj;
28742 fail:
28743   return NULL;
28744 }
28745
28746
28747 SWIGINTERN PyObject *_wrap_Document_makeCartesian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28748   PyObject *resultobj = 0;
28749   Hex::Document *arg1 = (Hex::Document *) 0 ;
28750   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28751   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28752   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
28753   Hex::Vector *arg5 = (Hex::Vector *) 0 ;
28754   Hex::RealVector arg6 ;
28755   Hex::RealVector arg7 ;
28756   Hex::RealVector arg8 ;
28757   void *argp1 = 0 ;
28758   int res1 = 0 ;
28759   void *argp2 = 0 ;
28760   int res2 = 0 ;
28761   void *argp3 = 0 ;
28762   int res3 = 0 ;
28763   void *argp4 = 0 ;
28764   int res4 = 0 ;
28765   void *argp5 = 0 ;
28766   int res5 = 0 ;
28767   PyObject * obj0 = 0 ;
28768   PyObject * obj1 = 0 ;
28769   PyObject * obj2 = 0 ;
28770   PyObject * obj3 = 0 ;
28771   PyObject * obj4 = 0 ;
28772   PyObject * obj5 = 0 ;
28773   PyObject * obj6 = 0 ;
28774   PyObject * obj7 = 0 ;
28775   Hex::Elements *result = 0 ;
28776
28777   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_makeCartesian",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
28778   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28779   if (!SWIG_IsOK(res1)) {
28780     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCartesian" "', argument " "1"" of type '" "Hex::Document *""'");
28781   }
28782   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28783   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28784   if (!SWIG_IsOK(res2)) {
28785     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCartesian" "', argument " "2"" of type '" "Hex::Vertex *""'");
28786   }
28787   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28788   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28789   if (!SWIG_IsOK(res3)) {
28790     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCartesian" "', argument " "3"" of type '" "Hex::Vector *""'");
28791   }
28792   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28793   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28794   if (!SWIG_IsOK(res4)) {
28795     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCartesian" "', argument " "4"" of type '" "Hex::Vector *""'");
28796   }
28797   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
28798   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28799   if (!SWIG_IsOK(res5)) {
28800     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_makeCartesian" "', argument " "5"" of type '" "Hex::Vector *""'");
28801   }
28802   arg5 = reinterpret_cast< Hex::Vector * >(argp5);
28803   {
28804     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
28805     int res = swig::asptr(obj5, &ptr);
28806     if (!SWIG_IsOK(res) || !ptr) {
28807       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "6"" of type '" "Hex::RealVector""'");
28808     }
28809     arg6 = *ptr;
28810     if (SWIG_IsNewObj(res)) delete ptr;
28811   }
28812   {
28813     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
28814     int res = swig::asptr(obj6, &ptr);
28815     if (!SWIG_IsOK(res) || !ptr) {
28816       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "7"" of type '" "Hex::RealVector""'");
28817     }
28818     arg7 = *ptr;
28819     if (SWIG_IsNewObj(res)) delete ptr;
28820   }
28821   {
28822     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
28823     int res = swig::asptr(obj7, &ptr);
28824     if (!SWIG_IsOK(res) || !ptr) {
28825       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCartesian" "', argument " "8"" of type '" "Hex::RealVector""'");
28826     }
28827     arg8 = *ptr;
28828     if (SWIG_IsNewObj(res)) delete ptr;
28829   }
28830   result = (Hex::Elements *)(arg1)->makeCartesian(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
28831   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28832   return resultobj;
28833 fail:
28834   return NULL;
28835 }
28836
28837
28838 SWIGINTERN PyObject *_wrap_Document_makeCylinderTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28839   PyObject *resultobj = 0;
28840   Hex::Document *arg1 = (Hex::Document *) 0 ;
28841   int arg2 ;
28842   int arg3 ;
28843   int arg4 ;
28844   void *argp1 = 0 ;
28845   int res1 = 0 ;
28846   int val2 ;
28847   int ecode2 = 0 ;
28848   int val3 ;
28849   int ecode3 = 0 ;
28850   int val4 ;
28851   int ecode4 = 0 ;
28852   PyObject * obj0 = 0 ;
28853   PyObject * obj1 = 0 ;
28854   PyObject * obj2 = 0 ;
28855   PyObject * obj3 = 0 ;
28856   Hex::Elements *result = 0 ;
28857
28858   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeCylinderTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28859   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28860   if (!SWIG_IsOK(res1)) {
28861     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderTop" "', argument " "1"" of type '" "Hex::Document *""'");
28862   }
28863   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28864   ecode2 = SWIG_AsVal_int(obj1, &val2);
28865   if (!SWIG_IsOK(ecode2)) {
28866     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeCylinderTop" "', argument " "2"" of type '" "int""'");
28867   }
28868   arg2 = static_cast< int >(val2);
28869   ecode3 = SWIG_AsVal_int(obj2, &val3);
28870   if (!SWIG_IsOK(ecode3)) {
28871     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeCylinderTop" "', argument " "3"" of type '" "int""'");
28872   }
28873   arg3 = static_cast< int >(val3);
28874   ecode4 = SWIG_AsVal_int(obj3, &val4);
28875   if (!SWIG_IsOK(ecode4)) {
28876     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinderTop" "', argument " "4"" of type '" "int""'");
28877   }
28878   arg4 = static_cast< int >(val4);
28879   result = (Hex::Elements *)(arg1)->makeCylinderTop(arg2,arg3,arg4);
28880   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28881   return resultobj;
28882 fail:
28883   return NULL;
28884 }
28885
28886
28887 SWIGINTERN PyObject *_wrap_Document_makeCylinderUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28888   PyObject *resultobj = 0;
28889   Hex::Document *arg1 = (Hex::Document *) 0 ;
28890   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
28891   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
28892   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
28893   double arg5 ;
28894   double arg6 ;
28895   double arg7 ;
28896   double arg8 ;
28897   int arg9 ;
28898   int arg10 ;
28899   int arg11 ;
28900   void *argp1 = 0 ;
28901   int res1 = 0 ;
28902   void *argp2 = 0 ;
28903   int res2 = 0 ;
28904   void *argp3 = 0 ;
28905   int res3 = 0 ;
28906   void *argp4 = 0 ;
28907   int res4 = 0 ;
28908   double val5 ;
28909   int ecode5 = 0 ;
28910   double val6 ;
28911   int ecode6 = 0 ;
28912   double val7 ;
28913   int ecode7 = 0 ;
28914   double val8 ;
28915   int ecode8 = 0 ;
28916   int val9 ;
28917   int ecode9 = 0 ;
28918   int val10 ;
28919   int ecode10 = 0 ;
28920   int val11 ;
28921   int ecode11 = 0 ;
28922   PyObject * obj0 = 0 ;
28923   PyObject * obj1 = 0 ;
28924   PyObject * obj2 = 0 ;
28925   PyObject * obj3 = 0 ;
28926   PyObject * obj4 = 0 ;
28927   PyObject * obj5 = 0 ;
28928   PyObject * obj6 = 0 ;
28929   PyObject * obj7 = 0 ;
28930   PyObject * obj8 = 0 ;
28931   PyObject * obj9 = 0 ;
28932   PyObject * obj10 = 0 ;
28933   Hex::Elements *result = 0 ;
28934
28935   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeCylinderUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
28936   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
28937   if (!SWIG_IsOK(res1)) {
28938     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinderUni" "', argument " "1"" of type '" "Hex::Document *""'");
28939   }
28940   arg1 = reinterpret_cast< Hex::Document * >(argp1);
28941   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
28942   if (!SWIG_IsOK(res2)) {
28943     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinderUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
28944   }
28945   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
28946   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28947   if (!SWIG_IsOK(res3)) {
28948     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinderUni" "', argument " "3"" of type '" "Hex::Vector *""'");
28949   }
28950   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
28951   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
28952   if (!SWIG_IsOK(res4)) {
28953     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinderUni" "', argument " "4"" of type '" "Hex::Vector *""'");
28954   }
28955   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
28956   ecode5 = SWIG_AsVal_double(obj4, &val5);
28957   if (!SWIG_IsOK(ecode5)) {
28958     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinderUni" "', argument " "5"" of type '" "double""'");
28959   }
28960   arg5 = static_cast< double >(val5);
28961   ecode6 = SWIG_AsVal_double(obj5, &val6);
28962   if (!SWIG_IsOK(ecode6)) {
28963     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeCylinderUni" "', argument " "6"" of type '" "double""'");
28964   }
28965   arg6 = static_cast< double >(val6);
28966   ecode7 = SWIG_AsVal_double(obj6, &val7);
28967   if (!SWIG_IsOK(ecode7)) {
28968     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeCylinderUni" "', argument " "7"" of type '" "double""'");
28969   }
28970   arg7 = static_cast< double >(val7);
28971   ecode8 = SWIG_AsVal_double(obj7, &val8);
28972   if (!SWIG_IsOK(ecode8)) {
28973     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinderUni" "', argument " "8"" of type '" "double""'");
28974   }
28975   arg8 = static_cast< double >(val8);
28976   ecode9 = SWIG_AsVal_int(obj8, &val9);
28977   if (!SWIG_IsOK(ecode9)) {
28978     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinderUni" "', argument " "9"" of type '" "int""'");
28979   }
28980   arg9 = static_cast< int >(val9);
28981   ecode10 = SWIG_AsVal_int(obj9, &val10);
28982   if (!SWIG_IsOK(ecode10)) {
28983     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeCylinderUni" "', argument " "10"" of type '" "int""'");
28984   }
28985   arg10 = static_cast< int >(val10);
28986   ecode11 = SWIG_AsVal_int(obj10, &val11);
28987   if (!SWIG_IsOK(ecode11)) {
28988     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeCylinderUni" "', argument " "11"" of type '" "int""'");
28989   }
28990   arg11 = static_cast< int >(val11);
28991   result = (Hex::Elements *)(arg1)->makeCylinderUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
28992   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
28993   return resultobj;
28994 fail:
28995   return NULL;
28996 }
28997
28998
28999 SWIGINTERN PyObject *_wrap_Document_makeCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29000   PyObject *resultobj = 0;
29001   Hex::Document *arg1 = (Hex::Document *) 0 ;
29002   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29003   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29004   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29005   Hex::RealVector arg5 ;
29006   Hex::RealVector arg6 ;
29007   Hex::RealVector arg7 ;
29008   void *argp1 = 0 ;
29009   int res1 = 0 ;
29010   void *argp2 = 0 ;
29011   int res2 = 0 ;
29012   void *argp3 = 0 ;
29013   int res3 = 0 ;
29014   void *argp4 = 0 ;
29015   int res4 = 0 ;
29016   PyObject * obj0 = 0 ;
29017   PyObject * obj1 = 0 ;
29018   PyObject * obj2 = 0 ;
29019   PyObject * obj3 = 0 ;
29020   PyObject * obj4 = 0 ;
29021   PyObject * obj5 = 0 ;
29022   PyObject * obj6 = 0 ;
29023   Hex::Elements *result = 0 ;
29024
29025   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeCylinder",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29026   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29027   if (!SWIG_IsOK(res1)) {
29028     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
29029   }
29030   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29031   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29032   if (!SWIG_IsOK(res2)) {
29033     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinder" "', argument " "2"" of type '" "Hex::Vertex *""'");
29034   }
29035   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29036   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29037   if (!SWIG_IsOK(res3)) {
29038     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinder" "', argument " "3"" of type '" "Hex::Vector *""'");
29039   }
29040   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29041   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29042   if (!SWIG_IsOK(res4)) {
29043     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeCylinder" "', argument " "4"" of type '" "Hex::Vector *""'");
29044   }
29045   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29046   {
29047     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29048     int res = swig::asptr(obj4, &ptr);
29049     if (!SWIG_IsOK(res) || !ptr) {
29050       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "5"" of type '" "Hex::RealVector""'");
29051     }
29052     arg5 = *ptr;
29053     if (SWIG_IsNewObj(res)) delete ptr;
29054   }
29055   {
29056     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29057     int res = swig::asptr(obj5, &ptr);
29058     if (!SWIG_IsOK(res) || !ptr) {
29059       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "6"" of type '" "Hex::RealVector""'");
29060     }
29061     arg6 = *ptr;
29062     if (SWIG_IsNewObj(res)) delete ptr;
29063   }
29064   {
29065     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29066     int res = swig::asptr(obj6, &ptr);
29067     if (!SWIG_IsOK(res) || !ptr) {
29068       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeCylinder" "', argument " "7"" of type '" "Hex::RealVector""'");
29069     }
29070     arg7 = *ptr;
29071     if (SWIG_IsNewObj(res)) delete ptr;
29072   }
29073   result = (Hex::Elements *)(arg1)->makeCylinder(arg2,arg3,arg4,arg5,arg6,arg7);
29074   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29075   return resultobj;
29076 fail:
29077   return NULL;
29078 }
29079
29080
29081 SWIGINTERN PyObject *_wrap_Document_makePipeTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29082   PyObject *resultobj = 0;
29083   Hex::Document *arg1 = (Hex::Document *) 0 ;
29084   int arg2 ;
29085   int arg3 ;
29086   int arg4 ;
29087   void *argp1 = 0 ;
29088   int res1 = 0 ;
29089   int val2 ;
29090   int ecode2 = 0 ;
29091   int val3 ;
29092   int ecode3 = 0 ;
29093   int val4 ;
29094   int ecode4 = 0 ;
29095   PyObject * obj0 = 0 ;
29096   PyObject * obj1 = 0 ;
29097   PyObject * obj2 = 0 ;
29098   PyObject * obj3 = 0 ;
29099   Hex::Elements *result = 0 ;
29100
29101   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makePipeTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29102   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29103   if (!SWIG_IsOK(res1)) {
29104     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeTop" "', argument " "1"" of type '" "Hex::Document *""'");
29105   }
29106   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29107   ecode2 = SWIG_AsVal_int(obj1, &val2);
29108   if (!SWIG_IsOK(ecode2)) {
29109     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makePipeTop" "', argument " "2"" of type '" "int""'");
29110   }
29111   arg2 = static_cast< int >(val2);
29112   ecode3 = SWIG_AsVal_int(obj2, &val3);
29113   if (!SWIG_IsOK(ecode3)) {
29114     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makePipeTop" "', argument " "3"" of type '" "int""'");
29115   }
29116   arg3 = static_cast< int >(val3);
29117   ecode4 = SWIG_AsVal_int(obj3, &val4);
29118   if (!SWIG_IsOK(ecode4)) {
29119     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipeTop" "', argument " "4"" of type '" "int""'");
29120   }
29121   arg4 = static_cast< int >(val4);
29122   result = (Hex::Elements *)(arg1)->makePipeTop(arg2,arg3,arg4);
29123   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29124   return resultobj;
29125 fail:
29126   return NULL;
29127 }
29128
29129
29130 SWIGINTERN PyObject *_wrap_Document_makePipeUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29131   PyObject *resultobj = 0;
29132   Hex::Document *arg1 = (Hex::Document *) 0 ;
29133   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29134   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29135   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29136   double arg5 ;
29137   double arg6 ;
29138   double arg7 ;
29139   double arg8 ;
29140   int arg9 ;
29141   int arg10 ;
29142   int arg11 ;
29143   void *argp1 = 0 ;
29144   int res1 = 0 ;
29145   void *argp2 = 0 ;
29146   int res2 = 0 ;
29147   void *argp3 = 0 ;
29148   int res3 = 0 ;
29149   void *argp4 = 0 ;
29150   int res4 = 0 ;
29151   double val5 ;
29152   int ecode5 = 0 ;
29153   double val6 ;
29154   int ecode6 = 0 ;
29155   double val7 ;
29156   int ecode7 = 0 ;
29157   double val8 ;
29158   int ecode8 = 0 ;
29159   int val9 ;
29160   int ecode9 = 0 ;
29161   int val10 ;
29162   int ecode10 = 0 ;
29163   int val11 ;
29164   int ecode11 = 0 ;
29165   PyObject * obj0 = 0 ;
29166   PyObject * obj1 = 0 ;
29167   PyObject * obj2 = 0 ;
29168   PyObject * obj3 = 0 ;
29169   PyObject * obj4 = 0 ;
29170   PyObject * obj5 = 0 ;
29171   PyObject * obj6 = 0 ;
29172   PyObject * obj7 = 0 ;
29173   PyObject * obj8 = 0 ;
29174   PyObject * obj9 = 0 ;
29175   PyObject * obj10 = 0 ;
29176   Hex::Elements *result = 0 ;
29177
29178   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipeUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
29179   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29180   if (!SWIG_IsOK(res1)) {
29181     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipeUni" "', argument " "1"" of type '" "Hex::Document *""'");
29182   }
29183   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29184   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29185   if (!SWIG_IsOK(res2)) {
29186     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipeUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
29187   }
29188   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29189   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29190   if (!SWIG_IsOK(res3)) {
29191     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipeUni" "', argument " "3"" of type '" "Hex::Vector *""'");
29192   }
29193   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29194   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29195   if (!SWIG_IsOK(res4)) {
29196     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipeUni" "', argument " "4"" of type '" "Hex::Vector *""'");
29197   }
29198   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29199   ecode5 = SWIG_AsVal_double(obj4, &val5);
29200   if (!SWIG_IsOK(ecode5)) {
29201     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipeUni" "', argument " "5"" of type '" "double""'");
29202   }
29203   arg5 = static_cast< double >(val5);
29204   ecode6 = SWIG_AsVal_double(obj5, &val6);
29205   if (!SWIG_IsOK(ecode6)) {
29206     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipeUni" "', argument " "6"" of type '" "double""'");
29207   }
29208   arg6 = static_cast< double >(val6);
29209   ecode7 = SWIG_AsVal_double(obj6, &val7);
29210   if (!SWIG_IsOK(ecode7)) {
29211     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makePipeUni" "', argument " "7"" of type '" "double""'");
29212   }
29213   arg7 = static_cast< double >(val7);
29214   ecode8 = SWIG_AsVal_double(obj7, &val8);
29215   if (!SWIG_IsOK(ecode8)) {
29216     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makePipeUni" "', argument " "8"" of type '" "double""'");
29217   }
29218   arg8 = static_cast< double >(val8);
29219   ecode9 = SWIG_AsVal_int(obj8, &val9);
29220   if (!SWIG_IsOK(ecode9)) {
29221     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipeUni" "', argument " "9"" of type '" "int""'");
29222   }
29223   arg9 = static_cast< int >(val9);
29224   ecode10 = SWIG_AsVal_int(obj9, &val10);
29225   if (!SWIG_IsOK(ecode10)) {
29226     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipeUni" "', argument " "10"" of type '" "int""'");
29227   }
29228   arg10 = static_cast< int >(val10);
29229   ecode11 = SWIG_AsVal_int(obj10, &val11);
29230   if (!SWIG_IsOK(ecode11)) {
29231     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipeUni" "', argument " "11"" of type '" "int""'");
29232   }
29233   arg11 = static_cast< int >(val11);
29234   result = (Hex::Elements *)(arg1)->makePipeUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
29235   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29236   return resultobj;
29237 fail:
29238   return NULL;
29239 }
29240
29241
29242 SWIGINTERN PyObject *_wrap_Document_makePipe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29243   PyObject *resultobj = 0;
29244   Hex::Document *arg1 = (Hex::Document *) 0 ;
29245   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29246   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29247   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29248   Hex::RealVector arg5 ;
29249   Hex::RealVector arg6 ;
29250   Hex::RealVector arg7 ;
29251   void *argp1 = 0 ;
29252   int res1 = 0 ;
29253   void *argp2 = 0 ;
29254   int res2 = 0 ;
29255   void *argp3 = 0 ;
29256   int res3 = 0 ;
29257   void *argp4 = 0 ;
29258   int res4 = 0 ;
29259   PyObject * obj0 = 0 ;
29260   PyObject * obj1 = 0 ;
29261   PyObject * obj2 = 0 ;
29262   PyObject * obj3 = 0 ;
29263   PyObject * obj4 = 0 ;
29264   PyObject * obj5 = 0 ;
29265   PyObject * obj6 = 0 ;
29266   Hex::Elements *result = 0 ;
29267
29268   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makePipe",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29269   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29270   if (!SWIG_IsOK(res1)) {
29271     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipe" "', argument " "1"" of type '" "Hex::Document *""'");
29272   }
29273   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29274   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29275   if (!SWIG_IsOK(res2)) {
29276     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipe" "', argument " "2"" of type '" "Hex::Vertex *""'");
29277   }
29278   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29279   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29280   if (!SWIG_IsOK(res3)) {
29281     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipe" "', argument " "3"" of type '" "Hex::Vector *""'");
29282   }
29283   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29284   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29285   if (!SWIG_IsOK(res4)) {
29286     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makePipe" "', argument " "4"" of type '" "Hex::Vector *""'");
29287   }
29288   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29289   {
29290     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29291     int res = swig::asptr(obj4, &ptr);
29292     if (!SWIG_IsOK(res) || !ptr) {
29293       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "5"" of type '" "Hex::RealVector""'");
29294     }
29295     arg5 = *ptr;
29296     if (SWIG_IsNewObj(res)) delete ptr;
29297   }
29298   {
29299     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29300     int res = swig::asptr(obj5, &ptr);
29301     if (!SWIG_IsOK(res) || !ptr) {
29302       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "6"" of type '" "Hex::RealVector""'");
29303     }
29304     arg6 = *ptr;
29305     if (SWIG_IsNewObj(res)) delete ptr;
29306   }
29307   {
29308     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29309     int res = swig::asptr(obj6, &ptr);
29310     if (!SWIG_IsOK(res) || !ptr) {
29311       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makePipe" "', argument " "7"" of type '" "Hex::RealVector""'");
29312     }
29313     arg7 = *ptr;
29314     if (SWIG_IsNewObj(res)) delete ptr;
29315   }
29316   result = (Hex::Elements *)(arg1)->makePipe(arg2,arg3,arg4,arg5,arg6,arg7);
29317   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29318   return resultobj;
29319 fail:
29320   return NULL;
29321 }
29322
29323
29324 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29325   PyObject *resultobj = 0;
29326   Hex::Document *arg1 = (Hex::Document *) 0 ;
29327   int arg2 ;
29328   int arg3 ;
29329   void *argp1 = 0 ;
29330   int res1 = 0 ;
29331   int val2 ;
29332   int ecode2 = 0 ;
29333   int val3 ;
29334   int ecode3 = 0 ;
29335   PyObject * obj0 = 0 ;
29336   PyObject * obj1 = 0 ;
29337   PyObject * obj2 = 0 ;
29338   Hex::Elements *result = 0 ;
29339
29340   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_makeSphericalTop",&obj0,&obj1,&obj2)) SWIG_fail;
29341   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29342   if (!SWIG_IsOK(res1)) {
29343     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
29344   }
29345   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29346   ecode2 = SWIG_AsVal_int(obj1, &val2);
29347   if (!SWIG_IsOK(ecode2)) {
29348     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
29349   }
29350   arg2 = static_cast< int >(val2);
29351   ecode3 = SWIG_AsVal_int(obj2, &val3);
29352   if (!SWIG_IsOK(ecode3)) {
29353     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphericalTop" "', argument " "3"" of type '" "int""'");
29354   }
29355   arg3 = static_cast< int >(val3);
29356   result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2,arg3);
29357   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29358   return resultobj;
29359 fail:
29360   return NULL;
29361 }
29362
29363
29364 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29365   PyObject *resultobj = 0;
29366   Hex::Document *arg1 = (Hex::Document *) 0 ;
29367   int arg2 ;
29368   void *argp1 = 0 ;
29369   int res1 = 0 ;
29370   int val2 ;
29371   int ecode2 = 0 ;
29372   PyObject * obj0 = 0 ;
29373   PyObject * obj1 = 0 ;
29374   Hex::Elements *result = 0 ;
29375
29376   if (!PyArg_ParseTuple(args,(char *)"OO:Document_makeSphericalTop",&obj0,&obj1)) SWIG_fail;
29377   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29378   if (!SWIG_IsOK(res1)) {
29379     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalTop" "', argument " "1"" of type '" "Hex::Document *""'");
29380   }
29381   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29382   ecode2 = SWIG_AsVal_int(obj1, &val2);
29383   if (!SWIG_IsOK(ecode2)) {
29384     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphericalTop" "', argument " "2"" of type '" "int""'");
29385   }
29386   arg2 = static_cast< int >(val2);
29387   result = (Hex::Elements *)(arg1)->makeSphericalTop(arg2);
29388   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29389   return resultobj;
29390 fail:
29391   return NULL;
29392 }
29393
29394
29395 SWIGINTERN PyObject *_wrap_Document_makeSphericalTop(PyObject *self, PyObject *args) {
29396   Py_ssize_t argc;
29397   PyObject *argv[4] = {
29398     0
29399   };
29400   Py_ssize_t ii;
29401
29402   if (!PyTuple_Check(args)) SWIG_fail;
29403   argc = args ? PyObject_Length(args) : 0;
29404   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
29405     argv[ii] = PyTuple_GET_ITEM(args,ii);
29406   }
29407   if (argc == 2) {
29408     int _v;
29409     void *vptr = 0;
29410     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29411     _v = SWIG_CheckState(res);
29412     if (_v) {
29413       {
29414         int res = SWIG_AsVal_int(argv[1], NULL);
29415         _v = SWIG_CheckState(res);
29416       }
29417       if (_v) {
29418         return _wrap_Document_makeSphericalTop__SWIG_1(self, args);
29419       }
29420     }
29421   }
29422   if (argc == 3) {
29423     int _v;
29424     void *vptr = 0;
29425     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29426     _v = SWIG_CheckState(res);
29427     if (_v) {
29428       {
29429         int res = SWIG_AsVal_int(argv[1], NULL);
29430         _v = SWIG_CheckState(res);
29431       }
29432       if (_v) {
29433         {
29434           int res = SWIG_AsVal_int(argv[2], NULL);
29435           _v = SWIG_CheckState(res);
29436         }
29437         if (_v) {
29438           return _wrap_Document_makeSphericalTop__SWIG_0(self, args);
29439         }
29440       }
29441     }
29442   }
29443
29444 fail:
29445   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_makeSphericalTop'.\n"
29446     "  Possible C/C++ prototypes are:\n"
29447     "    Hex::Document::makeSphericalTop(int,int)\n"
29448     "    Hex::Document::makeSphericalTop(int)\n");
29449   return 0;
29450 }
29451
29452
29453 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29454   PyObject *resultobj = 0;
29455   Hex::Document *arg1 = (Hex::Document *) 0 ;
29456   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29457   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29458   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29459   double arg5 ;
29460   int arg6 ;
29461   int arg7 ;
29462   void *argp1 = 0 ;
29463   int res1 = 0 ;
29464   void *argp2 = 0 ;
29465   int res2 = 0 ;
29466   void *argp3 = 0 ;
29467   int res3 = 0 ;
29468   void *argp4 = 0 ;
29469   int res4 = 0 ;
29470   double val5 ;
29471   int ecode5 = 0 ;
29472   int val6 ;
29473   int ecode6 = 0 ;
29474   int val7 ;
29475   int ecode7 = 0 ;
29476   PyObject * obj0 = 0 ;
29477   PyObject * obj1 = 0 ;
29478   PyObject * obj2 = 0 ;
29479   PyObject * obj3 = 0 ;
29480   PyObject * obj4 = 0 ;
29481   PyObject * obj5 = 0 ;
29482   PyObject * obj6 = 0 ;
29483   Hex::Elements *result = 0 ;
29484
29485   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29486   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29487   if (!SWIG_IsOK(res1)) {
29488     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
29489   }
29490   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29491   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29492   if (!SWIG_IsOK(res2)) {
29493     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
29494   }
29495   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29496   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29497   if (!SWIG_IsOK(res3)) {
29498     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
29499   }
29500   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29501   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29502   if (!SWIG_IsOK(res4)) {
29503     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
29504   }
29505   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29506   ecode5 = SWIG_AsVal_double(obj4, &val5);
29507   if (!SWIG_IsOK(ecode5)) {
29508     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
29509   }
29510   arg5 = static_cast< double >(val5);
29511   ecode6 = SWIG_AsVal_int(obj5, &val6);
29512   if (!SWIG_IsOK(ecode6)) {
29513     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
29514   }
29515   arg6 = static_cast< int >(val6);
29516   ecode7 = SWIG_AsVal_int(obj6, &val7);
29517   if (!SWIG_IsOK(ecode7)) {
29518     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphericalUni" "', argument " "7"" of type '" "int""'");
29519   }
29520   arg7 = static_cast< int >(val7);
29521   result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6,arg7);
29522   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29523   return resultobj;
29524 fail:
29525   return NULL;
29526 }
29527
29528
29529 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29530   PyObject *resultobj = 0;
29531   Hex::Document *arg1 = (Hex::Document *) 0 ;
29532   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29533   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29534   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29535   double arg5 ;
29536   int arg6 ;
29537   void *argp1 = 0 ;
29538   int res1 = 0 ;
29539   void *argp2 = 0 ;
29540   int res2 = 0 ;
29541   void *argp3 = 0 ;
29542   int res3 = 0 ;
29543   void *argp4 = 0 ;
29544   int res4 = 0 ;
29545   double val5 ;
29546   int ecode5 = 0 ;
29547   int val6 ;
29548   int ecode6 = 0 ;
29549   PyObject * obj0 = 0 ;
29550   PyObject * obj1 = 0 ;
29551   PyObject * obj2 = 0 ;
29552   PyObject * obj3 = 0 ;
29553   PyObject * obj4 = 0 ;
29554   PyObject * obj5 = 0 ;
29555   Hex::Elements *result = 0 ;
29556
29557   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSphericalUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29558   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29559   if (!SWIG_IsOK(res1)) {
29560     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphericalUni" "', argument " "1"" of type '" "Hex::Document *""'");
29561   }
29562   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29563   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29564   if (!SWIG_IsOK(res2)) {
29565     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphericalUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
29566   }
29567   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29568   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29569   if (!SWIG_IsOK(res3)) {
29570     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphericalUni" "', argument " "3"" of type '" "Hex::Vector *""'");
29571   }
29572   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29573   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29574   if (!SWIG_IsOK(res4)) {
29575     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphericalUni" "', argument " "4"" of type '" "Hex::Vector *""'");
29576   }
29577   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29578   ecode5 = SWIG_AsVal_double(obj4, &val5);
29579   if (!SWIG_IsOK(ecode5)) {
29580     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphericalUni" "', argument " "5"" of type '" "double""'");
29581   }
29582   arg5 = static_cast< double >(val5);
29583   ecode6 = SWIG_AsVal_int(obj5, &val6);
29584   if (!SWIG_IsOK(ecode6)) {
29585     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphericalUni" "', argument " "6"" of type '" "int""'");
29586   }
29587   arg6 = static_cast< int >(val6);
29588   result = (Hex::Elements *)(arg1)->makeSphericalUni(arg2,arg3,arg4,arg5,arg6);
29589   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29590   return resultobj;
29591 fail:
29592   return NULL;
29593 }
29594
29595
29596 SWIGINTERN PyObject *_wrap_Document_makeSphericalUni(PyObject *self, PyObject *args) {
29597   Py_ssize_t argc;
29598   PyObject *argv[8] = {
29599     0
29600   };
29601   Py_ssize_t ii;
29602
29603   if (!PyTuple_Check(args)) SWIG_fail;
29604   argc = args ? PyObject_Length(args) : 0;
29605   for (ii = 0; (ii < 7) && (ii < argc); ii++) {
29606     argv[ii] = PyTuple_GET_ITEM(args,ii);
29607   }
29608   if (argc == 6) {
29609     int _v;
29610     void *vptr = 0;
29611     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29612     _v = SWIG_CheckState(res);
29613     if (_v) {
29614       void *vptr = 0;
29615       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
29616       _v = SWIG_CheckState(res);
29617       if (_v) {
29618         void *vptr = 0;
29619         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29620         _v = SWIG_CheckState(res);
29621         if (_v) {
29622           void *vptr = 0;
29623           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29624           _v = SWIG_CheckState(res);
29625           if (_v) {
29626             {
29627               int res = SWIG_AsVal_double(argv[4], NULL);
29628               _v = SWIG_CheckState(res);
29629             }
29630             if (_v) {
29631               {
29632                 int res = SWIG_AsVal_int(argv[5], NULL);
29633                 _v = SWIG_CheckState(res);
29634               }
29635               if (_v) {
29636                 return _wrap_Document_makeSphericalUni__SWIG_1(self, args);
29637               }
29638             }
29639           }
29640         }
29641       }
29642     }
29643   }
29644   if (argc == 7) {
29645     int _v;
29646     void *vptr = 0;
29647     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29648     _v = SWIG_CheckState(res);
29649     if (_v) {
29650       void *vptr = 0;
29651       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
29652       _v = SWIG_CheckState(res);
29653       if (_v) {
29654         void *vptr = 0;
29655         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29656         _v = SWIG_CheckState(res);
29657         if (_v) {
29658           void *vptr = 0;
29659           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29660           _v = SWIG_CheckState(res);
29661           if (_v) {
29662             {
29663               int res = SWIG_AsVal_double(argv[4], NULL);
29664               _v = SWIG_CheckState(res);
29665             }
29666             if (_v) {
29667               {
29668                 int res = SWIG_AsVal_int(argv[5], NULL);
29669                 _v = SWIG_CheckState(res);
29670               }
29671               if (_v) {
29672                 {
29673                   int res = SWIG_AsVal_int(argv[6], NULL);
29674                   _v = SWIG_CheckState(res);
29675                 }
29676                 if (_v) {
29677                   return _wrap_Document_makeSphericalUni__SWIG_0(self, args);
29678                 }
29679               }
29680             }
29681           }
29682         }
29683       }
29684     }
29685   }
29686
29687 fail:
29688   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_makeSphericalUni'.\n"
29689     "  Possible C/C++ prototypes are:\n"
29690     "    Hex::Document::makeSphericalUni(Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int,int)\n"
29691     "    Hex::Document::makeSphericalUni(Hex::Vertex *,Hex::Vector *,Hex::Vector *,double,int)\n");
29692   return 0;
29693 }
29694
29695
29696 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29697   PyObject *resultobj = 0;
29698   Hex::Document *arg1 = (Hex::Document *) 0 ;
29699   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29700   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29701   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29702   Hex::RealVector arg5 ;
29703   int arg6 ;
29704   void *argp1 = 0 ;
29705   int res1 = 0 ;
29706   void *argp2 = 0 ;
29707   int res2 = 0 ;
29708   void *argp3 = 0 ;
29709   int res3 = 0 ;
29710   void *argp4 = 0 ;
29711   int res4 = 0 ;
29712   int val6 ;
29713   int ecode6 = 0 ;
29714   PyObject * obj0 = 0 ;
29715   PyObject * obj1 = 0 ;
29716   PyObject * obj2 = 0 ;
29717   PyObject * obj3 = 0 ;
29718   PyObject * obj4 = 0 ;
29719   PyObject * obj5 = 0 ;
29720   Hex::Elements *result = 0 ;
29721
29722   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29723   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29724   if (!SWIG_IsOK(res1)) {
29725     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
29726   }
29727   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29728   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29729   if (!SWIG_IsOK(res2)) {
29730     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
29731   }
29732   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29733   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29734   if (!SWIG_IsOK(res3)) {
29735     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
29736   }
29737   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29738   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29739   if (!SWIG_IsOK(res4)) {
29740     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
29741   }
29742   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29743   {
29744     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29745     int res = swig::asptr(obj4, &ptr);
29746     if (!SWIG_IsOK(res) || !ptr) {
29747       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
29748     }
29749     arg5 = *ptr;
29750     if (SWIG_IsNewObj(res)) delete ptr;
29751   }
29752   ecode6 = SWIG_AsVal_int(obj5, &val6);
29753   if (!SWIG_IsOK(ecode6)) {
29754     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSpherical" "', argument " "6"" of type '" "int""'");
29755   }
29756   arg6 = static_cast< int >(val6);
29757   result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5,arg6);
29758   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29759   return resultobj;
29760 fail:
29761   return NULL;
29762 }
29763
29764
29765 SWIGINTERN PyObject *_wrap_Document_makeSpherical__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29766   PyObject *resultobj = 0;
29767   Hex::Document *arg1 = (Hex::Document *) 0 ;
29768   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29769   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29770   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29771   Hex::RealVector arg5 ;
29772   void *argp1 = 0 ;
29773   int res1 = 0 ;
29774   void *argp2 = 0 ;
29775   int res2 = 0 ;
29776   void *argp3 = 0 ;
29777   int res3 = 0 ;
29778   void *argp4 = 0 ;
29779   int res4 = 0 ;
29780   PyObject * obj0 = 0 ;
29781   PyObject * obj1 = 0 ;
29782   PyObject * obj2 = 0 ;
29783   PyObject * obj3 = 0 ;
29784   PyObject * obj4 = 0 ;
29785   Hex::Elements *result = 0 ;
29786
29787   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_makeSpherical",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29788   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29789   if (!SWIG_IsOK(res1)) {
29790     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSpherical" "', argument " "1"" of type '" "Hex::Document *""'");
29791   }
29792   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29793   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
29794   if (!SWIG_IsOK(res2)) {
29795     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSpherical" "', argument " "2"" of type '" "Hex::Vertex *""'");
29796   }
29797   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
29798   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29799   if (!SWIG_IsOK(res3)) {
29800     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSpherical" "', argument " "3"" of type '" "Hex::Vector *""'");
29801   }
29802   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
29803   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
29804   if (!SWIG_IsOK(res4)) {
29805     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSpherical" "', argument " "4"" of type '" "Hex::Vector *""'");
29806   }
29807   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
29808   {
29809     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
29810     int res = swig::asptr(obj4, &ptr);
29811     if (!SWIG_IsOK(res) || !ptr) {
29812       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSpherical" "', argument " "5"" of type '" "Hex::RealVector""'");
29813     }
29814     arg5 = *ptr;
29815     if (SWIG_IsNewObj(res)) delete ptr;
29816   }
29817   result = (Hex::Elements *)(arg1)->makeSpherical(arg2,arg3,arg4,arg5);
29818   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29819   return resultobj;
29820 fail:
29821   return NULL;
29822 }
29823
29824
29825 SWIGINTERN PyObject *_wrap_Document_makeSpherical(PyObject *self, PyObject *args) {
29826   Py_ssize_t argc;
29827   PyObject *argv[7] = {
29828     0
29829   };
29830   Py_ssize_t ii;
29831
29832   if (!PyTuple_Check(args)) SWIG_fail;
29833   argc = args ? PyObject_Length(args) : 0;
29834   for (ii = 0; (ii < 6) && (ii < argc); ii++) {
29835     argv[ii] = PyTuple_GET_ITEM(args,ii);
29836   }
29837   if (argc == 5) {
29838     int _v;
29839     void *vptr = 0;
29840     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29841     _v = SWIG_CheckState(res);
29842     if (_v) {
29843       void *vptr = 0;
29844       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
29845       _v = SWIG_CheckState(res);
29846       if (_v) {
29847         void *vptr = 0;
29848         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29849         _v = SWIG_CheckState(res);
29850         if (_v) {
29851           void *vptr = 0;
29852           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29853           _v = SWIG_CheckState(res);
29854           if (_v) {
29855             int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
29856             _v = SWIG_CheckState(res);
29857             if (_v) {
29858               return _wrap_Document_makeSpherical__SWIG_1(self, args);
29859             }
29860           }
29861         }
29862       }
29863     }
29864   }
29865   if (argc == 6) {
29866     int _v;
29867     void *vptr = 0;
29868     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
29869     _v = SWIG_CheckState(res);
29870     if (_v) {
29871       void *vptr = 0;
29872       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Vertex, 0);
29873       _v = SWIG_CheckState(res);
29874       if (_v) {
29875         void *vptr = 0;
29876         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29877         _v = SWIG_CheckState(res);
29878         if (_v) {
29879           void *vptr = 0;
29880           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Hex__Vector, 0);
29881           _v = SWIG_CheckState(res);
29882           if (_v) {
29883             int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
29884             _v = SWIG_CheckState(res);
29885             if (_v) {
29886               {
29887                 int res = SWIG_AsVal_int(argv[5], NULL);
29888                 _v = SWIG_CheckState(res);
29889               }
29890               if (_v) {
29891                 return _wrap_Document_makeSpherical__SWIG_0(self, args);
29892               }
29893             }
29894           }
29895         }
29896       }
29897     }
29898   }
29899
29900 fail:
29901   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_makeSpherical'.\n"
29902     "  Possible C/C++ prototypes are:\n"
29903     "    Hex::Document::makeSpherical(Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector,int)\n"
29904     "    Hex::Document::makeSpherical(Hex::Vertex *,Hex::Vector *,Hex::Vector *,Hex::RealVector)\n");
29905   return 0;
29906 }
29907
29908
29909 SWIGINTERN PyObject *_wrap_Document_makeSphereTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29910   PyObject *resultobj = 0;
29911   Hex::Document *arg1 = (Hex::Document *) 0 ;
29912   int arg2 ;
29913   int arg3 ;
29914   int arg4 ;
29915   void *argp1 = 0 ;
29916   int res1 = 0 ;
29917   int val2 ;
29918   int ecode2 = 0 ;
29919   int val3 ;
29920   int ecode3 = 0 ;
29921   int val4 ;
29922   int ecode4 = 0 ;
29923   PyObject * obj0 = 0 ;
29924   PyObject * obj1 = 0 ;
29925   PyObject * obj2 = 0 ;
29926   PyObject * obj3 = 0 ;
29927   Hex::Elements *result = 0 ;
29928
29929   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeSphereTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29930   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
29931   if (!SWIG_IsOK(res1)) {
29932     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereTop" "', argument " "1"" of type '" "Hex::Document *""'");
29933   }
29934   arg1 = reinterpret_cast< Hex::Document * >(argp1);
29935   ecode2 = SWIG_AsVal_int(obj1, &val2);
29936   if (!SWIG_IsOK(ecode2)) {
29937     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeSphereTop" "', argument " "2"" of type '" "int""'");
29938   }
29939   arg2 = static_cast< int >(val2);
29940   ecode3 = SWIG_AsVal_int(obj2, &val3);
29941   if (!SWIG_IsOK(ecode3)) {
29942     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeSphereTop" "', argument " "3"" of type '" "int""'");
29943   }
29944   arg3 = static_cast< int >(val3);
29945   ecode4 = SWIG_AsVal_int(obj3, &val4);
29946   if (!SWIG_IsOK(ecode4)) {
29947     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeSphereTop" "', argument " "4"" of type '" "int""'");
29948   }
29949   arg4 = static_cast< int >(val4);
29950   result = (Hex::Elements *)(arg1)->makeSphereTop(arg2,arg3,arg4);
29951   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
29952   return resultobj;
29953 fail:
29954   return NULL;
29955 }
29956
29957
29958 SWIGINTERN PyObject *_wrap_Document_makeSphereUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29959   PyObject *resultobj = 0;
29960   Hex::Document *arg1 = (Hex::Document *) 0 ;
29961   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
29962   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
29963   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
29964   double arg5 ;
29965   double arg6 ;
29966   double arg7 ;
29967   Hex::Vertex *arg8 = (Hex::Vertex *) 0 ;
29968   int arg9 ;
29969   int arg10 ;
29970   int arg11 ;
29971   void *argp1 = 0 ;
29972   int res1 = 0 ;
29973   void *argp2 = 0 ;
29974   int res2 = 0 ;
29975   void *argp3 = 0 ;
29976   int res3 = 0 ;
29977   void *argp4 = 0 ;
29978   int res4 = 0 ;
29979   double val5 ;
29980   int ecode5 = 0 ;
29981   double val6 ;
29982   int ecode6 = 0 ;
29983   double val7 ;
29984   int ecode7 = 0 ;
29985   void *argp8 = 0 ;
29986   int res8 = 0 ;
29987   int val9 ;
29988   int ecode9 = 0 ;
29989   int val10 ;
29990   int ecode10 = 0 ;
29991   int val11 ;
29992   int ecode11 = 0 ;
29993   PyObject * obj0 = 0 ;
29994   PyObject * obj1 = 0 ;
29995   PyObject * obj2 = 0 ;
29996   PyObject * obj3 = 0 ;
29997   PyObject * obj4 = 0 ;
29998   PyObject * obj5 = 0 ;
29999   PyObject * obj6 = 0 ;
30000   PyObject * obj7 = 0 ;
30001   PyObject * obj8 = 0 ;
30002   PyObject * obj9 = 0 ;
30003   PyObject * obj10 = 0 ;
30004   Hex::Elements *result = 0 ;
30005
30006   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makeSphereUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
30007   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30008   if (!SWIG_IsOK(res1)) {
30009     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphereUni" "', argument " "1"" of type '" "Hex::Document *""'");
30010   }
30011   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30012   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30013   if (!SWIG_IsOK(res2)) {
30014     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphereUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
30015   }
30016   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30017   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30018   if (!SWIG_IsOK(res3)) {
30019     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphereUni" "', argument " "3"" of type '" "Hex::Vector *""'");
30020   }
30021   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30022   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30023   if (!SWIG_IsOK(res4)) {
30024     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphereUni" "', argument " "4"" of type '" "Hex::Vector *""'");
30025   }
30026   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
30027   ecode5 = SWIG_AsVal_double(obj4, &val5);
30028   if (!SWIG_IsOK(ecode5)) {
30029     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeSphereUni" "', argument " "5"" of type '" "double""'");
30030   }
30031   arg5 = static_cast< double >(val5);
30032   ecode6 = SWIG_AsVal_double(obj5, &val6);
30033   if (!SWIG_IsOK(ecode6)) {
30034     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeSphereUni" "', argument " "6"" of type '" "double""'");
30035   }
30036   arg6 = static_cast< double >(val6);
30037   ecode7 = SWIG_AsVal_double(obj6, &val7);
30038   if (!SWIG_IsOK(ecode7)) {
30039     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeSphereUni" "', argument " "7"" of type '" "double""'");
30040   }
30041   arg7 = static_cast< double >(val7);
30042   res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30043   if (!SWIG_IsOK(res8)) {
30044     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makeSphereUni" "', argument " "8"" of type '" "Hex::Vertex *""'");
30045   }
30046   arg8 = reinterpret_cast< Hex::Vertex * >(argp8);
30047   ecode9 = SWIG_AsVal_int(obj8, &val9);
30048   if (!SWIG_IsOK(ecode9)) {
30049     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeSphereUni" "', argument " "9"" of type '" "int""'");
30050   }
30051   arg9 = static_cast< int >(val9);
30052   ecode10 = SWIG_AsVal_int(obj9, &val10);
30053   if (!SWIG_IsOK(ecode10)) {
30054     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeSphereUni" "', argument " "10"" of type '" "int""'");
30055   }
30056   arg10 = static_cast< int >(val10);
30057   ecode11 = SWIG_AsVal_int(obj10, &val11);
30058   if (!SWIG_IsOK(ecode11)) {
30059     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeSphereUni" "', argument " "11"" of type '" "int""'");
30060   }
30061   arg11 = static_cast< int >(val11);
30062   result = (Hex::Elements *)(arg1)->makeSphereUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
30063   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30064   return resultobj;
30065 fail:
30066   return NULL;
30067 }
30068
30069
30070 SWIGINTERN PyObject *_wrap_Document_makeSphere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30071   PyObject *resultobj = 0;
30072   Hex::Document *arg1 = (Hex::Document *) 0 ;
30073   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30074   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30075   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
30076   Hex::RealVector arg5 ;
30077   Hex::RealVector arg6 ;
30078   Hex::RealVector arg7 ;
30079   void *argp1 = 0 ;
30080   int res1 = 0 ;
30081   void *argp2 = 0 ;
30082   int res2 = 0 ;
30083   void *argp3 = 0 ;
30084   int res3 = 0 ;
30085   void *argp4 = 0 ;
30086   int res4 = 0 ;
30087   PyObject * obj0 = 0 ;
30088   PyObject * obj1 = 0 ;
30089   PyObject * obj2 = 0 ;
30090   PyObject * obj3 = 0 ;
30091   PyObject * obj4 = 0 ;
30092   PyObject * obj5 = 0 ;
30093   PyObject * obj6 = 0 ;
30094   Hex::Elements *result = 0 ;
30095
30096   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeSphere",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30097   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30098   if (!SWIG_IsOK(res1)) {
30099     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeSphere" "', argument " "1"" of type '" "Hex::Document *""'");
30100   }
30101   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30102   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30103   if (!SWIG_IsOK(res2)) {
30104     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeSphere" "', argument " "2"" of type '" "Hex::Vertex *""'");
30105   }
30106   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30107   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30108   if (!SWIG_IsOK(res3)) {
30109     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeSphere" "', argument " "3"" of type '" "Hex::Vector *""'");
30110   }
30111   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30112   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30113   if (!SWIG_IsOK(res4)) {
30114     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeSphere" "', argument " "4"" of type '" "Hex::Vector *""'");
30115   }
30116   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
30117   {
30118     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30119     int res = swig::asptr(obj4, &ptr);
30120     if (!SWIG_IsOK(res) || !ptr) {
30121       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "5"" of type '" "Hex::RealVector""'");
30122     }
30123     arg5 = *ptr;
30124     if (SWIG_IsNewObj(res)) delete ptr;
30125   }
30126   {
30127     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30128     int res = swig::asptr(obj5, &ptr);
30129     if (!SWIG_IsOK(res) || !ptr) {
30130       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "6"" of type '" "Hex::RealVector""'");
30131     }
30132     arg6 = *ptr;
30133     if (SWIG_IsNewObj(res)) delete ptr;
30134   }
30135   {
30136     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30137     int res = swig::asptr(obj6, &ptr);
30138     if (!SWIG_IsOK(res) || !ptr) {
30139       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeSphere" "', argument " "7"" of type '" "Hex::RealVector""'");
30140     }
30141     arg7 = *ptr;
30142     if (SWIG_IsNewObj(res)) delete ptr;
30143   }
30144   result = (Hex::Elements *)(arg1)->makeSphere(arg2,arg3,arg4,arg5,arg6,arg7);
30145   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30146   return resultobj;
30147 fail:
30148   return NULL;
30149 }
30150
30151
30152 SWIGINTERN PyObject *_wrap_Document_makeRindTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30153   PyObject *resultobj = 0;
30154   Hex::Document *arg1 = (Hex::Document *) 0 ;
30155   int arg2 ;
30156   int arg3 ;
30157   int arg4 ;
30158   void *argp1 = 0 ;
30159   int res1 = 0 ;
30160   int val2 ;
30161   int ecode2 = 0 ;
30162   int val3 ;
30163   int ecode3 = 0 ;
30164   int val4 ;
30165   int ecode4 = 0 ;
30166   PyObject * obj0 = 0 ;
30167   PyObject * obj1 = 0 ;
30168   PyObject * obj2 = 0 ;
30169   PyObject * obj3 = 0 ;
30170   Hex::Elements *result = 0 ;
30171
30172   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_makeRindTop",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30173   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30174   if (!SWIG_IsOK(res1)) {
30175     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindTop" "', argument " "1"" of type '" "Hex::Document *""'");
30176   }
30177   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30178   ecode2 = SWIG_AsVal_int(obj1, &val2);
30179   if (!SWIG_IsOK(ecode2)) {
30180     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_makeRindTop" "', argument " "2"" of type '" "int""'");
30181   }
30182   arg2 = static_cast< int >(val2);
30183   ecode3 = SWIG_AsVal_int(obj2, &val3);
30184   if (!SWIG_IsOK(ecode3)) {
30185     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_makeRindTop" "', argument " "3"" of type '" "int""'");
30186   }
30187   arg3 = static_cast< int >(val3);
30188   ecode4 = SWIG_AsVal_int(obj3, &val4);
30189   if (!SWIG_IsOK(ecode4)) {
30190     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeRindTop" "', argument " "4"" of type '" "int""'");
30191   }
30192   arg4 = static_cast< int >(val4);
30193   result = (Hex::Elements *)(arg1)->makeRindTop(arg2,arg3,arg4);
30194   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30195   return resultobj;
30196 fail:
30197   return NULL;
30198 }
30199
30200
30201 SWIGINTERN PyObject *_wrap_Document_makeRindUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30202   PyObject *resultobj = 0;
30203   Hex::Document *arg1 = (Hex::Document *) 0 ;
30204   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30205   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30206   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
30207   double arg5 ;
30208   double arg6 ;
30209   double arg7 ;
30210   double arg8 ;
30211   Hex::Vertex *arg9 = (Hex::Vertex *) 0 ;
30212   int arg10 ;
30213   int arg11 ;
30214   int arg12 ;
30215   void *argp1 = 0 ;
30216   int res1 = 0 ;
30217   void *argp2 = 0 ;
30218   int res2 = 0 ;
30219   void *argp3 = 0 ;
30220   int res3 = 0 ;
30221   void *argp4 = 0 ;
30222   int res4 = 0 ;
30223   double val5 ;
30224   int ecode5 = 0 ;
30225   double val6 ;
30226   int ecode6 = 0 ;
30227   double val7 ;
30228   int ecode7 = 0 ;
30229   double val8 ;
30230   int ecode8 = 0 ;
30231   void *argp9 = 0 ;
30232   int res9 = 0 ;
30233   int val10 ;
30234   int ecode10 = 0 ;
30235   int val11 ;
30236   int ecode11 = 0 ;
30237   int val12 ;
30238   int ecode12 = 0 ;
30239   PyObject * obj0 = 0 ;
30240   PyObject * obj1 = 0 ;
30241   PyObject * obj2 = 0 ;
30242   PyObject * obj3 = 0 ;
30243   PyObject * obj4 = 0 ;
30244   PyObject * obj5 = 0 ;
30245   PyObject * obj6 = 0 ;
30246   PyObject * obj7 = 0 ;
30247   PyObject * obj8 = 0 ;
30248   PyObject * obj9 = 0 ;
30249   PyObject * obj10 = 0 ;
30250   PyObject * obj11 = 0 ;
30251   Hex::Elements *result = 0 ;
30252
30253   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Document_makeRindUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
30254   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30255   if (!SWIG_IsOK(res1)) {
30256     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRindUni" "', argument " "1"" of type '" "Hex::Document *""'");
30257   }
30258   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30259   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30260   if (!SWIG_IsOK(res2)) {
30261     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRindUni" "', argument " "2"" of type '" "Hex::Vertex *""'");
30262   }
30263   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30264   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30265   if (!SWIG_IsOK(res3)) {
30266     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRindUni" "', argument " "3"" of type '" "Hex::Vector *""'");
30267   }
30268   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30269   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30270   if (!SWIG_IsOK(res4)) {
30271     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRindUni" "', argument " "4"" of type '" "Hex::Vector *""'");
30272   }
30273   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
30274   ecode5 = SWIG_AsVal_double(obj4, &val5);
30275   if (!SWIG_IsOK(ecode5)) {
30276     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeRindUni" "', argument " "5"" of type '" "double""'");
30277   }
30278   arg5 = static_cast< double >(val5);
30279   ecode6 = SWIG_AsVal_double(obj5, &val6);
30280   if (!SWIG_IsOK(ecode6)) {
30281     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makeRindUni" "', argument " "6"" of type '" "double""'");
30282   }
30283   arg6 = static_cast< double >(val6);
30284   ecode7 = SWIG_AsVal_double(obj6, &val7);
30285   if (!SWIG_IsOK(ecode7)) {
30286     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Document_makeRindUni" "', argument " "7"" of type '" "double""'");
30287   }
30288   arg7 = static_cast< double >(val7);
30289   ecode8 = SWIG_AsVal_double(obj7, &val8);
30290   if (!SWIG_IsOK(ecode8)) {
30291     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeRindUni" "', argument " "8"" of type '" "double""'");
30292   }
30293   arg8 = static_cast< double >(val8);
30294   res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30295   if (!SWIG_IsOK(res9)) {
30296     SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "Document_makeRindUni" "', argument " "9"" of type '" "Hex::Vertex *""'");
30297   }
30298   arg9 = reinterpret_cast< Hex::Vertex * >(argp9);
30299   ecode10 = SWIG_AsVal_int(obj9, &val10);
30300   if (!SWIG_IsOK(ecode10)) {
30301     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makeRindUni" "', argument " "10"" of type '" "int""'");
30302   }
30303   arg10 = static_cast< int >(val10);
30304   ecode11 = SWIG_AsVal_int(obj10, &val11);
30305   if (!SWIG_IsOK(ecode11)) {
30306     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makeRindUni" "', argument " "11"" of type '" "int""'");
30307   }
30308   arg11 = static_cast< int >(val11);
30309   ecode12 = SWIG_AsVal_int(obj11, &val12);
30310   if (!SWIG_IsOK(ecode12)) {
30311     SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Document_makeRindUni" "', argument " "12"" of type '" "int""'");
30312   }
30313   arg12 = static_cast< int >(val12);
30314   result = (Hex::Elements *)(arg1)->makeRindUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
30315   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30316   return resultobj;
30317 fail:
30318   return NULL;
30319 }
30320
30321
30322 SWIGINTERN PyObject *_wrap_Document_makeRind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30323   PyObject *resultobj = 0;
30324   Hex::Document *arg1 = (Hex::Document *) 0 ;
30325   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30326   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30327   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
30328   Hex::RealVector arg5 ;
30329   Hex::RealVector arg6 ;
30330   Hex::RealVector arg7 ;
30331   void *argp1 = 0 ;
30332   int res1 = 0 ;
30333   void *argp2 = 0 ;
30334   int res2 = 0 ;
30335   void *argp3 = 0 ;
30336   int res3 = 0 ;
30337   void *argp4 = 0 ;
30338   int res4 = 0 ;
30339   PyObject * obj0 = 0 ;
30340   PyObject * obj1 = 0 ;
30341   PyObject * obj2 = 0 ;
30342   PyObject * obj3 = 0 ;
30343   PyObject * obj4 = 0 ;
30344   PyObject * obj5 = 0 ;
30345   PyObject * obj6 = 0 ;
30346   Hex::Elements *result = 0 ;
30347
30348   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Document_makeRind",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30349   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30350   if (!SWIG_IsOK(res1)) {
30351     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeRind" "', argument " "1"" of type '" "Hex::Document *""'");
30352   }
30353   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30354   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30355   if (!SWIG_IsOK(res2)) {
30356     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeRind" "', argument " "2"" of type '" "Hex::Vertex *""'");
30357   }
30358   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30359   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30360   if (!SWIG_IsOK(res3)) {
30361     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeRind" "', argument " "3"" of type '" "Hex::Vector *""'");
30362   }
30363   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30364   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30365   if (!SWIG_IsOK(res4)) {
30366     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_makeRind" "', argument " "4"" of type '" "Hex::Vector *""'");
30367   }
30368   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
30369   {
30370     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30371     int res = swig::asptr(obj4, &ptr);
30372     if (!SWIG_IsOK(res) || !ptr) {
30373       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "5"" of type '" "Hex::RealVector""'");
30374     }
30375     arg5 = *ptr;
30376     if (SWIG_IsNewObj(res)) delete ptr;
30377   }
30378   {
30379     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30380     int res = swig::asptr(obj5, &ptr);
30381     if (!SWIG_IsOK(res) || !ptr) {
30382       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "6"" of type '" "Hex::RealVector""'");
30383     }
30384     arg6 = *ptr;
30385     if (SWIG_IsNewObj(res)) delete ptr;
30386   }
30387   {
30388     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30389     int res = swig::asptr(obj6, &ptr);
30390     if (!SWIG_IsOK(res) || !ptr) {
30391       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_makeRind" "', argument " "7"" of type '" "Hex::RealVector""'");
30392     }
30393     arg7 = *ptr;
30394     if (SWIG_IsNewObj(res)) delete ptr;
30395   }
30396   result = (Hex::Elements *)(arg1)->makeRind(arg2,arg3,arg4,arg5,arg6,arg7);
30397   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30398   return resultobj;
30399 fail:
30400   return NULL;
30401 }
30402
30403
30404 SWIGINTERN PyObject *_wrap_Document_makeCylinders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30405   PyObject *resultobj = 0;
30406   Hex::Document *arg1 = (Hex::Document *) 0 ;
30407   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30408   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30409   double arg4 ;
30410   double arg5 ;
30411   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
30412   Hex::Vector *arg7 = (Hex::Vector *) 0 ;
30413   double arg8 ;
30414   double arg9 ;
30415   void *argp1 = 0 ;
30416   int res1 = 0 ;
30417   void *argp2 = 0 ;
30418   int res2 = 0 ;
30419   void *argp3 = 0 ;
30420   int res3 = 0 ;
30421   double val4 ;
30422   int ecode4 = 0 ;
30423   double val5 ;
30424   int ecode5 = 0 ;
30425   void *argp6 = 0 ;
30426   int res6 = 0 ;
30427   void *argp7 = 0 ;
30428   int res7 = 0 ;
30429   double val8 ;
30430   int ecode8 = 0 ;
30431   double val9 ;
30432   int ecode9 = 0 ;
30433   PyObject * obj0 = 0 ;
30434   PyObject * obj1 = 0 ;
30435   PyObject * obj2 = 0 ;
30436   PyObject * obj3 = 0 ;
30437   PyObject * obj4 = 0 ;
30438   PyObject * obj5 = 0 ;
30439   PyObject * obj6 = 0 ;
30440   PyObject * obj7 = 0 ;
30441   PyObject * obj8 = 0 ;
30442   Hex::BiCylinder *result = 0 ;
30443
30444   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Document_makeCylinders",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
30445   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30446   if (!SWIG_IsOK(res1)) {
30447     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makeCylinders" "', argument " "1"" of type '" "Hex::Document *""'");
30448   }
30449   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30450   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30451   if (!SWIG_IsOK(res2)) {
30452     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makeCylinders" "', argument " "2"" of type '" "Hex::Vertex *""'");
30453   }
30454   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30455   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30456   if (!SWIG_IsOK(res3)) {
30457     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makeCylinders" "', argument " "3"" of type '" "Hex::Vector *""'");
30458   }
30459   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30460   ecode4 = SWIG_AsVal_double(obj3, &val4);
30461   if (!SWIG_IsOK(ecode4)) {
30462     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makeCylinders" "', argument " "4"" of type '" "double""'");
30463   }
30464   arg4 = static_cast< double >(val4);
30465   ecode5 = SWIG_AsVal_double(obj4, &val5);
30466   if (!SWIG_IsOK(ecode5)) {
30467     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makeCylinders" "', argument " "5"" of type '" "double""'");
30468   }
30469   arg5 = static_cast< double >(val5);
30470   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30471   if (!SWIG_IsOK(res6)) {
30472     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_makeCylinders" "', argument " "6"" of type '" "Hex::Vertex *""'");
30473   }
30474   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
30475   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30476   if (!SWIG_IsOK(res7)) {
30477     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makeCylinders" "', argument " "7"" of type '" "Hex::Vector *""'");
30478   }
30479   arg7 = reinterpret_cast< Hex::Vector * >(argp7);
30480   ecode8 = SWIG_AsVal_double(obj7, &val8);
30481   if (!SWIG_IsOK(ecode8)) {
30482     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_makeCylinders" "', argument " "8"" of type '" "double""'");
30483   }
30484   arg8 = static_cast< double >(val8);
30485   ecode9 = SWIG_AsVal_double(obj8, &val9);
30486   if (!SWIG_IsOK(ecode9)) {
30487     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makeCylinders" "', argument " "9"" of type '" "double""'");
30488   }
30489   arg9 = static_cast< double >(val9);
30490   result = (Hex::BiCylinder *)(arg1)->makeCylinders(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
30491   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30492   return resultobj;
30493 fail:
30494   return NULL;
30495 }
30496
30497
30498 SWIGINTERN PyObject *_wrap_Document_makePipes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30499   PyObject *resultobj = 0;
30500   Hex::Document *arg1 = (Hex::Document *) 0 ;
30501   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
30502   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30503   double arg4 ;
30504   double arg5 ;
30505   double arg6 ;
30506   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
30507   Hex::Vector *arg8 = (Hex::Vector *) 0 ;
30508   double arg9 ;
30509   double arg10 ;
30510   double arg11 ;
30511   void *argp1 = 0 ;
30512   int res1 = 0 ;
30513   void *argp2 = 0 ;
30514   int res2 = 0 ;
30515   void *argp3 = 0 ;
30516   int res3 = 0 ;
30517   double val4 ;
30518   int ecode4 = 0 ;
30519   double val5 ;
30520   int ecode5 = 0 ;
30521   double val6 ;
30522   int ecode6 = 0 ;
30523   void *argp7 = 0 ;
30524   int res7 = 0 ;
30525   void *argp8 = 0 ;
30526   int res8 = 0 ;
30527   double val9 ;
30528   int ecode9 = 0 ;
30529   double val10 ;
30530   int ecode10 = 0 ;
30531   double val11 ;
30532   int ecode11 = 0 ;
30533   PyObject * obj0 = 0 ;
30534   PyObject * obj1 = 0 ;
30535   PyObject * obj2 = 0 ;
30536   PyObject * obj3 = 0 ;
30537   PyObject * obj4 = 0 ;
30538   PyObject * obj5 = 0 ;
30539   PyObject * obj6 = 0 ;
30540   PyObject * obj7 = 0 ;
30541   PyObject * obj8 = 0 ;
30542   PyObject * obj9 = 0 ;
30543   PyObject * obj10 = 0 ;
30544   Hex::BiCylinder *result = 0 ;
30545
30546   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOO:Document_makePipes",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10)) SWIG_fail;
30547   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30548   if (!SWIG_IsOK(res1)) {
30549     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_makePipes" "', argument " "1"" of type '" "Hex::Document *""'");
30550   }
30551   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30552   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30553   if (!SWIG_IsOK(res2)) {
30554     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_makePipes" "', argument " "2"" of type '" "Hex::Vertex *""'");
30555   }
30556   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
30557   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30558   if (!SWIG_IsOK(res3)) {
30559     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_makePipes" "', argument " "3"" of type '" "Hex::Vector *""'");
30560   }
30561   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30562   ecode4 = SWIG_AsVal_double(obj3, &val4);
30563   if (!SWIG_IsOK(ecode4)) {
30564     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_makePipes" "', argument " "4"" of type '" "double""'");
30565   }
30566   arg4 = static_cast< double >(val4);
30567   ecode5 = SWIG_AsVal_double(obj4, &val5);
30568   if (!SWIG_IsOK(ecode5)) {
30569     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_makePipes" "', argument " "5"" of type '" "double""'");
30570   }
30571   arg5 = static_cast< double >(val5);
30572   ecode6 = SWIG_AsVal_double(obj5, &val6);
30573   if (!SWIG_IsOK(ecode6)) {
30574     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_makePipes" "', argument " "6"" of type '" "double""'");
30575   }
30576   arg6 = static_cast< double >(val6);
30577   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30578   if (!SWIG_IsOK(res7)) {
30579     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_makePipes" "', argument " "7"" of type '" "Hex::Vertex *""'");
30580   }
30581   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
30582   res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30583   if (!SWIG_IsOK(res8)) {
30584     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_makePipes" "', argument " "8"" of type '" "Hex::Vector *""'");
30585   }
30586   arg8 = reinterpret_cast< Hex::Vector * >(argp8);
30587   ecode9 = SWIG_AsVal_double(obj8, &val9);
30588   if (!SWIG_IsOK(ecode9)) {
30589     SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Document_makePipes" "', argument " "9"" of type '" "double""'");
30590   }
30591   arg9 = static_cast< double >(val9);
30592   ecode10 = SWIG_AsVal_double(obj9, &val10);
30593   if (!SWIG_IsOK(ecode10)) {
30594     SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Document_makePipes" "', argument " "10"" of type '" "double""'");
30595   }
30596   arg10 = static_cast< double >(val10);
30597   ecode11 = SWIG_AsVal_double(obj10, &val11);
30598   if (!SWIG_IsOK(ecode11)) {
30599     SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Document_makePipes" "', argument " "11"" of type '" "double""'");
30600   }
30601   arg11 = static_cast< double >(val11);
30602   result = (Hex::BiCylinder *)(arg1)->makePipes(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
30603   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
30604   return resultobj;
30605 fail:
30606   return NULL;
30607 }
30608
30609
30610 SWIGINTERN PyObject *_wrap_Document_extrudeQuadTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30611   PyObject *resultobj = 0;
30612   Hex::Document *arg1 = (Hex::Document *) 0 ;
30613   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
30614   int arg3 ;
30615   void *argp1 = 0 ;
30616   int res1 = 0 ;
30617   void *argp2 = 0 ;
30618   int res2 = 0 ;
30619   int val3 ;
30620   int ecode3 = 0 ;
30621   PyObject * obj0 = 0 ;
30622   PyObject * obj1 = 0 ;
30623   PyObject * obj2 = 0 ;
30624   Hex::Elements *result = 0 ;
30625
30626   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadTop",&obj0,&obj1,&obj2)) SWIG_fail;
30627   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30628   if (!SWIG_IsOK(res1)) {
30629     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadTop" "', argument " "1"" of type '" "Hex::Document *""'");
30630   }
30631   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30632   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
30633   if (!SWIG_IsOK(res2)) {
30634     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadTop" "', argument " "2"" of type '" "Hex::Quad *""'");
30635   }
30636   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
30637   ecode3 = SWIG_AsVal_int(obj2, &val3);
30638   if (!SWIG_IsOK(ecode3)) {
30639     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadTop" "', argument " "3"" of type '" "int""'");
30640   }
30641   arg3 = static_cast< int >(val3);
30642   result = (Hex::Elements *)(arg1)->extrudeQuadTop(arg2,arg3);
30643   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30644   return resultobj;
30645 fail:
30646   return NULL;
30647 }
30648
30649
30650 SWIGINTERN PyObject *_wrap_Document_extrudeQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30651   PyObject *resultobj = 0;
30652   Hex::Document *arg1 = (Hex::Document *) 0 ;
30653   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
30654   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30655   double arg4 ;
30656   int arg5 ;
30657   void *argp1 = 0 ;
30658   int res1 = 0 ;
30659   void *argp2 = 0 ;
30660   int res2 = 0 ;
30661   void *argp3 = 0 ;
30662   int res3 = 0 ;
30663   double val4 ;
30664   int ecode4 = 0 ;
30665   int val5 ;
30666   int ecode5 = 0 ;
30667   PyObject * obj0 = 0 ;
30668   PyObject * obj1 = 0 ;
30669   PyObject * obj2 = 0 ;
30670   PyObject * obj3 = 0 ;
30671   PyObject * obj4 = 0 ;
30672   Hex::Elements *result = 0 ;
30673
30674   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30675   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30676   if (!SWIG_IsOK(res1)) {
30677     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
30678   }
30679   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30680   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
30681   if (!SWIG_IsOK(res2)) {
30682     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
30683   }
30684   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
30685   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30686   if (!SWIG_IsOK(res3)) {
30687     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadUni" "', argument " "3"" of type '" "Hex::Vector *""'");
30688   }
30689   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30690   ecode4 = SWIG_AsVal_double(obj3, &val4);
30691   if (!SWIG_IsOK(ecode4)) {
30692     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadUni" "', argument " "4"" of type '" "double""'");
30693   }
30694   arg4 = static_cast< double >(val4);
30695   ecode5 = SWIG_AsVal_int(obj4, &val5);
30696   if (!SWIG_IsOK(ecode5)) {
30697     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadUni" "', argument " "5"" of type '" "int""'");
30698   }
30699   arg5 = static_cast< int >(val5);
30700   result = (Hex::Elements *)(arg1)->extrudeQuadUni(arg2,arg3,arg4,arg5);
30701   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30702   return resultobj;
30703 fail:
30704   return NULL;
30705 }
30706
30707
30708 SWIGINTERN PyObject *_wrap_Document_extrudeQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30709   PyObject *resultobj = 0;
30710   Hex::Document *arg1 = (Hex::Document *) 0 ;
30711   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
30712   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30713   Hex::RealVector arg4 ;
30714   void *argp1 = 0 ;
30715   int res1 = 0 ;
30716   void *argp2 = 0 ;
30717   int res2 = 0 ;
30718   void *argp3 = 0 ;
30719   int res3 = 0 ;
30720   PyObject * obj0 = 0 ;
30721   PyObject * obj1 = 0 ;
30722   PyObject * obj2 = 0 ;
30723   PyObject * obj3 = 0 ;
30724   Hex::Elements *result = 0 ;
30725
30726   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuad",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30727   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30728   if (!SWIG_IsOK(res1)) {
30729     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuad" "', argument " "1"" of type '" "Hex::Document *""'");
30730   }
30731   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30732   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
30733   if (!SWIG_IsOK(res2)) {
30734     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_extrudeQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
30735   }
30736   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
30737   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30738   if (!SWIG_IsOK(res3)) {
30739     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuad" "', argument " "3"" of type '" "Hex::Vector *""'");
30740   }
30741   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30742   {
30743     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30744     int res = swig::asptr(obj3, &ptr);
30745     if (!SWIG_IsOK(res) || !ptr) {
30746       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuad" "', argument " "4"" of type '" "Hex::RealVector""'");
30747     }
30748     arg4 = *ptr;
30749     if (SWIG_IsNewObj(res)) delete ptr;
30750   }
30751   result = (Hex::Elements *)(arg1)->extrudeQuad(arg2,arg3,arg4);
30752   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30753   return resultobj;
30754 fail:
30755   return NULL;
30756 }
30757
30758
30759 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30760   PyObject *resultobj = 0;
30761   Hex::Document *arg1 = (Hex::Document *) 0 ;
30762   Hex::Quads arg2 ;
30763   int arg3 ;
30764   void *argp1 = 0 ;
30765   int res1 = 0 ;
30766   int val3 ;
30767   int ecode3 = 0 ;
30768   PyObject * obj0 = 0 ;
30769   PyObject * obj1 = 0 ;
30770   PyObject * obj2 = 0 ;
30771   Hex::Elements *result = 0 ;
30772
30773   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_extrudeQuadsTop",&obj0,&obj1,&obj2)) SWIG_fail;
30774   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30775   if (!SWIG_IsOK(res1)) {
30776     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsTop" "', argument " "1"" of type '" "Hex::Document *""'");
30777   }
30778   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30779   {
30780     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
30781     int res = swig::asptr(obj1, &ptr);
30782     if (!SWIG_IsOK(res) || !ptr) {
30783       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsTop" "', argument " "2"" of type '" "Hex::Quads""'");
30784     }
30785     arg2 = *ptr;
30786     if (SWIG_IsNewObj(res)) delete ptr;
30787   }
30788   ecode3 = SWIG_AsVal_int(obj2, &val3);
30789   if (!SWIG_IsOK(ecode3)) {
30790     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_extrudeQuadsTop" "', argument " "3"" of type '" "int""'");
30791   }
30792   arg3 = static_cast< int >(val3);
30793   result = (Hex::Elements *)(arg1)->extrudeQuadsTop(arg2,arg3);
30794   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30795   return resultobj;
30796 fail:
30797   return NULL;
30798 }
30799
30800
30801 SWIGINTERN PyObject *_wrap_Document_extrudeQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30802   PyObject *resultobj = 0;
30803   Hex::Document *arg1 = (Hex::Document *) 0 ;
30804   Hex::Quads arg2 ;
30805   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30806   double arg4 ;
30807   int arg5 ;
30808   void *argp1 = 0 ;
30809   int res1 = 0 ;
30810   void *argp3 = 0 ;
30811   int res3 = 0 ;
30812   double val4 ;
30813   int ecode4 = 0 ;
30814   int val5 ;
30815   int ecode5 = 0 ;
30816   PyObject * obj0 = 0 ;
30817   PyObject * obj1 = 0 ;
30818   PyObject * obj2 = 0 ;
30819   PyObject * obj3 = 0 ;
30820   PyObject * obj4 = 0 ;
30821   Hex::Elements *result = 0 ;
30822
30823   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_extrudeQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30824   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30825   if (!SWIG_IsOK(res1)) {
30826     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
30827   }
30828   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30829   {
30830     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
30831     int res = swig::asptr(obj1, &ptr);
30832     if (!SWIG_IsOK(res) || !ptr) {
30833       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
30834     }
30835     arg2 = *ptr;
30836     if (SWIG_IsNewObj(res)) delete ptr;
30837   }
30838   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30839   if (!SWIG_IsOK(res3)) {
30840     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuadsUni" "', argument " "3"" of type '" "Hex::Vector *""'");
30841   }
30842   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30843   ecode4 = SWIG_AsVal_double(obj3, &val4);
30844   if (!SWIG_IsOK(ecode4)) {
30845     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Document_extrudeQuadsUni" "', argument " "4"" of type '" "double""'");
30846   }
30847   arg4 = static_cast< double >(val4);
30848   ecode5 = SWIG_AsVal_int(obj4, &val5);
30849   if (!SWIG_IsOK(ecode5)) {
30850     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_extrudeQuadsUni" "', argument " "5"" of type '" "int""'");
30851   }
30852   arg5 = static_cast< int >(val5);
30853   result = (Hex::Elements *)(arg1)->extrudeQuadsUni(arg2,arg3,arg4,arg5);
30854   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30855   return resultobj;
30856 fail:
30857   return NULL;
30858 }
30859
30860
30861 SWIGINTERN PyObject *_wrap_Document_extrudeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30862   PyObject *resultobj = 0;
30863   Hex::Document *arg1 = (Hex::Document *) 0 ;
30864   Hex::Quads arg2 ;
30865   Hex::Vector *arg3 = (Hex::Vector *) 0 ;
30866   Hex::RealVector arg4 ;
30867   void *argp1 = 0 ;
30868   int res1 = 0 ;
30869   void *argp3 = 0 ;
30870   int res3 = 0 ;
30871   PyObject * obj0 = 0 ;
30872   PyObject * obj1 = 0 ;
30873   PyObject * obj2 = 0 ;
30874   PyObject * obj3 = 0 ;
30875   Hex::Elements *result = 0 ;
30876
30877   if (!PyArg_ParseTuple(args,(char *)"OOOO:Document_extrudeQuads",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30878   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30879   if (!SWIG_IsOK(res1)) {
30880     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_extrudeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
30881   }
30882   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30883   {
30884     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
30885     int res = swig::asptr(obj1, &ptr);
30886     if (!SWIG_IsOK(res) || !ptr) {
30887       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "2"" of type '" "Hex::Quads""'");
30888     }
30889     arg2 = *ptr;
30890     if (SWIG_IsNewObj(res)) delete ptr;
30891   }
30892   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30893   if (!SWIG_IsOK(res3)) {
30894     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_extrudeQuads" "', argument " "3"" of type '" "Hex::Vector *""'");
30895   }
30896   arg3 = reinterpret_cast< Hex::Vector * >(argp3);
30897   {
30898     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
30899     int res = swig::asptr(obj3, &ptr);
30900     if (!SWIG_IsOK(res) || !ptr) {
30901       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_extrudeQuads" "', argument " "4"" of type '" "Hex::RealVector""'");
30902     }
30903     arg4 = *ptr;
30904     if (SWIG_IsNewObj(res)) delete ptr;
30905   }
30906   result = (Hex::Elements *)(arg1)->extrudeQuads(arg2,arg3,arg4);
30907   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30908   return resultobj;
30909 fail:
30910   return NULL;
30911 }
30912
30913
30914 SWIGINTERN PyObject *_wrap_Document_revolutionQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30915   PyObject *resultobj = 0;
30916   Hex::Document *arg1 = (Hex::Document *) 0 ;
30917   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
30918   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
30919   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
30920   double arg5 ;
30921   int arg6 ;
30922   void *argp1 = 0 ;
30923   int res1 = 0 ;
30924   void *argp2 = 0 ;
30925   int res2 = 0 ;
30926   void *argp3 = 0 ;
30927   int res3 = 0 ;
30928   void *argp4 = 0 ;
30929   int res4 = 0 ;
30930   double val5 ;
30931   int ecode5 = 0 ;
30932   int val6 ;
30933   int ecode6 = 0 ;
30934   PyObject * obj0 = 0 ;
30935   PyObject * obj1 = 0 ;
30936   PyObject * obj2 = 0 ;
30937   PyObject * obj3 = 0 ;
30938   PyObject * obj4 = 0 ;
30939   PyObject * obj5 = 0 ;
30940   Hex::Elements *result = 0 ;
30941
30942   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30943   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
30944   if (!SWIG_IsOK(res1)) {
30945     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
30946   }
30947   arg1 = reinterpret_cast< Hex::Document * >(argp1);
30948   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
30949   if (!SWIG_IsOK(res2)) {
30950     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
30951   }
30952   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
30953   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
30954   if (!SWIG_IsOK(res3)) {
30955     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
30956   }
30957   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
30958   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
30959   if (!SWIG_IsOK(res4)) {
30960     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadUni" "', argument " "4"" of type '" "Hex::Vector *""'");
30961   }
30962   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
30963   ecode5 = SWIG_AsVal_double(obj4, &val5);
30964   if (!SWIG_IsOK(ecode5)) {
30965     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadUni" "', argument " "5"" of type '" "double""'");
30966   }
30967   arg5 = static_cast< double >(val5);
30968   ecode6 = SWIG_AsVal_int(obj5, &val6);
30969   if (!SWIG_IsOK(ecode6)) {
30970     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadUni" "', argument " "6"" of type '" "int""'");
30971   }
30972   arg6 = static_cast< int >(val6);
30973   result = (Hex::Elements *)(arg1)->revolutionQuadUni(arg2,arg3,arg4,arg5,arg6);
30974   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
30975   return resultobj;
30976 fail:
30977   return NULL;
30978 }
30979
30980
30981 SWIGINTERN PyObject *_wrap_Document_revolutionQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30982   PyObject *resultobj = 0;
30983   Hex::Document *arg1 = (Hex::Document *) 0 ;
30984   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
30985   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
30986   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
30987   Hex::RealVector arg5 ;
30988   void *argp1 = 0 ;
30989   int res1 = 0 ;
30990   void *argp2 = 0 ;
30991   int res2 = 0 ;
30992   void *argp3 = 0 ;
30993   int res3 = 0 ;
30994   void *argp4 = 0 ;
30995   int res4 = 0 ;
30996   PyObject * obj0 = 0 ;
30997   PyObject * obj1 = 0 ;
30998   PyObject * obj2 = 0 ;
30999   PyObject * obj3 = 0 ;
31000   PyObject * obj4 = 0 ;
31001   Hex::Elements *result = 0 ;
31002
31003   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuad",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31004   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31005   if (!SWIG_IsOK(res1)) {
31006     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuad" "', argument " "1"" of type '" "Hex::Document *""'");
31007   }
31008   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31009   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
31010   if (!SWIG_IsOK(res2)) {
31011     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_revolutionQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
31012   }
31013   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
31014   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31015   if (!SWIG_IsOK(res3)) {
31016     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuad" "', argument " "3"" of type '" "Hex::Vertex *""'");
31017   }
31018   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
31019   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
31020   if (!SWIG_IsOK(res4)) {
31021     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuad" "', argument " "4"" of type '" "Hex::Vector *""'");
31022   }
31023   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
31024   {
31025     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
31026     int res = swig::asptr(obj4, &ptr);
31027     if (!SWIG_IsOK(res) || !ptr) {
31028       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuad" "', argument " "5"" of type '" "Hex::RealVector""'");
31029     }
31030     arg5 = *ptr;
31031     if (SWIG_IsNewObj(res)) delete ptr;
31032   }
31033   result = (Hex::Elements *)(arg1)->revolutionQuad(arg2,arg3,arg4,arg5);
31034   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
31035   return resultobj;
31036 fail:
31037   return NULL;
31038 }
31039
31040
31041 SWIGINTERN PyObject *_wrap_Document_revolutionQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31042   PyObject *resultobj = 0;
31043   Hex::Document *arg1 = (Hex::Document *) 0 ;
31044   Hex::Quads arg2 ;
31045   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
31046   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
31047   double arg5 ;
31048   int arg6 ;
31049   void *argp1 = 0 ;
31050   int res1 = 0 ;
31051   void *argp3 = 0 ;
31052   int res3 = 0 ;
31053   void *argp4 = 0 ;
31054   int res4 = 0 ;
31055   double val5 ;
31056   int ecode5 = 0 ;
31057   int val6 ;
31058   int ecode6 = 0 ;
31059   PyObject * obj0 = 0 ;
31060   PyObject * obj1 = 0 ;
31061   PyObject * obj2 = 0 ;
31062   PyObject * obj3 = 0 ;
31063   PyObject * obj4 = 0 ;
31064   PyObject * obj5 = 0 ;
31065   Hex::Elements *result = 0 ;
31066
31067   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:Document_revolutionQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31068   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31069   if (!SWIG_IsOK(res1)) {
31070     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
31071   }
31072   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31073   {
31074     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
31075     int res = swig::asptr(obj1, &ptr);
31076     if (!SWIG_IsOK(res) || !ptr) {
31077       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
31078     }
31079     arg2 = *ptr;
31080     if (SWIG_IsNewObj(res)) delete ptr;
31081   }
31082   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31083   if (!SWIG_IsOK(res3)) {
31084     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuadsUni" "', argument " "3"" of type '" "Hex::Vertex *""'");
31085   }
31086   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
31087   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
31088   if (!SWIG_IsOK(res4)) {
31089     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuadsUni" "', argument " "4"" of type '" "Hex::Vector *""'");
31090   }
31091   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
31092   ecode5 = SWIG_AsVal_double(obj4, &val5);
31093   if (!SWIG_IsOK(ecode5)) {
31094     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Document_revolutionQuadsUni" "', argument " "5"" of type '" "double""'");
31095   }
31096   arg5 = static_cast< double >(val5);
31097   ecode6 = SWIG_AsVal_int(obj5, &val6);
31098   if (!SWIG_IsOK(ecode6)) {
31099     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Document_revolutionQuadsUni" "', argument " "6"" of type '" "int""'");
31100   }
31101   arg6 = static_cast< int >(val6);
31102   result = (Hex::Elements *)(arg1)->revolutionQuadsUni(arg2,arg3,arg4,arg5,arg6);
31103   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
31104   return resultobj;
31105 fail:
31106   return NULL;
31107 }
31108
31109
31110 SWIGINTERN PyObject *_wrap_Document_revolutionQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31111   PyObject *resultobj = 0;
31112   Hex::Document *arg1 = (Hex::Document *) 0 ;
31113   Hex::Quads arg2 ;
31114   Hex::Vertex *arg3 = (Hex::Vertex *) 0 ;
31115   Hex::Vector *arg4 = (Hex::Vector *) 0 ;
31116   Hex::RealVector arg5 ;
31117   void *argp1 = 0 ;
31118   int res1 = 0 ;
31119   void *argp3 = 0 ;
31120   int res3 = 0 ;
31121   void *argp4 = 0 ;
31122   int res4 = 0 ;
31123   PyObject * obj0 = 0 ;
31124   PyObject * obj1 = 0 ;
31125   PyObject * obj2 = 0 ;
31126   PyObject * obj3 = 0 ;
31127   PyObject * obj4 = 0 ;
31128   Hex::Elements *result = 0 ;
31129
31130   if (!PyArg_ParseTuple(args,(char *)"OOOOO:Document_revolutionQuads",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31131   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31132   if (!SWIG_IsOK(res1)) {
31133     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_revolutionQuads" "', argument " "1"" of type '" "Hex::Document *""'");
31134   }
31135   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31136   {
31137     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
31138     int res = swig::asptr(obj1, &ptr);
31139     if (!SWIG_IsOK(res) || !ptr) {
31140       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "2"" of type '" "Hex::Quads""'");
31141     }
31142     arg2 = *ptr;
31143     if (SWIG_IsNewObj(res)) delete ptr;
31144   }
31145   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31146   if (!SWIG_IsOK(res3)) {
31147     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_revolutionQuads" "', argument " "3"" of type '" "Hex::Vertex *""'");
31148   }
31149   arg3 = reinterpret_cast< Hex::Vertex * >(argp3);
31150   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vector, 0 |  0 );
31151   if (!SWIG_IsOK(res4)) {
31152     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_revolutionQuads" "', argument " "4"" of type '" "Hex::Vector *""'");
31153   }
31154   arg4 = reinterpret_cast< Hex::Vector * >(argp4);
31155   {
31156     std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
31157     int res = swig::asptr(obj4, &ptr);
31158     if (!SWIG_IsOK(res) || !ptr) {
31159       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_revolutionQuads" "', argument " "5"" of type '" "Hex::RealVector""'");
31160     }
31161     arg5 = *ptr;
31162     if (SWIG_IsNewObj(res)) delete ptr;
31163   }
31164   result = (Hex::Elements *)(arg1)->revolutionQuads(arg2,arg3,arg4,arg5);
31165   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
31166   return resultobj;
31167 fail:
31168   return NULL;
31169 }
31170
31171
31172 SWIGINTERN PyObject *_wrap_Document_joinQuadUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31173   PyObject *resultobj = 0;
31174   Hex::Document *arg1 = (Hex::Document *) 0 ;
31175   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
31176   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
31177   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
31178   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
31179   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
31180   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
31181   int arg8 ;
31182   void *argp1 = 0 ;
31183   int res1 = 0 ;
31184   void *argp2 = 0 ;
31185   int res2 = 0 ;
31186   void *argp3 = 0 ;
31187   int res3 = 0 ;
31188   void *argp4 = 0 ;
31189   int res4 = 0 ;
31190   void *argp5 = 0 ;
31191   int res5 = 0 ;
31192   void *argp6 = 0 ;
31193   int res6 = 0 ;
31194   void *argp7 = 0 ;
31195   int res7 = 0 ;
31196   int val8 ;
31197   int ecode8 = 0 ;
31198   PyObject * obj0 = 0 ;
31199   PyObject * obj1 = 0 ;
31200   PyObject * obj2 = 0 ;
31201   PyObject * obj3 = 0 ;
31202   PyObject * obj4 = 0 ;
31203   PyObject * obj5 = 0 ;
31204   PyObject * obj6 = 0 ;
31205   PyObject * obj7 = 0 ;
31206   Hex::Elements *result = 0 ;
31207
31208   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
31209   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31210   if (!SWIG_IsOK(res1)) {
31211     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadUni" "', argument " "1"" of type '" "Hex::Document *""'");
31212   }
31213   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31214   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
31215   if (!SWIG_IsOK(res2)) {
31216     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuadUni" "', argument " "2"" of type '" "Hex::Quad *""'");
31217   }
31218   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
31219   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
31220   if (!SWIG_IsOK(res3)) {
31221     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadUni" "', argument " "3"" of type '" "Hex::Quad *""'");
31222   }
31223   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
31224   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31225   if (!SWIG_IsOK(res4)) {
31226     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
31227   }
31228   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
31229   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31230   if (!SWIG_IsOK(res5)) {
31231     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
31232   }
31233   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
31234   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31235   if (!SWIG_IsOK(res6)) {
31236     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
31237   }
31238   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
31239   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31240   if (!SWIG_IsOK(res7)) {
31241     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
31242   }
31243   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
31244   ecode8 = SWIG_AsVal_int(obj7, &val8);
31245   if (!SWIG_IsOK(ecode8)) {
31246     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadUni" "', argument " "8"" of type '" "int""'");
31247   }
31248   arg8 = static_cast< int >(val8);
31249   result = (Hex::Elements *)(arg1)->joinQuadUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
31250   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
31251   return resultobj;
31252 fail:
31253   return NULL;
31254 }
31255
31256
31257 SWIGINTERN PyObject *_wrap_Document_joinQuadsUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31258   PyObject *resultobj = 0;
31259   Hex::Document *arg1 = (Hex::Document *) 0 ;
31260   Hex::Quads arg2 ;
31261   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
31262   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
31263   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
31264   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
31265   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
31266   int arg8 ;
31267   void *argp1 = 0 ;
31268   int res1 = 0 ;
31269   void *argp3 = 0 ;
31270   int res3 = 0 ;
31271   void *argp4 = 0 ;
31272   int res4 = 0 ;
31273   void *argp5 = 0 ;
31274   int res5 = 0 ;
31275   void *argp6 = 0 ;
31276   int res6 = 0 ;
31277   void *argp7 = 0 ;
31278   int res7 = 0 ;
31279   int val8 ;
31280   int ecode8 = 0 ;
31281   PyObject * obj0 = 0 ;
31282   PyObject * obj1 = 0 ;
31283   PyObject * obj2 = 0 ;
31284   PyObject * obj3 = 0 ;
31285   PyObject * obj4 = 0 ;
31286   PyObject * obj5 = 0 ;
31287   PyObject * obj6 = 0 ;
31288   PyObject * obj7 = 0 ;
31289   Hex::Elements *result = 0 ;
31290
31291   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuadsUni",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
31292   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31293   if (!SWIG_IsOK(res1)) {
31294     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuadsUni" "', argument " "1"" of type '" "Hex::Document *""'");
31295   }
31296   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31297   {
31298     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
31299     int res = swig::asptr(obj1, &ptr);
31300     if (!SWIG_IsOK(res) || !ptr) {
31301       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuadsUni" "', argument " "2"" of type '" "Hex::Quads""'");
31302     }
31303     arg2 = *ptr;
31304     if (SWIG_IsNewObj(res)) delete ptr;
31305   }
31306   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
31307   if (!SWIG_IsOK(res3)) {
31308     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuadsUni" "', argument " "3"" of type '" "Hex::Quad *""'");
31309   }
31310   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
31311   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31312   if (!SWIG_IsOK(res4)) {
31313     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuadsUni" "', argument " "4"" of type '" "Hex::Vertex *""'");
31314   }
31315   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
31316   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31317   if (!SWIG_IsOK(res5)) {
31318     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuadsUni" "', argument " "5"" of type '" "Hex::Vertex *""'");
31319   }
31320   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
31321   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31322   if (!SWIG_IsOK(res6)) {
31323     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuadsUni" "', argument " "6"" of type '" "Hex::Vertex *""'");
31324   }
31325   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
31326   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31327   if (!SWIG_IsOK(res7)) {
31328     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuadsUni" "', argument " "7"" of type '" "Hex::Vertex *""'");
31329   }
31330   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
31331   ecode8 = SWIG_AsVal_int(obj7, &val8);
31332   if (!SWIG_IsOK(ecode8)) {
31333     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Document_joinQuadsUni" "', argument " "8"" of type '" "int""'");
31334   }
31335   arg8 = static_cast< int >(val8);
31336   result = (Hex::Elements *)(arg1)->joinQuadsUni(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
31337   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
31338   return resultobj;
31339 fail:
31340   return NULL;
31341 }
31342
31343
31344 SWIGINTERN PyObject *_wrap_Document_joinQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31345   PyObject *resultobj = 0;
31346   Hex::Document *arg1 = (Hex::Document *) 0 ;
31347   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
31348   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
31349   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
31350   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
31351   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
31352   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
31353   Hex::RealVector *arg8 = 0 ;
31354   void *argp1 = 0 ;
31355   int res1 = 0 ;
31356   void *argp2 = 0 ;
31357   int res2 = 0 ;
31358   void *argp3 = 0 ;
31359   int res3 = 0 ;
31360   void *argp4 = 0 ;
31361   int res4 = 0 ;
31362   void *argp5 = 0 ;
31363   int res5 = 0 ;
31364   void *argp6 = 0 ;
31365   int res6 = 0 ;
31366   void *argp7 = 0 ;
31367   int res7 = 0 ;
31368   void *argp8 = 0 ;
31369   int res8 = 0 ;
31370   PyObject * obj0 = 0 ;
31371   PyObject * obj1 = 0 ;
31372   PyObject * obj2 = 0 ;
31373   PyObject * obj3 = 0 ;
31374   PyObject * obj4 = 0 ;
31375   PyObject * obj5 = 0 ;
31376   PyObject * obj6 = 0 ;
31377   PyObject * obj7 = 0 ;
31378   Hex::Elements *result = 0 ;
31379
31380   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuad",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
31381   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31382   if (!SWIG_IsOK(res1)) {
31383     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuad" "', argument " "1"" of type '" "Hex::Document *""'");
31384   }
31385   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31386   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
31387   if (!SWIG_IsOK(res2)) {
31388     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_joinQuad" "', argument " "2"" of type '" "Hex::Quad *""'");
31389   }
31390   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
31391   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
31392   if (!SWIG_IsOK(res3)) {
31393     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuad" "', argument " "3"" of type '" "Hex::Quad *""'");
31394   }
31395   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
31396   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31397   if (!SWIG_IsOK(res4)) {
31398     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuad" "', argument " "4"" of type '" "Hex::Vertex *""'");
31399   }
31400   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
31401   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31402   if (!SWIG_IsOK(res5)) {
31403     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuad" "', argument " "5"" of type '" "Hex::Vertex *""'");
31404   }
31405   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
31406   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31407   if (!SWIG_IsOK(res6)) {
31408     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuad" "', argument " "6"" of type '" "Hex::Vertex *""'");
31409   }
31410   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
31411   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31412   if (!SWIG_IsOK(res7)) {
31413     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuad" "', argument " "7"" of type '" "Hex::Vertex *""'");
31414   }
31415   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
31416   res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
31417   if (!SWIG_IsOK(res8)) {
31418     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
31419   }
31420   if (!argp8) {
31421     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuad" "', argument " "8"" of type '" "Hex::RealVector &""'");
31422   }
31423   arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
31424   result = (Hex::Elements *)(arg1)->joinQuad(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
31425   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
31426   return resultobj;
31427 fail:
31428   return NULL;
31429 }
31430
31431
31432 SWIGINTERN PyObject *_wrap_Document_joinQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31433   PyObject *resultobj = 0;
31434   Hex::Document *arg1 = (Hex::Document *) 0 ;
31435   Hex::Quads arg2 ;
31436   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
31437   Hex::Vertex *arg4 = (Hex::Vertex *) 0 ;
31438   Hex::Vertex *arg5 = (Hex::Vertex *) 0 ;
31439   Hex::Vertex *arg6 = (Hex::Vertex *) 0 ;
31440   Hex::Vertex *arg7 = (Hex::Vertex *) 0 ;
31441   Hex::RealVector *arg8 = 0 ;
31442   void *argp1 = 0 ;
31443   int res1 = 0 ;
31444   void *argp3 = 0 ;
31445   int res3 = 0 ;
31446   void *argp4 = 0 ;
31447   int res4 = 0 ;
31448   void *argp5 = 0 ;
31449   int res5 = 0 ;
31450   void *argp6 = 0 ;
31451   int res6 = 0 ;
31452   void *argp7 = 0 ;
31453   int res7 = 0 ;
31454   void *argp8 = 0 ;
31455   int res8 = 0 ;
31456   PyObject * obj0 = 0 ;
31457   PyObject * obj1 = 0 ;
31458   PyObject * obj2 = 0 ;
31459   PyObject * obj3 = 0 ;
31460   PyObject * obj4 = 0 ;
31461   PyObject * obj5 = 0 ;
31462   PyObject * obj6 = 0 ;
31463   PyObject * obj7 = 0 ;
31464   Hex::Elements *result = 0 ;
31465
31466   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Document_joinQuads",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
31467   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31468   if (!SWIG_IsOK(res1)) {
31469     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_joinQuads" "', argument " "1"" of type '" "Hex::Document *""'");
31470   }
31471   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31472   {
31473     std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *ptr = (std::vector< Hex::Quad*,std::allocator< Hex::Quad * > > *)0;
31474     int res = swig::asptr(obj1, &ptr);
31475     if (!SWIG_IsOK(res) || !ptr) {
31476       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Document_joinQuads" "', argument " "2"" of type '" "Hex::Quads""'");
31477     }
31478     arg2 = *ptr;
31479     if (SWIG_IsNewObj(res)) delete ptr;
31480   }
31481   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
31482   if (!SWIG_IsOK(res3)) {
31483     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_joinQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
31484   }
31485   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
31486   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31487   if (!SWIG_IsOK(res4)) {
31488     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Document_joinQuads" "', argument " "4"" of type '" "Hex::Vertex *""'");
31489   }
31490   arg4 = reinterpret_cast< Hex::Vertex * >(argp4);
31491   res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31492   if (!SWIG_IsOK(res5)) {
31493     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Document_joinQuads" "', argument " "5"" of type '" "Hex::Vertex *""'");
31494   }
31495   arg5 = reinterpret_cast< Hex::Vertex * >(argp5);
31496   res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31497   if (!SWIG_IsOK(res6)) {
31498     SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Document_joinQuads" "', argument " "6"" of type '" "Hex::Vertex *""'");
31499   }
31500   arg6 = reinterpret_cast< Hex::Vertex * >(argp6);
31501   res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31502   if (!SWIG_IsOK(res7)) {
31503     SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Document_joinQuads" "', argument " "7"" of type '" "Hex::Vertex *""'");
31504   }
31505   arg7 = reinterpret_cast< Hex::Vertex * >(argp7);
31506   res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
31507   if (!SWIG_IsOK(res8)) {
31508     SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
31509   }
31510   if (!argp8) {
31511     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_joinQuads" "', argument " "8"" of type '" "Hex::RealVector &""'");
31512   }
31513   arg8 = reinterpret_cast< Hex::RealVector * >(argp8);
31514   result = (Hex::Elements *)(arg1)->joinQuads(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
31515   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
31516   return resultobj;
31517 fail:
31518   return NULL;
31519 }
31520
31521
31522 SWIGINTERN PyObject *_wrap_Document_cutUni(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31523   PyObject *resultobj = 0;
31524   Hex::Document *arg1 = (Hex::Document *) 0 ;
31525   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
31526   int arg3 ;
31527   void *argp1 = 0 ;
31528   int res1 = 0 ;
31529   void *argp2 = 0 ;
31530   int res2 = 0 ;
31531   int val3 ;
31532   int ecode3 = 0 ;
31533   PyObject * obj0 = 0 ;
31534   PyObject * obj1 = 0 ;
31535   PyObject * obj2 = 0 ;
31536   Hex::Elements *result = 0 ;
31537
31538   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cutUni",&obj0,&obj1,&obj2)) SWIG_fail;
31539   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31540   if (!SWIG_IsOK(res1)) {
31541     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cutUni" "', argument " "1"" of type '" "Hex::Document *""'");
31542   }
31543   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31544   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
31545   if (!SWIG_IsOK(res2)) {
31546     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cutUni" "', argument " "2"" of type '" "Hex::Edge *""'");
31547   }
31548   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
31549   ecode3 = SWIG_AsVal_int(obj2, &val3);
31550   if (!SWIG_IsOK(ecode3)) {
31551     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_cutUni" "', argument " "3"" of type '" "int""'");
31552   }
31553   arg3 = static_cast< int >(val3);
31554   result = (Hex::Elements *)(arg1)->cutUni(arg2,arg3);
31555   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
31556   return resultobj;
31557 fail:
31558   return NULL;
31559 }
31560
31561
31562 SWIGINTERN PyObject *_wrap_Document_cut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31563   PyObject *resultobj = 0;
31564   Hex::Document *arg1 = (Hex::Document *) 0 ;
31565   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
31566   Hex::RealVector *arg3 = 0 ;
31567   void *argp1 = 0 ;
31568   int res1 = 0 ;
31569   void *argp2 = 0 ;
31570   int res2 = 0 ;
31571   void *argp3 = 0 ;
31572   int res3 = 0 ;
31573   PyObject * obj0 = 0 ;
31574   PyObject * obj1 = 0 ;
31575   PyObject * obj2 = 0 ;
31576   Hex::Elements *result = 0 ;
31577
31578   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_cut",&obj0,&obj1,&obj2)) SWIG_fail;
31579   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31580   if (!SWIG_IsOK(res1)) {
31581     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_cut" "', argument " "1"" of type '" "Hex::Document *""'");
31582   }
31583   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31584   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
31585   if (!SWIG_IsOK(res2)) {
31586     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_cut" "', argument " "2"" of type '" "Hex::Edge *""'");
31587   }
31588   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
31589   res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t,  0 );
31590   if (!SWIG_IsOK(res3)) {
31591     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
31592   }
31593   if (!argp3) {
31594     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Document_cut" "', argument " "3"" of type '" "Hex::RealVector &""'");
31595   }
31596   arg3 = reinterpret_cast< Hex::RealVector * >(argp3);
31597   result = (Hex::Elements *)(arg1)->cut(arg2,*arg3);
31598   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, 0 |  0 );
31599   return resultobj;
31600 fail:
31601   return NULL;
31602 }
31603
31604
31605 SWIGINTERN PyObject *_wrap_Document_addGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31606   PyObject *resultobj = 0;
31607   Hex::Document *arg1 = (Hex::Document *) 0 ;
31608   cpchar arg2 = (cpchar) 0 ;
31609   Hex::EnumGroup arg3 ;
31610   void *argp1 = 0 ;
31611   int res1 = 0 ;
31612   int res2 ;
31613   char *buf2 = 0 ;
31614   int alloc2 = 0 ;
31615   int val3 ;
31616   int ecode3 = 0 ;
31617   PyObject * obj0 = 0 ;
31618   PyObject * obj1 = 0 ;
31619   PyObject * obj2 = 0 ;
31620   Hex::Group *result = 0 ;
31621
31622   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addGroup",&obj0,&obj1,&obj2)) SWIG_fail;
31623   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31624   if (!SWIG_IsOK(res1)) {
31625     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addGroup" "', argument " "1"" of type '" "Hex::Document *""'");
31626   }
31627   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31628   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
31629   if (!SWIG_IsOK(res2)) {
31630     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addGroup" "', argument " "2"" of type '" "cpchar""'");
31631   }
31632   arg2 = reinterpret_cast< cpchar >(buf2);
31633   ecode3 = SWIG_AsVal_int(obj2, &val3);
31634   if (!SWIG_IsOK(ecode3)) {
31635     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Document_addGroup" "', argument " "3"" of type '" "Hex::EnumGroup""'");
31636   }
31637   arg3 = static_cast< Hex::EnumGroup >(val3);
31638   result = (Hex::Group *)(arg1)->addGroup(arg2,arg3);
31639   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, 0 |  0 );
31640   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31641   return resultobj;
31642 fail:
31643   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
31644   return NULL;
31645 }
31646
31647
31648 SWIGINTERN PyObject *_wrap_Document_isSaved(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31649   PyObject *resultobj = 0;
31650   Hex::Document *arg1 = (Hex::Document *) 0 ;
31651   void *argp1 = 0 ;
31652   int res1 = 0 ;
31653   PyObject * obj0 = 0 ;
31654   bool result;
31655
31656   if (!PyArg_ParseTuple(args,(char *)"O:Document_isSaved",&obj0)) SWIG_fail;
31657   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31658   if (!SWIG_IsOK(res1)) {
31659     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_isSaved" "', argument " "1"" of type '" "Hex::Document *""'");
31660   }
31661   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31662   result = (bool)(arg1)->isSaved();
31663   resultobj = SWIG_From_bool(static_cast< bool >(result));
31664   return resultobj;
31665 fail:
31666   return NULL;
31667 }
31668
31669
31670 SWIGINTERN PyObject *_wrap_Document_appendXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31671   PyObject *resultobj = 0;
31672   Hex::Document *arg1 = (Hex::Document *) 0 ;
31673   pfile arg2 = (pfile) 0 ;
31674   void *argp1 = 0 ;
31675   int res1 = 0 ;
31676   void *argp2 = 0 ;
31677   int res2 = 0 ;
31678   PyObject * obj0 = 0 ;
31679   PyObject * obj1 = 0 ;
31680   int result;
31681
31682   if (!PyArg_ParseTuple(args,(char *)"OO:Document_appendXml",&obj0,&obj1)) SWIG_fail;
31683   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31684   if (!SWIG_IsOK(res1)) {
31685     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_appendXml" "', argument " "1"" of type '" "Hex::Document *""'");
31686   }
31687   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31688   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 |  0 );
31689   if (!SWIG_IsOK(res2)) {
31690     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_appendXml" "', argument " "2"" of type '" "pfile""'");
31691   }
31692   arg2 = reinterpret_cast< pfile >(argp2);
31693   result = (int)(arg1)->appendXml(arg2);
31694   resultobj = SWIG_From_int(static_cast< int >(result));
31695   return resultobj;
31696 fail:
31697   return NULL;
31698 }
31699
31700
31701 SWIGINTERN PyObject *_wrap_Document_getXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31702   PyObject *resultobj = 0;
31703   Hex::Document *arg1 = (Hex::Document *) 0 ;
31704   void *argp1 = 0 ;
31705   int res1 = 0 ;
31706   PyObject * obj0 = 0 ;
31707   cpchar result;
31708
31709   if (!PyArg_ParseTuple(args,(char *)"O:Document_getXml",&obj0)) SWIG_fail;
31710   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31711   if (!SWIG_IsOK(res1)) {
31712     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getXml" "', argument " "1"" of type '" "Hex::Document *""'");
31713   }
31714   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31715   result = (cpchar)(arg1)->getXml();
31716   resultobj = SWIG_FromCharPtr((const char *)result);
31717   return resultobj;
31718 fail:
31719   return NULL;
31720 }
31721
31722
31723 SWIGINTERN PyObject *_wrap_Document_getLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31724   PyObject *resultobj = 0;
31725   Hex::Document *arg1 = (Hex::Document *) 0 ;
31726   void *argp1 = 0 ;
31727   int res1 = 0 ;
31728   PyObject * obj0 = 0 ;
31729   int result;
31730
31731   if (!PyArg_ParseTuple(args,(char *)"O:Document_getLevel",&obj0)) SWIG_fail;
31732   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31733   if (!SWIG_IsOK(res1)) {
31734     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_getLevel" "', argument " "1"" of type '" "Hex::Document *""'");
31735   }
31736   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31737   result = (int)(arg1)->getLevel();
31738   resultobj = SWIG_From_int(static_cast< int >(result));
31739   return resultobj;
31740 fail:
31741   return NULL;
31742 }
31743
31744
31745 SWIGINTERN PyObject *_wrap_Document_findVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31746   PyObject *resultobj = 0;
31747   Hex::Document *arg1 = (Hex::Document *) 0 ;
31748   int arg2 ;
31749   void *argp1 = 0 ;
31750   int res1 = 0 ;
31751   int val2 ;
31752   int ecode2 = 0 ;
31753   PyObject * obj0 = 0 ;
31754   PyObject * obj1 = 0 ;
31755   Hex::Vertex *result = 0 ;
31756
31757   if (!PyArg_ParseTuple(args,(char *)"OO:Document_findVertex",&obj0,&obj1)) SWIG_fail;
31758   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31759   if (!SWIG_IsOK(res1)) {
31760     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_findVertex" "', argument " "1"" of type '" "Hex::Document *""'");
31761   }
31762   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31763   ecode2 = SWIG_AsVal_int(obj1, &val2);
31764   if (!SWIG_IsOK(ecode2)) {
31765     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_findVertex" "', argument " "2"" of type '" "int""'");
31766   }
31767   arg2 = static_cast< int >(val2);
31768   result = (Hex::Vertex *)(arg1)->findVertex(arg2);
31769   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
31770   return resultobj;
31771 fail:
31772   return NULL;
31773 }
31774
31775
31776 SWIGINTERN PyObject *_wrap_Document_findVertex(PyObject *self, PyObject *args) {
31777   Py_ssize_t argc;
31778   PyObject *argv[5] = {
31779     0
31780   };
31781   Py_ssize_t ii;
31782
31783   if (!PyTuple_Check(args)) SWIG_fail;
31784   argc = args ? PyObject_Length(args) : 0;
31785   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
31786     argv[ii] = PyTuple_GET_ITEM(args,ii);
31787   }
31788   if (argc == 2) {
31789     int _v;
31790     void *vptr = 0;
31791     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
31792     _v = SWIG_CheckState(res);
31793     if (_v) {
31794       {
31795         int res = SWIG_AsVal_int(argv[1], NULL);
31796         _v = SWIG_CheckState(res);
31797       }
31798       if (_v) {
31799         return _wrap_Document_findVertex__SWIG_1(self, args);
31800       }
31801     }
31802   }
31803   if (argc == 4) {
31804     int _v;
31805     void *vptr = 0;
31806     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
31807     _v = SWIG_CheckState(res);
31808     if (_v) {
31809       {
31810         int res = SWIG_AsVal_double(argv[1], NULL);
31811         _v = SWIG_CheckState(res);
31812       }
31813       if (_v) {
31814         {
31815           int res = SWIG_AsVal_double(argv[2], NULL);
31816           _v = SWIG_CheckState(res);
31817         }
31818         if (_v) {
31819           {
31820             int res = SWIG_AsVal_double(argv[3], NULL);
31821             _v = SWIG_CheckState(res);
31822           }
31823           if (_v) {
31824             return _wrap_Document_findVertex__SWIG_0(self, args);
31825           }
31826         }
31827       }
31828     }
31829   }
31830
31831 fail:
31832   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_findVertex'.\n"
31833     "  Possible C/C++ prototypes are:\n"
31834     "    Hex::Document::findVertex(double,double,double)\n"
31835     "    Hex::Document::findVertex(int)\n");
31836   return 0;
31837 }
31838
31839
31840 SWIGINTERN PyObject *_wrap_Document_closeQuads(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31841   PyObject *resultobj = 0;
31842   Hex::Document *arg1 = (Hex::Document *) 0 ;
31843   Hex::Quad *arg2 = (Hex::Quad *) 0 ;
31844   Hex::Quad *arg3 = (Hex::Quad *) 0 ;
31845   void *argp1 = 0 ;
31846   int res1 = 0 ;
31847   void *argp2 = 0 ;
31848   int res2 = 0 ;
31849   void *argp3 = 0 ;
31850   int res3 = 0 ;
31851   PyObject * obj0 = 0 ;
31852   PyObject * obj1 = 0 ;
31853   PyObject * obj2 = 0 ;
31854   int result;
31855
31856   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_closeQuads",&obj0,&obj1,&obj2)) SWIG_fail;
31857   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31858   if (!SWIG_IsOK(res1)) {
31859     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_closeQuads" "', argument " "1"" of type '" "Hex::Document *""'");
31860   }
31861   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31862   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Quad, 0 |  0 );
31863   if (!SWIG_IsOK(res2)) {
31864     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_closeQuads" "', argument " "2"" of type '" "Hex::Quad *""'");
31865   }
31866   arg2 = reinterpret_cast< Hex::Quad * >(argp2);
31867   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Hex__Quad, 0 |  0 );
31868   if (!SWIG_IsOK(res3)) {
31869     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_closeQuads" "', argument " "3"" of type '" "Hex::Quad *""'");
31870   }
31871   arg3 = reinterpret_cast< Hex::Quad * >(argp3);
31872   result = (int)(arg1)->closeQuads(arg2,arg3);
31873   resultobj = SWIG_From_int(static_cast< int >(result));
31874   return resultobj;
31875 fail:
31876   return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_Document_addLaw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31881   PyObject *resultobj = 0;
31882   Hex::Document *arg1 = (Hex::Document *) 0 ;
31883   Hex::Law *arg2 = (Hex::Law *) 0 ;
31884   void *argp1 = 0 ;
31885   int res1 = 0 ;
31886   void *argp2 = 0 ;
31887   int res2 = 0 ;
31888   PyObject * obj0 = 0 ;
31889   PyObject * obj1 = 0 ;
31890   Hex::Law *result = 0 ;
31891
31892   if (!PyArg_ParseTuple(args,(char *)"OO:Document_addLaw",&obj0,&obj1)) SWIG_fail;
31893   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31894   if (!SWIG_IsOK(res1)) {
31895     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addLaw" "', argument " "1"" of type '" "Hex::Document *""'");
31896   }
31897   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31898   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
31899   if (!SWIG_IsOK(res2)) {
31900     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Document_addLaw" "', argument " "2"" of type '" "Hex::Law *""'");
31901   }
31902   arg2 = reinterpret_cast< Hex::Law * >(argp2);
31903   result = (Hex::Law *)(arg1)->addLaw(arg2);
31904   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
31905   return resultobj;
31906 fail:
31907   return NULL;
31908 }
31909
31910
31911 SWIGINTERN PyObject *_wrap_Document_addLaw(PyObject *self, PyObject *args) {
31912   Py_ssize_t argc;
31913   PyObject *argv[4] = {
31914     0
31915   };
31916   Py_ssize_t ii;
31917
31918   if (!PyTuple_Check(args)) SWIG_fail;
31919   argc = args ? PyObject_Length(args) : 0;
31920   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
31921     argv[ii] = PyTuple_GET_ITEM(args,ii);
31922   }
31923   if (argc == 2) {
31924     int _v;
31925     void *vptr = 0;
31926     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
31927     _v = SWIG_CheckState(res);
31928     if (_v) {
31929       void *vptr = 0;
31930       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__Law, 0);
31931       _v = SWIG_CheckState(res);
31932       if (_v) {
31933         return _wrap_Document_addLaw__SWIG_1(self, args);
31934       }
31935     }
31936   }
31937   if (argc == 3) {
31938     int _v;
31939     void *vptr = 0;
31940     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
31941     _v = SWIG_CheckState(res);
31942     if (_v) {
31943       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
31944       _v = SWIG_CheckState(res);
31945       if (_v) {
31946         {
31947           int res = SWIG_AsVal_int(argv[2], NULL);
31948           _v = SWIG_CheckState(res);
31949         }
31950         if (_v) {
31951           return _wrap_Document_addLaw__SWIG_0(self, args);
31952         }
31953       }
31954     }
31955   }
31956
31957 fail:
31958   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Document_addLaw'.\n"
31959     "  Possible C/C++ prototypes are:\n"
31960     "    Hex::Document::addLaw(char const *,int)\n"
31961     "    Hex::Document::addLaw(Hex::Law *)\n");
31962   return 0;
31963 }
31964
31965
31966 SWIGINTERN PyObject *_wrap_Document_checkAssociations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31967   PyObject *resultobj = 0;
31968   Hex::Document *arg1 = (Hex::Document *) 0 ;
31969   void *argp1 = 0 ;
31970   int res1 = 0 ;
31971   PyObject * obj0 = 0 ;
31972   int result;
31973
31974   if (!PyArg_ParseTuple(args,(char *)"O:Document_checkAssociations",&obj0)) SWIG_fail;
31975   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
31976   if (!SWIG_IsOK(res1)) {
31977     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_checkAssociations" "', argument " "1"" of type '" "Hex::Document *""'");
31978   }
31979   arg1 = reinterpret_cast< Hex::Document * >(argp1);
31980   result = (int)(arg1)->checkAssociations();
31981   resultobj = SWIG_From_int(static_cast< int >(result));
31982   return resultobj;
31983 fail:
31984   return NULL;
31985 }
31986
31987
31988 SWIGINTERN PyObject *_wrap_Document_addShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31989   PyObject *resultobj = 0;
31990   Hex::Document *arg1 = (Hex::Document *) 0 ;
31991   long arg2 ;
31992   char *arg3 = (char *) 0 ;
31993   void *argp1 = 0 ;
31994   int res1 = 0 ;
31995   long val2 ;
31996   int ecode2 = 0 ;
31997   int res3 ;
31998   char *buf3 = 0 ;
31999   int alloc3 = 0 ;
32000   PyObject * obj0 = 0 ;
32001   PyObject * obj1 = 0 ;
32002   PyObject * obj2 = 0 ;
32003   Hex::NewShape *result = 0 ;
32004
32005   if (!PyArg_ParseTuple(args,(char *)"OOO:Document_addShape",&obj0,&obj1,&obj2)) SWIG_fail;
32006   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
32007   if (!SWIG_IsOK(res1)) {
32008     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Document_addShape" "', argument " "1"" of type '" "Hex::Document *""'");
32009   }
32010   arg1 = reinterpret_cast< Hex::Document * >(argp1);
32011   ecode2 = SWIG_AsVal_long(obj1, &val2);
32012   if (!SWIG_IsOK(ecode2)) {
32013     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Document_addShape" "', argument " "2"" of type '" "long""'");
32014   }
32015   arg2 = static_cast< long >(val2);
32016   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
32017   if (!SWIG_IsOK(res3)) {
32018     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Document_addShape" "', argument " "3"" of type '" "char const *""'");
32019   }
32020   arg3 = reinterpret_cast< char * >(buf3);
32021   result = (Hex::NewShape *)(arg1)->addShape(arg2,(char const *)arg3);
32022   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, 0 |  0 );
32023   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
32024   return resultobj;
32025 fail:
32026   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
32027   return NULL;
32028 }
32029
32030
32031 SWIGINTERN PyObject *_wrap_delete_Document(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32032   PyObject *resultobj = 0;
32033   Hex::Document *arg1 = (Hex::Document *) 0 ;
32034   void *argp1 = 0 ;
32035   int res1 = 0 ;
32036   PyObject * obj0 = 0 ;
32037
32038   if (!PyArg_ParseTuple(args,(char *)"O:delete_Document",&obj0)) SWIG_fail;
32039   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, SWIG_POINTER_DISOWN |  0 );
32040   if (!SWIG_IsOK(res1)) {
32041     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Document" "', argument " "1"" of type '" "Hex::Document *""'");
32042   }
32043   arg1 = reinterpret_cast< Hex::Document * >(argp1);
32044   delete arg1;
32045   resultobj = SWIG_Py_Void();
32046   return resultobj;
32047 fail:
32048   return NULL;
32049 }
32050
32051
32052 SWIGINTERN PyObject *Document_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32053   PyObject *obj;
32054   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
32055   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Document, SWIG_NewClientData(obj));
32056   return SWIG_Py_Void();
32057 }
32058
32059 SWIGINTERN PyObject *_wrap_Propagation_getEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32060   PyObject *resultobj = 0;
32061   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32062   void *argp1 = 0 ;
32063   int res1 = 0 ;
32064   PyObject * obj0 = 0 ;
32065   Hex::Edges *result = 0 ;
32066
32067   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getEdges",&obj0)) SWIG_fail;
32068   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
32069   if (!SWIG_IsOK(res1)) {
32070     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getEdges" "', argument " "1"" of type '" "Hex::Propagation *""'");
32071   }
32072   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32073   result = (Hex::Edges *) &(arg1)->getEdges();
32074   resultobj = swig::from(static_cast< std::vector< Hex::Edge*,std::allocator< Hex::Edge * > > >(*result));
32075   return resultobj;
32076 fail:
32077   return NULL;
32078 }
32079
32080
32081 SWIGINTERN PyObject *_wrap_Propagation_getLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32082   PyObject *resultobj = 0;
32083   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32084   void *argp1 = 0 ;
32085   int res1 = 0 ;
32086   PyObject * obj0 = 0 ;
32087   Hex::Law *result = 0 ;
32088
32089   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getLaw",&obj0)) SWIG_fail;
32090   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
32091   if (!SWIG_IsOK(res1)) {
32092     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
32093   }
32094   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32095   result = (Hex::Law *)(arg1)->getLaw();
32096   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Law, 0 |  0 );
32097   return resultobj;
32098 fail:
32099   return NULL;
32100 }
32101
32102
32103 SWIGINTERN PyObject *_wrap_Propagation_getWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32104   PyObject *resultobj = 0;
32105   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32106   void *argp1 = 0 ;
32107   int res1 = 0 ;
32108   PyObject * obj0 = 0 ;
32109   bool result;
32110
32111   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_getWay",&obj0)) SWIG_fail;
32112   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
32113   if (!SWIG_IsOK(res1)) {
32114     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_getWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
32115   }
32116   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32117   result = (bool)(arg1)->getWay();
32118   resultobj = SWIG_From_bool(static_cast< bool >(result));
32119   return resultobj;
32120 fail:
32121   return NULL;
32122 }
32123
32124
32125 SWIGINTERN PyObject *_wrap_Propagation_setWay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32126   PyObject *resultobj = 0;
32127   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32128   bool arg2 ;
32129   void *argp1 = 0 ;
32130   int res1 = 0 ;
32131   bool val2 ;
32132   int ecode2 = 0 ;
32133   PyObject * obj0 = 0 ;
32134   PyObject * obj1 = 0 ;
32135
32136   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setWay",&obj0,&obj1)) SWIG_fail;
32137   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
32138   if (!SWIG_IsOK(res1)) {
32139     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setWay" "', argument " "1"" of type '" "Hex::Propagation *""'");
32140   }
32141   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32142   ecode2 = SWIG_AsVal_bool(obj1, &val2);
32143   if (!SWIG_IsOK(ecode2)) {
32144     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Propagation_setWay" "', argument " "2"" of type '" "bool""'");
32145   }
32146   arg2 = static_cast< bool >(val2);
32147   (arg1)->setWay(arg2);
32148   resultobj = SWIG_Py_Void();
32149   return resultobj;
32150 fail:
32151   return NULL;
32152 }
32153
32154
32155 SWIGINTERN PyObject *_wrap_Propagation_setLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32156   PyObject *resultobj = 0;
32157   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32158   Hex::Law *arg2 = (Hex::Law *) 0 ;
32159   void *argp1 = 0 ;
32160   int res1 = 0 ;
32161   void *argp2 = 0 ;
32162   int res2 = 0 ;
32163   PyObject * obj0 = 0 ;
32164   PyObject * obj1 = 0 ;
32165   int result;
32166
32167   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_setLaw",&obj0,&obj1)) SWIG_fail;
32168   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
32169   if (!SWIG_IsOK(res1)) {
32170     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_setLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
32171   }
32172   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32173   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Law, 0 |  0 );
32174   if (!SWIG_IsOK(res2)) {
32175     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_setLaw" "', argument " "2"" of type '" "Hex::Law *""'");
32176   }
32177   arg2 = reinterpret_cast< Hex::Law * >(argp2);
32178   result = (int)(arg1)->setLaw(arg2);
32179   resultobj = SWIG_From_int(static_cast< int >(result));
32180   return resultobj;
32181 fail:
32182   return NULL;
32183 }
32184
32185
32186 SWIGINTERN PyObject *_wrap_new_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32187   PyObject *resultobj = 0;
32188   Hex::Document *arg1 = (Hex::Document *) 0 ;
32189   void *argp1 = 0 ;
32190   int res1 = 0 ;
32191   PyObject * obj0 = 0 ;
32192   Hex::Propagation *result = 0 ;
32193
32194   if (!PyArg_ParseTuple(args,(char *)"O:new_Propagation",&obj0)) SWIG_fail;
32195   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
32196   if (!SWIG_IsOK(res1)) {
32197     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Propagation" "', argument " "1"" of type '" "Hex::Document *""'");
32198   }
32199   arg1 = reinterpret_cast< Hex::Document * >(argp1);
32200   result = (Hex::Propagation *)new Hex::Propagation(arg1);
32201   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_NEW |  0 );
32202   return resultobj;
32203 fail:
32204   return NULL;
32205 }
32206
32207
32208 SWIGINTERN PyObject *_wrap_Propagation_saveXml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32209   PyObject *resultobj = 0;
32210   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32211   Hex::XmlWriter *arg2 = (Hex::XmlWriter *) 0 ;
32212   void *argp1 = 0 ;
32213   int res1 = 0 ;
32214   void *argp2 = 0 ;
32215   int res2 = 0 ;
32216   PyObject * obj0 = 0 ;
32217   PyObject * obj1 = 0 ;
32218
32219   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_saveXml",&obj0,&obj1)) SWIG_fail;
32220   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
32221   if (!SWIG_IsOK(res1)) {
32222     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_saveXml" "', argument " "1"" of type '" "Hex::Propagation *""'");
32223   }
32224   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32225   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__XmlWriter, 0 |  0 );
32226   if (!SWIG_IsOK(res2)) {
32227     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_saveXml" "', argument " "2"" of type '" "Hex::XmlWriter *""'");
32228   }
32229   arg2 = reinterpret_cast< Hex::XmlWriter * >(argp2);
32230   (arg1)->saveXml(arg2);
32231   resultobj = SWIG_Py_Void();
32232   return resultobj;
32233 fail:
32234   return NULL;
32235 }
32236
32237
32238 SWIGINTERN PyObject *_wrap_Propagation_addEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32239   PyObject *resultobj = 0;
32240   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32241   Hex::Edge *arg2 = (Hex::Edge *) 0 ;
32242   void *argp1 = 0 ;
32243   int res1 = 0 ;
32244   void *argp2 = 0 ;
32245   int res2 = 0 ;
32246   PyObject * obj0 = 0 ;
32247   PyObject * obj1 = 0 ;
32248
32249   if (!PyArg_ParseTuple(args,(char *)"OO:Propagation_addEdge",&obj0,&obj1)) SWIG_fail;
32250   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
32251   if (!SWIG_IsOK(res1)) {
32252     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_addEdge" "', argument " "1"" of type '" "Hex::Propagation *""'");
32253   }
32254   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32255   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Edge, 0 |  0 );
32256   if (!SWIG_IsOK(res2)) {
32257     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Propagation_addEdge" "', argument " "2"" of type '" "Hex::Edge *""'");
32258   }
32259   arg2 = reinterpret_cast< Hex::Edge * >(argp2);
32260   (arg1)->addEdge(arg2);
32261   resultobj = SWIG_Py_Void();
32262   return resultobj;
32263 fail:
32264   return NULL;
32265 }
32266
32267
32268 SWIGINTERN PyObject *_wrap_Propagation_majLaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32269   PyObject *resultobj = 0;
32270   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32271   void *argp1 = 0 ;
32272   int res1 = 0 ;
32273   PyObject * obj0 = 0 ;
32274
32275   if (!PyArg_ParseTuple(args,(char *)"O:Propagation_majLaw",&obj0)) SWIG_fail;
32276   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, 0 |  0 );
32277   if (!SWIG_IsOK(res1)) {
32278     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Propagation_majLaw" "', argument " "1"" of type '" "Hex::Propagation *""'");
32279   }
32280   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32281   (arg1)->majLaw();
32282   resultobj = SWIG_Py_Void();
32283   return resultobj;
32284 fail:
32285   return NULL;
32286 }
32287
32288
32289 SWIGINTERN PyObject *_wrap_delete_Propagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32290   PyObject *resultobj = 0;
32291   Hex::Propagation *arg1 = (Hex::Propagation *) 0 ;
32292   void *argp1 = 0 ;
32293   int res1 = 0 ;
32294   PyObject * obj0 = 0 ;
32295
32296   if (!PyArg_ParseTuple(args,(char *)"O:delete_Propagation",&obj0)) SWIG_fail;
32297   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Propagation, SWIG_POINTER_DISOWN |  0 );
32298   if (!SWIG_IsOK(res1)) {
32299     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Propagation" "', argument " "1"" of type '" "Hex::Propagation *""'");
32300   }
32301   arg1 = reinterpret_cast< Hex::Propagation * >(argp1);
32302   delete arg1;
32303   resultobj = SWIG_Py_Void();
32304   return resultobj;
32305 fail:
32306   return NULL;
32307 }
32308
32309
32310 SWIGINTERN PyObject *Propagation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32311   PyObject *obj;
32312   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
32313   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Propagation, SWIG_NewClientData(obj));
32314   return SWIG_Py_Void();
32315 }
32316
32317 SWIGINTERN PyObject *_wrap_hex_instance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32318   PyObject *resultobj = 0;
32319   Hex::Hex *result = 0 ;
32320
32321   if (!PyArg_ParseTuple(args,(char *)":hex_instance")) SWIG_fail;
32322   result = (Hex::Hex *)Hex::hex_instance();
32323   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 |  0 );
32324   return resultobj;
32325 fail:
32326   return NULL;
32327 }
32328
32329
32330 SWIGINTERN PyObject *_wrap_Hex_getInstance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32331   PyObject *resultobj = 0;
32332   Hex::Hex *result = 0 ;
32333
32334   if (!PyArg_ParseTuple(args,(char *)":Hex_getInstance")) SWIG_fail;
32335   result = (Hex::Hex *)Hex::Hex::getInstance();
32336   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, 0 |  0 );
32337   return resultobj;
32338 fail:
32339   return NULL;
32340 }
32341
32342
32343 SWIGINTERN PyObject *_wrap_Hex_countDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32344   PyObject *resultobj = 0;
32345   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32346   void *argp1 = 0 ;
32347   int res1 = 0 ;
32348   PyObject * obj0 = 0 ;
32349   int result;
32350
32351   if (!PyArg_ParseTuple(args,(char *)"O:Hex_countDocument",&obj0)) SWIG_fail;
32352   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
32353   if (!SWIG_IsOK(res1)) {
32354     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_countDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32355   }
32356   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32357   result = (int)(arg1)->countDocument();
32358   resultobj = SWIG_From_int(static_cast< int >(result));
32359   return resultobj;
32360 fail:
32361   return NULL;
32362 }
32363
32364
32365 SWIGINTERN PyObject *_wrap_Hex_getDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32366   PyObject *resultobj = 0;
32367   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32368   int arg2 ;
32369   void *argp1 = 0 ;
32370   int res1 = 0 ;
32371   int val2 ;
32372   int ecode2 = 0 ;
32373   PyObject * obj0 = 0 ;
32374   PyObject * obj1 = 0 ;
32375   Hex::Document *result = 0 ;
32376
32377   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getDocument",&obj0,&obj1)) SWIG_fail;
32378   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
32379   if (!SWIG_IsOK(res1)) {
32380     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32381   }
32382   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32383   ecode2 = SWIG_AsVal_int(obj1, &val2);
32384   if (!SWIG_IsOK(ecode2)) {
32385     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getDocument" "', argument " "2"" of type '" "int""'");
32386   }
32387   arg2 = static_cast< int >(val2);
32388   result = (Hex::Document *)(arg1)->getDocument(arg2);
32389   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
32390   return resultobj;
32391 fail:
32392   return NULL;
32393 }
32394
32395
32396 SWIGINTERN PyObject *_wrap_Hex_removeDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32397   PyObject *resultobj = 0;
32398   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32399   Hex::Document *arg2 = (Hex::Document *) 0 ;
32400   void *argp1 = 0 ;
32401   int res1 = 0 ;
32402   void *argp2 = 0 ;
32403   int res2 = 0 ;
32404   PyObject * obj0 = 0 ;
32405   PyObject * obj1 = 0 ;
32406
32407   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_removeDocument",&obj0,&obj1)) SWIG_fail;
32408   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
32409   if (!SWIG_IsOK(res1)) {
32410     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_removeDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32411   }
32412   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32413   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Document, 0 |  0 );
32414   if (!SWIG_IsOK(res2)) {
32415     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_removeDocument" "', argument " "2"" of type '" "Hex::Document *""'");
32416   }
32417   arg2 = reinterpret_cast< Hex::Document * >(argp2);
32418   (arg1)->removeDocument(arg2);
32419   resultobj = SWIG_Py_Void();
32420   return resultobj;
32421 fail:
32422   return NULL;
32423 }
32424
32425
32426 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32427   PyObject *resultobj = 0;
32428   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32429   cpchar arg2 = (cpchar) 0 ;
32430   void *argp1 = 0 ;
32431   int res1 = 0 ;
32432   int res2 ;
32433   char *buf2 = 0 ;
32434   int alloc2 = 0 ;
32435   PyObject * obj0 = 0 ;
32436   PyObject * obj1 = 0 ;
32437   Hex::Document *result = 0 ;
32438
32439   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_addDocument",&obj0,&obj1)) SWIG_fail;
32440   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
32441   if (!SWIG_IsOK(res1)) {
32442     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32443   }
32444   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32445   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32446   if (!SWIG_IsOK(res2)) {
32447     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_addDocument" "', argument " "2"" of type '" "cpchar""'");
32448   }
32449   arg2 = reinterpret_cast< cpchar >(buf2);
32450   result = (Hex::Document *)(arg1)->addDocument(arg2);
32451   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
32452   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32453   return resultobj;
32454 fail:
32455   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32456   return NULL;
32457 }
32458
32459
32460 SWIGINTERN PyObject *_wrap_Hex_addDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32461   PyObject *resultobj = 0;
32462   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32463   void *argp1 = 0 ;
32464   int res1 = 0 ;
32465   PyObject * obj0 = 0 ;
32466   Hex::Document *result = 0 ;
32467
32468   if (!PyArg_ParseTuple(args,(char *)"O:Hex_addDocument",&obj0)) SWIG_fail;
32469   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
32470   if (!SWIG_IsOK(res1)) {
32471     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_addDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32472   }
32473   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32474   result = (Hex::Document *)(arg1)->addDocument();
32475   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
32476   return resultobj;
32477 fail:
32478   return NULL;
32479 }
32480
32481
32482 SWIGINTERN PyObject *_wrap_Hex_addDocument(PyObject *self, PyObject *args) {
32483   Py_ssize_t argc;
32484   PyObject *argv[3] = {
32485     0
32486   };
32487   Py_ssize_t ii;
32488
32489   if (!PyTuple_Check(args)) SWIG_fail;
32490   argc = args ? PyObject_Length(args) : 0;
32491   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
32492     argv[ii] = PyTuple_GET_ITEM(args,ii);
32493   }
32494   if (argc == 1) {
32495     int _v;
32496     void *vptr = 0;
32497     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
32498     _v = SWIG_CheckState(res);
32499     if (_v) {
32500       return _wrap_Hex_addDocument__SWIG_1(self, args);
32501     }
32502   }
32503   if (argc == 2) {
32504     int _v;
32505     void *vptr = 0;
32506     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
32507     _v = SWIG_CheckState(res);
32508     if (_v) {
32509       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
32510       _v = SWIG_CheckState(res);
32511       if (_v) {
32512         return _wrap_Hex_addDocument__SWIG_0(self, args);
32513       }
32514     }
32515   }
32516
32517 fail:
32518   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hex_addDocument'.\n"
32519     "  Possible C/C++ prototypes are:\n"
32520     "    Hex::Hex::addDocument(cpchar)\n"
32521     "    Hex::Hex::addDocument()\n");
32522   return 0;
32523 }
32524
32525
32526 SWIGINTERN PyObject *_wrap_Hex_loadDocument(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32527   PyObject *resultobj = 0;
32528   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32529   cpchar arg2 = (cpchar) 0 ;
32530   void *argp1 = 0 ;
32531   int res1 = 0 ;
32532   int res2 ;
32533   char *buf2 = 0 ;
32534   int alloc2 = 0 ;
32535   PyObject * obj0 = 0 ;
32536   PyObject * obj1 = 0 ;
32537   Hex::Document *result = 0 ;
32538
32539   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_loadDocument",&obj0,&obj1)) SWIG_fail;
32540   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
32541   if (!SWIG_IsOK(res1)) {
32542     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_loadDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32543   }
32544   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32545   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32546   if (!SWIG_IsOK(res2)) {
32547     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_loadDocument" "', argument " "2"" of type '" "cpchar""'");
32548   }
32549   arg2 = reinterpret_cast< cpchar >(buf2);
32550   result = (Hex::Document *)(arg1)->loadDocument(arg2);
32551   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
32552   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32553   return resultobj;
32554 fail:
32555   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32556   return NULL;
32557 }
32558
32559
32560 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32561   PyObject *resultobj = 0;
32562   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32563   cpchar arg2 = (cpchar) 0 ;
32564   void *argp1 = 0 ;
32565   int res1 = 0 ;
32566   int res2 ;
32567   char *buf2 = 0 ;
32568   int alloc2 = 0 ;
32569   PyObject * obj0 = 0 ;
32570   PyObject * obj1 = 0 ;
32571   Hex::Document *result = 0 ;
32572
32573   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
32574   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
32575   if (!SWIG_IsOK(res1)) {
32576     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32577   }
32578   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32579   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32580   if (!SWIG_IsOK(res2)) {
32581     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "cpchar""'");
32582   }
32583   arg2 = reinterpret_cast< cpchar >(buf2);
32584   result = (Hex::Document *)(arg1)->findDocument(arg2);
32585   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
32586   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32587   return resultobj;
32588 fail:
32589   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
32590   return NULL;
32591 }
32592
32593
32594 SWIGINTERN PyObject *_wrap_Hex_findDocument__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32595   PyObject *resultobj = 0;
32596   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32597   std::string *arg2 = 0 ;
32598   void *argp1 = 0 ;
32599   int res1 = 0 ;
32600   void *argp2 = 0 ;
32601   int res2 = 0 ;
32602   PyObject * obj0 = 0 ;
32603   PyObject * obj1 = 0 ;
32604   Hex::Document *result = 0 ;
32605
32606   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_findDocument",&obj0,&obj1)) SWIG_fail;
32607   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
32608   if (!SWIG_IsOK(res1)) {
32609     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_findDocument" "', argument " "1"" of type '" "Hex::Hex *""'");
32610   }
32611   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32612   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_string,  0  | 0);
32613   if (!SWIG_IsOK(res2)) {
32614     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
32615   }
32616   if (!argp2) {
32617     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hex_findDocument" "', argument " "2"" of type '" "string const &""'");
32618   }
32619   arg2 = reinterpret_cast< std::string * >(argp2);
32620   result = (Hex::Document *)(arg1)->findDocument((std::string const &)*arg2);
32621   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Document, 0 |  0 );
32622   return resultobj;
32623 fail:
32624   return NULL;
32625 }
32626
32627
32628 SWIGINTERN PyObject *_wrap_Hex_findDocument(PyObject *self, PyObject *args) {
32629   Py_ssize_t argc;
32630   PyObject *argv[3] = {
32631     0
32632   };
32633   Py_ssize_t ii;
32634
32635   if (!PyTuple_Check(args)) SWIG_fail;
32636   argc = args ? PyObject_Length(args) : 0;
32637   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
32638     argv[ii] = PyTuple_GET_ITEM(args,ii);
32639   }
32640   if (argc == 2) {
32641     int _v;
32642     void *vptr = 0;
32643     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
32644     _v = SWIG_CheckState(res);
32645     if (_v) {
32646       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_string, 0);
32647       _v = SWIG_CheckState(res);
32648       if (_v) {
32649         return _wrap_Hex_findDocument__SWIG_1(self, args);
32650       }
32651     }
32652   }
32653   if (argc == 2) {
32654     int _v;
32655     void *vptr = 0;
32656     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Hex, 0);
32657     _v = SWIG_CheckState(res);
32658     if (_v) {
32659       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
32660       _v = SWIG_CheckState(res);
32661       if (_v) {
32662         return _wrap_Hex_findDocument__SWIG_0(self, args);
32663       }
32664     }
32665   }
32666
32667 fail:
32668   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Hex_findDocument'.\n"
32669     "  Possible C/C++ prototypes are:\n"
32670     "    Hex::Hex::findDocument(cpchar)\n"
32671     "    Hex::Hex::findDocument(string const &)\n");
32672   return 0;
32673 }
32674
32675
32676 SWIGINTERN PyObject *_wrap_Hex_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32677   PyObject *resultobj = 0;
32678   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32679   void *argp1 = 0 ;
32680   int res1 = 0 ;
32681   PyObject * obj0 = 0 ;
32682
32683   if (!PyArg_ParseTuple(args,(char *)"O:Hex_what",&obj0)) SWIG_fail;
32684   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
32685   if (!SWIG_IsOK(res1)) {
32686     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_what" "', argument " "1"" of type '" "Hex::Hex *""'");
32687   }
32688   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32689   (arg1)->what();
32690   resultobj = SWIG_Py_Void();
32691   return resultobj;
32692 fail:
32693   return NULL;
32694 }
32695
32696
32697 SWIGINTERN PyObject *_wrap_Hex_sizeofMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32698   PyObject *resultobj = 0;
32699   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32700   void *argp1 = 0 ;
32701   int res1 = 0 ;
32702   PyObject * obj0 = 0 ;
32703   int result;
32704
32705   if (!PyArg_ParseTuple(args,(char *)"O:Hex_sizeofMessage",&obj0)) SWIG_fail;
32706   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
32707   if (!SWIG_IsOK(res1)) {
32708     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_sizeofMessage" "', argument " "1"" of type '" "Hex::Hex *""'");
32709   }
32710   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32711   result = (int)(arg1)->sizeofMessage();
32712   resultobj = SWIG_From_int(static_cast< int >(result));
32713   return resultobj;
32714 fail:
32715   return NULL;
32716 }
32717
32718
32719 SWIGINTERN PyObject *_wrap_Hex_getMessageLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32720   PyObject *resultobj = 0;
32721   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32722   int arg2 ;
32723   void *argp1 = 0 ;
32724   int res1 = 0 ;
32725   int val2 ;
32726   int ecode2 = 0 ;
32727   PyObject * obj0 = 0 ;
32728   PyObject * obj1 = 0 ;
32729   cpchar result;
32730
32731   if (!PyArg_ParseTuple(args,(char *)"OO:Hex_getMessageLine",&obj0,&obj1)) SWIG_fail;
32732   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, 0 |  0 );
32733   if (!SWIG_IsOK(res1)) {
32734     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hex_getMessageLine" "', argument " "1"" of type '" "Hex::Hex *""'");
32735   }
32736   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32737   ecode2 = SWIG_AsVal_int(obj1, &val2);
32738   if (!SWIG_IsOK(ecode2)) {
32739     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hex_getMessageLine" "', argument " "2"" of type '" "int""'");
32740   }
32741   arg2 = static_cast< int >(val2);
32742   result = (cpchar)(arg1)->getMessageLine(arg2);
32743   resultobj = SWIG_FromCharPtr((const char *)result);
32744   return resultobj;
32745 fail:
32746   return NULL;
32747 }
32748
32749
32750 SWIGINTERN PyObject *_wrap_new_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32751   PyObject *resultobj = 0;
32752   Hex::Hex *result = 0 ;
32753
32754   if (!PyArg_ParseTuple(args,(char *)":new_Hex")) SWIG_fail;
32755   result = (Hex::Hex *)new Hex::Hex();
32756   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hex, SWIG_POINTER_NEW |  0 );
32757   return resultobj;
32758 fail:
32759   return NULL;
32760 }
32761
32762
32763 SWIGINTERN PyObject *_wrap_delete_Hex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32764   PyObject *resultobj = 0;
32765   Hex::Hex *arg1 = (Hex::Hex *) 0 ;
32766   void *argp1 = 0 ;
32767   int res1 = 0 ;
32768   PyObject * obj0 = 0 ;
32769
32770   if (!PyArg_ParseTuple(args,(char *)"O:delete_Hex",&obj0)) SWIG_fail;
32771   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Hex, SWIG_POINTER_DISOWN |  0 );
32772   if (!SWIG_IsOK(res1)) {
32773     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Hex" "', argument " "1"" of type '" "Hex::Hex *""'");
32774   }
32775   arg1 = reinterpret_cast< Hex::Hex * >(argp1);
32776   delete arg1;
32777   resultobj = SWIG_Py_Void();
32778   return resultobj;
32779 fail:
32780   return NULL;
32781 }
32782
32783
32784 SWIGINTERN PyObject *Hex_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32785   PyObject *obj;
32786   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
32787   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Hex, SWIG_NewClientData(obj));
32788   return SWIG_Py_Void();
32789 }
32790
32791 SWIGINTERN PyObject *_wrap_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32792   PyObject *resultobj = 0;
32793
32794   if (!PyArg_ParseTuple(args,(char *)":what")) SWIG_fail;
32795   Hex::what();
32796   resultobj = SWIG_Py_Void();
32797   return resultobj;
32798 fail:
32799   return NULL;
32800 }
32801
32802
32803 SWIGINTERN PyObject *_wrap_Elements_getHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32804   PyObject *resultobj = 0;
32805   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32806   int arg2 ;
32807   void *argp1 = 0 ;
32808   int res1 = 0 ;
32809   int val2 ;
32810   int ecode2 = 0 ;
32811   PyObject * obj0 = 0 ;
32812   PyObject * obj1 = 0 ;
32813   Hex::Hexa *result = 0 ;
32814
32815   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getHexa",&obj0,&obj1)) SWIG_fail;
32816   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
32817   if (!SWIG_IsOK(res1)) {
32818     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
32819   }
32820   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
32821   ecode2 = SWIG_AsVal_int(obj1, &val2);
32822   if (!SWIG_IsOK(ecode2)) {
32823     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexa" "', argument " "2"" of type '" "int""'");
32824   }
32825   arg2 = static_cast< int >(val2);
32826   result = (Hex::Hexa *)(arg1)->getHexa(arg2);
32827   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
32828   return resultobj;
32829 fail:
32830   return NULL;
32831 }
32832
32833
32834 SWIGINTERN PyObject *_wrap_Elements_getQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32835   PyObject *resultobj = 0;
32836   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32837   int arg2 ;
32838   void *argp1 = 0 ;
32839   int res1 = 0 ;
32840   int val2 ;
32841   int ecode2 = 0 ;
32842   PyObject * obj0 = 0 ;
32843   PyObject * obj1 = 0 ;
32844   Hex::Quad *result = 0 ;
32845
32846   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getQuad",&obj0,&obj1)) SWIG_fail;
32847   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
32848   if (!SWIG_IsOK(res1)) {
32849     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
32850   }
32851   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
32852   ecode2 = SWIG_AsVal_int(obj1, &val2);
32853   if (!SWIG_IsOK(ecode2)) {
32854     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuad" "', argument " "2"" of type '" "int""'");
32855   }
32856   arg2 = static_cast< int >(val2);
32857   result = (Hex::Quad *)(arg1)->getQuad(arg2);
32858   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
32859   return resultobj;
32860 fail:
32861   return NULL;
32862 }
32863
32864
32865 SWIGINTERN PyObject *_wrap_Elements_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32866   PyObject *resultobj = 0;
32867   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32868   int arg2 ;
32869   void *argp1 = 0 ;
32870   int res1 = 0 ;
32871   int val2 ;
32872   int ecode2 = 0 ;
32873   PyObject * obj0 = 0 ;
32874   PyObject * obj1 = 0 ;
32875   Hex::Edge *result = 0 ;
32876
32877   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getEdge",&obj0,&obj1)) SWIG_fail;
32878   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
32879   if (!SWIG_IsOK(res1)) {
32880     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
32881   }
32882   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
32883   ecode2 = SWIG_AsVal_int(obj1, &val2);
32884   if (!SWIG_IsOK(ecode2)) {
32885     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdge" "', argument " "2"" of type '" "int""'");
32886   }
32887   arg2 = static_cast< int >(val2);
32888   result = (Hex::Edge *)(arg1)->getEdge(arg2);
32889   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
32890   return resultobj;
32891 fail:
32892   return NULL;
32893 }
32894
32895
32896 SWIGINTERN PyObject *_wrap_Elements_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32897   PyObject *resultobj = 0;
32898   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32899   int arg2 ;
32900   void *argp1 = 0 ;
32901   int res1 = 0 ;
32902   int val2 ;
32903   int ecode2 = 0 ;
32904   PyObject * obj0 = 0 ;
32905   PyObject * obj1 = 0 ;
32906   Hex::Vertex *result = 0 ;
32907
32908   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_getVertex",&obj0,&obj1)) SWIG_fail;
32909   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
32910   if (!SWIG_IsOK(res1)) {
32911     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
32912   }
32913   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
32914   ecode2 = SWIG_AsVal_int(obj1, &val2);
32915   if (!SWIG_IsOK(ecode2)) {
32916     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertex" "', argument " "2"" of type '" "int""'");
32917   }
32918   arg2 = static_cast< int >(val2);
32919   result = (Hex::Vertex *)(arg1)->getVertex(arg2);
32920   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
32921   return resultobj;
32922 fail:
32923   return NULL;
32924 }
32925
32926
32927 SWIGINTERN PyObject *_wrap_Elements_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32928   PyObject *resultobj = 0;
32929   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32930   int arg2 ;
32931   int arg3 ;
32932   int arg4 ;
32933   void *argp1 = 0 ;
32934   int res1 = 0 ;
32935   int val2 ;
32936   int ecode2 = 0 ;
32937   int val3 ;
32938   int ecode3 = 0 ;
32939   int val4 ;
32940   int ecode4 = 0 ;
32941   PyObject * obj0 = 0 ;
32942   PyObject * obj1 = 0 ;
32943   PyObject * obj2 = 0 ;
32944   PyObject * obj3 = 0 ;
32945   Hex::Hexa *result = 0 ;
32946
32947   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getHexaIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32948   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
32949   if (!SWIG_IsOK(res1)) {
32950     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getHexaIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
32951   }
32952   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
32953   ecode2 = SWIG_AsVal_int(obj1, &val2);
32954   if (!SWIG_IsOK(ecode2)) {
32955     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getHexaIJK" "', argument " "2"" of type '" "int""'");
32956   }
32957   arg2 = static_cast< int >(val2);
32958   ecode3 = SWIG_AsVal_int(obj2, &val3);
32959   if (!SWIG_IsOK(ecode3)) {
32960     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getHexaIJK" "', argument " "3"" of type '" "int""'");
32961   }
32962   arg3 = static_cast< int >(val3);
32963   ecode4 = SWIG_AsVal_int(obj3, &val4);
32964   if (!SWIG_IsOK(ecode4)) {
32965     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getHexaIJK" "', argument " "4"" of type '" "int""'");
32966   }
32967   arg4 = static_cast< int >(val4);
32968   result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4);
32969   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
32970   return resultobj;
32971 fail:
32972   return NULL;
32973 }
32974
32975
32976 SWIGINTERN PyObject *_wrap_Elements_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32977   PyObject *resultobj = 0;
32978   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
32979   int arg2 ;
32980   int arg3 ;
32981   int arg4 ;
32982   void *argp1 = 0 ;
32983   int res1 = 0 ;
32984   int val2 ;
32985   int ecode2 = 0 ;
32986   int val3 ;
32987   int ecode3 = 0 ;
32988   int val4 ;
32989   int ecode4 = 0 ;
32990   PyObject * obj0 = 0 ;
32991   PyObject * obj1 = 0 ;
32992   PyObject * obj2 = 0 ;
32993   PyObject * obj3 = 0 ;
32994   Hex::Quad *result = 0 ;
32995
32996   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32997   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
32998   if (!SWIG_IsOK(res1)) {
32999     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIJ" "', argument " "1"" of type '" "Hex::Elements *""'");
33000   }
33001   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33002   ecode2 = SWIG_AsVal_int(obj1, &val2);
33003   if (!SWIG_IsOK(ecode2)) {
33004     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIJ" "', argument " "2"" of type '" "int""'");
33005   }
33006   arg2 = static_cast< int >(val2);
33007   ecode3 = SWIG_AsVal_int(obj2, &val3);
33008   if (!SWIG_IsOK(ecode3)) {
33009     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIJ" "', argument " "3"" of type '" "int""'");
33010   }
33011   arg3 = static_cast< int >(val3);
33012   ecode4 = SWIG_AsVal_int(obj3, &val4);
33013   if (!SWIG_IsOK(ecode4)) {
33014     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIJ" "', argument " "4"" of type '" "int""'");
33015   }
33016   arg4 = static_cast< int >(val4);
33017   result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4);
33018   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
33019   return resultobj;
33020 fail:
33021   return NULL;
33022 }
33023
33024
33025 SWIGINTERN PyObject *_wrap_Elements_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33026   PyObject *resultobj = 0;
33027   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33028   int arg2 ;
33029   int arg3 ;
33030   int arg4 ;
33031   void *argp1 = 0 ;
33032   int res1 = 0 ;
33033   int val2 ;
33034   int ecode2 = 0 ;
33035   int val3 ;
33036   int ecode3 = 0 ;
33037   int val4 ;
33038   int ecode4 = 0 ;
33039   PyObject * obj0 = 0 ;
33040   PyObject * obj1 = 0 ;
33041   PyObject * obj2 = 0 ;
33042   PyObject * obj3 = 0 ;
33043   Hex::Quad *result = 0 ;
33044
33045   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33046   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33047   if (!SWIG_IsOK(res1)) {
33048     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadJK" "', argument " "1"" of type '" "Hex::Elements *""'");
33049   }
33050   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33051   ecode2 = SWIG_AsVal_int(obj1, &val2);
33052   if (!SWIG_IsOK(ecode2)) {
33053     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadJK" "', argument " "2"" of type '" "int""'");
33054   }
33055   arg2 = static_cast< int >(val2);
33056   ecode3 = SWIG_AsVal_int(obj2, &val3);
33057   if (!SWIG_IsOK(ecode3)) {
33058     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadJK" "', argument " "3"" of type '" "int""'");
33059   }
33060   arg3 = static_cast< int >(val3);
33061   ecode4 = SWIG_AsVal_int(obj3, &val4);
33062   if (!SWIG_IsOK(ecode4)) {
33063     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadJK" "', argument " "4"" of type '" "int""'");
33064   }
33065   arg4 = static_cast< int >(val4);
33066   result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4);
33067   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
33068   return resultobj;
33069 fail:
33070   return NULL;
33071 }
33072
33073
33074 SWIGINTERN PyObject *_wrap_Elements_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33075   PyObject *resultobj = 0;
33076   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33077   int arg2 ;
33078   int arg3 ;
33079   int arg4 ;
33080   void *argp1 = 0 ;
33081   int res1 = 0 ;
33082   int val2 ;
33083   int ecode2 = 0 ;
33084   int val3 ;
33085   int ecode3 = 0 ;
33086   int val4 ;
33087   int ecode4 = 0 ;
33088   PyObject * obj0 = 0 ;
33089   PyObject * obj1 = 0 ;
33090   PyObject * obj2 = 0 ;
33091   PyObject * obj3 = 0 ;
33092   Hex::Quad *result = 0 ;
33093
33094   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getQuadIK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33095   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33096   if (!SWIG_IsOK(res1)) {
33097     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getQuadIK" "', argument " "1"" of type '" "Hex::Elements *""'");
33098   }
33099   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33100   ecode2 = SWIG_AsVal_int(obj1, &val2);
33101   if (!SWIG_IsOK(ecode2)) {
33102     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getQuadIK" "', argument " "2"" of type '" "int""'");
33103   }
33104   arg2 = static_cast< int >(val2);
33105   ecode3 = SWIG_AsVal_int(obj2, &val3);
33106   if (!SWIG_IsOK(ecode3)) {
33107     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getQuadIK" "', argument " "3"" of type '" "int""'");
33108   }
33109   arg3 = static_cast< int >(val3);
33110   ecode4 = SWIG_AsVal_int(obj3, &val4);
33111   if (!SWIG_IsOK(ecode4)) {
33112     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getQuadIK" "', argument " "4"" of type '" "int""'");
33113   }
33114   arg4 = static_cast< int >(val4);
33115   result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4);
33116   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
33117   return resultobj;
33118 fail:
33119   return NULL;
33120 }
33121
33122
33123 SWIGINTERN PyObject *_wrap_Elements_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33124   PyObject *resultobj = 0;
33125   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33126   int arg2 ;
33127   int arg3 ;
33128   int arg4 ;
33129   void *argp1 = 0 ;
33130   int res1 = 0 ;
33131   int val2 ;
33132   int ecode2 = 0 ;
33133   int val3 ;
33134   int ecode3 = 0 ;
33135   int val4 ;
33136   int ecode4 = 0 ;
33137   PyObject * obj0 = 0 ;
33138   PyObject * obj1 = 0 ;
33139   PyObject * obj2 = 0 ;
33140   PyObject * obj3 = 0 ;
33141   Hex::Edge *result = 0 ;
33142
33143   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeI",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33144   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33145   if (!SWIG_IsOK(res1)) {
33146     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeI" "', argument " "1"" of type '" "Hex::Elements *""'");
33147   }
33148   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33149   ecode2 = SWIG_AsVal_int(obj1, &val2);
33150   if (!SWIG_IsOK(ecode2)) {
33151     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeI" "', argument " "2"" of type '" "int""'");
33152   }
33153   arg2 = static_cast< int >(val2);
33154   ecode3 = SWIG_AsVal_int(obj2, &val3);
33155   if (!SWIG_IsOK(ecode3)) {
33156     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeI" "', argument " "3"" of type '" "int""'");
33157   }
33158   arg3 = static_cast< int >(val3);
33159   ecode4 = SWIG_AsVal_int(obj3, &val4);
33160   if (!SWIG_IsOK(ecode4)) {
33161     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeI" "', argument " "4"" of type '" "int""'");
33162   }
33163   arg4 = static_cast< int >(val4);
33164   result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4);
33165   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
33166   return resultobj;
33167 fail:
33168   return NULL;
33169 }
33170
33171
33172 SWIGINTERN PyObject *_wrap_Elements_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33173   PyObject *resultobj = 0;
33174   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33175   int arg2 ;
33176   int arg3 ;
33177   int arg4 ;
33178   void *argp1 = 0 ;
33179   int res1 = 0 ;
33180   int val2 ;
33181   int ecode2 = 0 ;
33182   int val3 ;
33183   int ecode3 = 0 ;
33184   int val4 ;
33185   int ecode4 = 0 ;
33186   PyObject * obj0 = 0 ;
33187   PyObject * obj1 = 0 ;
33188   PyObject * obj2 = 0 ;
33189   PyObject * obj3 = 0 ;
33190   Hex::Edge *result = 0 ;
33191
33192   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeJ",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33193   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33194   if (!SWIG_IsOK(res1)) {
33195     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeJ" "', argument " "1"" of type '" "Hex::Elements *""'");
33196   }
33197   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33198   ecode2 = SWIG_AsVal_int(obj1, &val2);
33199   if (!SWIG_IsOK(ecode2)) {
33200     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeJ" "', argument " "2"" of type '" "int""'");
33201   }
33202   arg2 = static_cast< int >(val2);
33203   ecode3 = SWIG_AsVal_int(obj2, &val3);
33204   if (!SWIG_IsOK(ecode3)) {
33205     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeJ" "', argument " "3"" of type '" "int""'");
33206   }
33207   arg3 = static_cast< int >(val3);
33208   ecode4 = SWIG_AsVal_int(obj3, &val4);
33209   if (!SWIG_IsOK(ecode4)) {
33210     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeJ" "', argument " "4"" of type '" "int""'");
33211   }
33212   arg4 = static_cast< int >(val4);
33213   result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4);
33214   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
33215   return resultobj;
33216 fail:
33217   return NULL;
33218 }
33219
33220
33221 SWIGINTERN PyObject *_wrap_Elements_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33222   PyObject *resultobj = 0;
33223   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33224   int arg2 ;
33225   int arg3 ;
33226   int arg4 ;
33227   void *argp1 = 0 ;
33228   int res1 = 0 ;
33229   int val2 ;
33230   int ecode2 = 0 ;
33231   int val3 ;
33232   int ecode3 = 0 ;
33233   int val4 ;
33234   int ecode4 = 0 ;
33235   PyObject * obj0 = 0 ;
33236   PyObject * obj1 = 0 ;
33237   PyObject * obj2 = 0 ;
33238   PyObject * obj3 = 0 ;
33239   Hex::Edge *result = 0 ;
33240
33241   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getEdgeK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33242   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33243   if (!SWIG_IsOK(res1)) {
33244     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getEdgeK" "', argument " "1"" of type '" "Hex::Elements *""'");
33245   }
33246   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33247   ecode2 = SWIG_AsVal_int(obj1, &val2);
33248   if (!SWIG_IsOK(ecode2)) {
33249     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getEdgeK" "', argument " "2"" of type '" "int""'");
33250   }
33251   arg2 = static_cast< int >(val2);
33252   ecode3 = SWIG_AsVal_int(obj2, &val3);
33253   if (!SWIG_IsOK(ecode3)) {
33254     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getEdgeK" "', argument " "3"" of type '" "int""'");
33255   }
33256   arg3 = static_cast< int >(val3);
33257   ecode4 = SWIG_AsVal_int(obj3, &val4);
33258   if (!SWIG_IsOK(ecode4)) {
33259     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getEdgeK" "', argument " "4"" of type '" "int""'");
33260   }
33261   arg4 = static_cast< int >(val4);
33262   result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4);
33263   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
33264   return resultobj;
33265 fail:
33266   return NULL;
33267 }
33268
33269
33270 SWIGINTERN PyObject *_wrap_Elements_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33271   PyObject *resultobj = 0;
33272   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33273   int arg2 ;
33274   int arg3 ;
33275   int arg4 ;
33276   void *argp1 = 0 ;
33277   int res1 = 0 ;
33278   int val2 ;
33279   int ecode2 = 0 ;
33280   int val3 ;
33281   int ecode3 = 0 ;
33282   int val4 ;
33283   int ecode4 = 0 ;
33284   PyObject * obj0 = 0 ;
33285   PyObject * obj1 = 0 ;
33286   PyObject * obj2 = 0 ;
33287   PyObject * obj3 = 0 ;
33288   Hex::Vertex *result = 0 ;
33289
33290   if (!PyArg_ParseTuple(args,(char *)"OOOO:Elements_getVertexIJK",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33291   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33292   if (!SWIG_IsOK(res1)) {
33293     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_getVertexIJK" "', argument " "1"" of type '" "Hex::Elements *""'");
33294   }
33295   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33296   ecode2 = SWIG_AsVal_int(obj1, &val2);
33297   if (!SWIG_IsOK(ecode2)) {
33298     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elements_getVertexIJK" "', argument " "2"" of type '" "int""'");
33299   }
33300   arg2 = static_cast< int >(val2);
33301   ecode3 = SWIG_AsVal_int(obj2, &val3);
33302   if (!SWIG_IsOK(ecode3)) {
33303     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Elements_getVertexIJK" "', argument " "3"" of type '" "int""'");
33304   }
33305   arg3 = static_cast< int >(val3);
33306   ecode4 = SWIG_AsVal_int(obj3, &val4);
33307   if (!SWIG_IsOK(ecode4)) {
33308     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Elements_getVertexIJK" "', argument " "4"" of type '" "int""'");
33309   }
33310   arg4 = static_cast< int >(val4);
33311   result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4);
33312   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
33313   return resultobj;
33314 fail:
33315   return NULL;
33316 }
33317
33318
33319 SWIGINTERN PyObject *_wrap_Elements_countHexa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33320   PyObject *resultobj = 0;
33321   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33322   void *argp1 = 0 ;
33323   int res1 = 0 ;
33324   PyObject * obj0 = 0 ;
33325   int result;
33326
33327   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countHexa",&obj0)) SWIG_fail;
33328   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33329   if (!SWIG_IsOK(res1)) {
33330     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countHexa" "', argument " "1"" of type '" "Hex::Elements *""'");
33331   }
33332   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33333   result = (int)(arg1)->countHexa();
33334   resultobj = SWIG_From_int(static_cast< int >(result));
33335   return resultobj;
33336 fail:
33337   return NULL;
33338 }
33339
33340
33341 SWIGINTERN PyObject *_wrap_Elements_countQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33342   PyObject *resultobj = 0;
33343   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33344   void *argp1 = 0 ;
33345   int res1 = 0 ;
33346   PyObject * obj0 = 0 ;
33347   int result;
33348
33349   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countQuad",&obj0)) SWIG_fail;
33350   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33351   if (!SWIG_IsOK(res1)) {
33352     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countQuad" "', argument " "1"" of type '" "Hex::Elements *""'");
33353   }
33354   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33355   result = (int)(arg1)->countQuad();
33356   resultobj = SWIG_From_int(static_cast< int >(result));
33357   return resultobj;
33358 fail:
33359   return NULL;
33360 }
33361
33362
33363 SWIGINTERN PyObject *_wrap_Elements_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33364   PyObject *resultobj = 0;
33365   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33366   void *argp1 = 0 ;
33367   int res1 = 0 ;
33368   PyObject * obj0 = 0 ;
33369   int result;
33370
33371   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countEdge",&obj0)) SWIG_fail;
33372   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33373   if (!SWIG_IsOK(res1)) {
33374     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countEdge" "', argument " "1"" of type '" "Hex::Elements *""'");
33375   }
33376   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33377   result = (int)(arg1)->countEdge();
33378   resultobj = SWIG_From_int(static_cast< int >(result));
33379   return resultobj;
33380 fail:
33381   return NULL;
33382 }
33383
33384
33385 SWIGINTERN PyObject *_wrap_Elements_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33386   PyObject *resultobj = 0;
33387   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33388   void *argp1 = 0 ;
33389   int res1 = 0 ;
33390   PyObject * obj0 = 0 ;
33391   int result;
33392
33393   if (!PyArg_ParseTuple(args,(char *)"O:Elements_countVertex",&obj0)) SWIG_fail;
33394   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33395   if (!SWIG_IsOK(res1)) {
33396     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_countVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
33397   }
33398   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33399   result = (int)(arg1)->countVertex();
33400   resultobj = SWIG_From_int(static_cast< int >(result));
33401   return resultobj;
33402 fail:
33403   return NULL;
33404 }
33405
33406
33407 SWIGINTERN PyObject *_wrap_Elements_nearestVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33408   PyObject *resultobj = 0;
33409   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33410   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
33411   void *argp1 = 0 ;
33412   int res1 = 0 ;
33413   void *argp2 = 0 ;
33414   int res2 = 0 ;
33415   PyObject * obj0 = 0 ;
33416   PyObject * obj1 = 0 ;
33417   Hex::Vertex *result = 0 ;
33418
33419   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_nearestVertex",&obj0,&obj1)) SWIG_fail;
33420   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33421   if (!SWIG_IsOK(res1)) {
33422     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_nearestVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
33423   }
33424   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33425   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
33426   if (!SWIG_IsOK(res2)) {
33427     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_nearestVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
33428   }
33429   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
33430   result = (Hex::Vertex *)(arg1)->nearestVertex(arg2);
33431   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
33432   return resultobj;
33433 fail:
33434   return NULL;
33435 }
33436
33437
33438 SWIGINTERN PyObject *_wrap_Elements_findVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33439   PyObject *resultobj = 0;
33440   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33441   Hex::Vertex *arg2 = (Hex::Vertex *) 0 ;
33442   void *argp1 = 0 ;
33443   int res1 = 0 ;
33444   void *argp2 = 0 ;
33445   int res2 = 0 ;
33446   PyObject * obj0 = 0 ;
33447   PyObject * obj1 = 0 ;
33448   int result;
33449
33450   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_findVertex",&obj0,&obj1)) SWIG_fail;
33451   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33452   if (!SWIG_IsOK(res1)) {
33453     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_findVertex" "', argument " "1"" of type '" "Hex::Elements *""'");
33454   }
33455   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33456   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__Vertex, 0 |  0 );
33457   if (!SWIG_IsOK(res2)) {
33458     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_findVertex" "', argument " "2"" of type '" "Hex::Vertex *""'");
33459   }
33460   arg2 = reinterpret_cast< Hex::Vertex * >(argp2);
33461   result = (int)(arg1)->findVertex(arg2);
33462   resultobj = SWIG_From_int(static_cast< int >(result));
33463   return resultobj;
33464 fail:
33465   return NULL;
33466 }
33467
33468
33469 SWIGINTERN PyObject *_wrap_Elements_clearAssociation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33470   PyObject *resultobj = 0;
33471   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33472   void *argp1 = 0 ;
33473   int res1 = 0 ;
33474   PyObject * obj0 = 0 ;
33475
33476   if (!PyArg_ParseTuple(args,(char *)"O:Elements_clearAssociation",&obj0)) SWIG_fail;
33477   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33478   if (!SWIG_IsOK(res1)) {
33479     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_clearAssociation" "', argument " "1"" of type '" "Hex::Elements *""'");
33480   }
33481   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33482   (arg1)->clearAssociation();
33483   resultobj = SWIG_Py_Void();
33484   return resultobj;
33485 fail:
33486   return NULL;
33487 }
33488
33489
33490 SWIGINTERN PyObject *_wrap_Elements_saveVtk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33491   PyObject *resultobj = 0;
33492   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33493   cpchar arg2 = (cpchar) 0 ;
33494   void *argp1 = 0 ;
33495   int res1 = 0 ;
33496   int res2 ;
33497   char *buf2 = 0 ;
33498   int alloc2 = 0 ;
33499   PyObject * obj0 = 0 ;
33500   PyObject * obj1 = 0 ;
33501   int result;
33502
33503   if (!PyArg_ParseTuple(args,(char *)"OO:Elements_saveVtk",&obj0,&obj1)) SWIG_fail;
33504   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, 0 |  0 );
33505   if (!SWIG_IsOK(res1)) {
33506     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elements_saveVtk" "', argument " "1"" of type '" "Hex::Elements *""'");
33507   }
33508   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33509   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
33510   if (!SWIG_IsOK(res2)) {
33511     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elements_saveVtk" "', argument " "2"" of type '" "cpchar""'");
33512   }
33513   arg2 = reinterpret_cast< cpchar >(buf2);
33514   result = (int)(arg1)->saveVtk(arg2);
33515   resultobj = SWIG_From_int(static_cast< int >(result));
33516   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33517   return resultobj;
33518 fail:
33519   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
33520   return NULL;
33521 }
33522
33523
33524 SWIGINTERN PyObject *_wrap_new_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33525   PyObject *resultobj = 0;
33526   Hex::Document *arg1 = (Hex::Document *) 0 ;
33527   void *argp1 = 0 ;
33528   int res1 = 0 ;
33529   PyObject * obj0 = 0 ;
33530   Hex::Elements *result = 0 ;
33531
33532   if (!PyArg_ParseTuple(args,(char *)"O:new_Elements",&obj0)) SWIG_fail;
33533   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
33534   if (!SWIG_IsOK(res1)) {
33535     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Elements" "', argument " "1"" of type '" "Hex::Document *""'");
33536   }
33537   arg1 = reinterpret_cast< Hex::Document * >(argp1);
33538   result = (Hex::Elements *)new Hex::Elements(arg1);
33539   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Elements, SWIG_POINTER_NEW |  0 );
33540   return resultobj;
33541 fail:
33542   return NULL;
33543 }
33544
33545
33546 SWIGINTERN PyObject *_wrap_delete_Elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33547   PyObject *resultobj = 0;
33548   Hex::Elements *arg1 = (Hex::Elements *) 0 ;
33549   void *argp1 = 0 ;
33550   int res1 = 0 ;
33551   PyObject * obj0 = 0 ;
33552
33553   if (!PyArg_ParseTuple(args,(char *)"O:delete_Elements",&obj0)) SWIG_fail;
33554   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Elements, SWIG_POINTER_DISOWN |  0 );
33555   if (!SWIG_IsOK(res1)) {
33556     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Elements" "', argument " "1"" of type '" "Hex::Elements *""'");
33557   }
33558   arg1 = reinterpret_cast< Hex::Elements * >(argp1);
33559   delete arg1;
33560   resultobj = SWIG_Py_Void();
33561   return resultobj;
33562 fail:
33563   return NULL;
33564 }
33565
33566
33567 SWIGINTERN PyObject *Elements_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33568   PyObject *obj;
33569   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
33570   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Elements, SWIG_NewClientData(obj));
33571   return SWIG_Py_Void();
33572 }
33573
33574 SWIGINTERN PyObject *_wrap_new_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33575   PyObject *resultobj = 0;
33576   Hex::Document *arg1 = (Hex::Document *) 0 ;
33577   void *argp1 = 0 ;
33578   int res1 = 0 ;
33579   PyObject * obj0 = 0 ;
33580   Hex::BiCylinder *result = 0 ;
33581
33582   if (!PyArg_ParseTuple(args,(char *)"O:new_BiCylinder",&obj0)) SWIG_fail;
33583   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
33584   if (!SWIG_IsOK(res1)) {
33585     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BiCylinder" "', argument " "1"" of type '" "Hex::Document *""'");
33586   }
33587   arg1 = reinterpret_cast< Hex::Document * >(argp1);
33588   result = (Hex::BiCylinder *)new Hex::BiCylinder(arg1);
33589   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_NEW |  0 );
33590   return resultobj;
33591 fail:
33592   return NULL;
33593 }
33594
33595
33596 SWIGINTERN PyObject *_wrap_BiCylinder_getHexaIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33597   PyObject *resultobj = 0;
33598   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33599   int arg2 ;
33600   int arg3 ;
33601   int arg4 ;
33602   int arg5 ;
33603   void *argp1 = 0 ;
33604   int res1 = 0 ;
33605   int val2 ;
33606   int ecode2 = 0 ;
33607   int val3 ;
33608   int ecode3 = 0 ;
33609   int val4 ;
33610   int ecode4 = 0 ;
33611   int val5 ;
33612   int ecode5 = 0 ;
33613   PyObject * obj0 = 0 ;
33614   PyObject * obj1 = 0 ;
33615   PyObject * obj2 = 0 ;
33616   PyObject * obj3 = 0 ;
33617   PyObject * obj4 = 0 ;
33618   Hex::Hexa *result = 0 ;
33619
33620   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getHexaIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33621   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
33622   if (!SWIG_IsOK(res1)) {
33623     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getHexaIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33624   }
33625   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33626   ecode2 = SWIG_AsVal_int(obj1, &val2);
33627   if (!SWIG_IsOK(ecode2)) {
33628     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getHexaIJK" "', argument " "2"" of type '" "int""'");
33629   }
33630   arg2 = static_cast< int >(val2);
33631   ecode3 = SWIG_AsVal_int(obj2, &val3);
33632   if (!SWIG_IsOK(ecode3)) {
33633     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getHexaIJK" "', argument " "3"" of type '" "int""'");
33634   }
33635   arg3 = static_cast< int >(val3);
33636   ecode4 = SWIG_AsVal_int(obj3, &val4);
33637   if (!SWIG_IsOK(ecode4)) {
33638     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getHexaIJK" "', argument " "4"" of type '" "int""'");
33639   }
33640   arg4 = static_cast< int >(val4);
33641   ecode5 = SWIG_AsVal_int(obj4, &val5);
33642   if (!SWIG_IsOK(ecode5)) {
33643     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getHexaIJK" "', argument " "5"" of type '" "int""'");
33644   }
33645   arg5 = static_cast< int >(val5);
33646   result = (Hex::Hexa *)(arg1)->getHexaIJK(arg2,arg3,arg4,arg5);
33647   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Hexa, 0 |  0 );
33648   return resultobj;
33649 fail:
33650   return NULL;
33651 }
33652
33653
33654 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33655   PyObject *resultobj = 0;
33656   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33657   int arg2 ;
33658   int arg3 ;
33659   int arg4 ;
33660   int arg5 ;
33661   void *argp1 = 0 ;
33662   int res1 = 0 ;
33663   int val2 ;
33664   int ecode2 = 0 ;
33665   int val3 ;
33666   int ecode3 = 0 ;
33667   int val4 ;
33668   int ecode4 = 0 ;
33669   int val5 ;
33670   int ecode5 = 0 ;
33671   PyObject * obj0 = 0 ;
33672   PyObject * obj1 = 0 ;
33673   PyObject * obj2 = 0 ;
33674   PyObject * obj3 = 0 ;
33675   PyObject * obj4 = 0 ;
33676   Hex::Quad *result = 0 ;
33677
33678   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33679   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
33680   if (!SWIG_IsOK(res1)) {
33681     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33682   }
33683   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33684   ecode2 = SWIG_AsVal_int(obj1, &val2);
33685   if (!SWIG_IsOK(ecode2)) {
33686     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIJ" "', argument " "2"" of type '" "int""'");
33687   }
33688   arg2 = static_cast< int >(val2);
33689   ecode3 = SWIG_AsVal_int(obj2, &val3);
33690   if (!SWIG_IsOK(ecode3)) {
33691     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIJ" "', argument " "3"" of type '" "int""'");
33692   }
33693   arg3 = static_cast< int >(val3);
33694   ecode4 = SWIG_AsVal_int(obj3, &val4);
33695   if (!SWIG_IsOK(ecode4)) {
33696     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIJ" "', argument " "4"" of type '" "int""'");
33697   }
33698   arg4 = static_cast< int >(val4);
33699   ecode5 = SWIG_AsVal_int(obj4, &val5);
33700   if (!SWIG_IsOK(ecode5)) {
33701     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIJ" "', argument " "5"" of type '" "int""'");
33702   }
33703   arg5 = static_cast< int >(val5);
33704   result = (Hex::Quad *)(arg1)->getQuadIJ(arg2,arg3,arg4,arg5);
33705   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
33706   return resultobj;
33707 fail:
33708   return NULL;
33709 }
33710
33711
33712 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33713   PyObject *resultobj = 0;
33714   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33715   int arg2 ;
33716   int arg3 ;
33717   int arg4 ;
33718   int arg5 ;
33719   void *argp1 = 0 ;
33720   int res1 = 0 ;
33721   int val2 ;
33722   int ecode2 = 0 ;
33723   int val3 ;
33724   int ecode3 = 0 ;
33725   int val4 ;
33726   int ecode4 = 0 ;
33727   int val5 ;
33728   int ecode5 = 0 ;
33729   PyObject * obj0 = 0 ;
33730   PyObject * obj1 = 0 ;
33731   PyObject * obj2 = 0 ;
33732   PyObject * obj3 = 0 ;
33733   PyObject * obj4 = 0 ;
33734   Hex::Quad *result = 0 ;
33735
33736   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33737   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
33738   if (!SWIG_IsOK(res1)) {
33739     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33740   }
33741   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33742   ecode2 = SWIG_AsVal_int(obj1, &val2);
33743   if (!SWIG_IsOK(ecode2)) {
33744     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadJK" "', argument " "2"" of type '" "int""'");
33745   }
33746   arg2 = static_cast< int >(val2);
33747   ecode3 = SWIG_AsVal_int(obj2, &val3);
33748   if (!SWIG_IsOK(ecode3)) {
33749     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadJK" "', argument " "3"" of type '" "int""'");
33750   }
33751   arg3 = static_cast< int >(val3);
33752   ecode4 = SWIG_AsVal_int(obj3, &val4);
33753   if (!SWIG_IsOK(ecode4)) {
33754     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadJK" "', argument " "4"" of type '" "int""'");
33755   }
33756   arg4 = static_cast< int >(val4);
33757   ecode5 = SWIG_AsVal_int(obj4, &val5);
33758   if (!SWIG_IsOK(ecode5)) {
33759     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadJK" "', argument " "5"" of type '" "int""'");
33760   }
33761   arg5 = static_cast< int >(val5);
33762   result = (Hex::Quad *)(arg1)->getQuadJK(arg2,arg3,arg4,arg5);
33763   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
33764   return resultobj;
33765 fail:
33766   return NULL;
33767 }
33768
33769
33770 SWIGINTERN PyObject *_wrap_BiCylinder_getQuadIK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33771   PyObject *resultobj = 0;
33772   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33773   int arg2 ;
33774   int arg3 ;
33775   int arg4 ;
33776   int arg5 ;
33777   void *argp1 = 0 ;
33778   int res1 = 0 ;
33779   int val2 ;
33780   int ecode2 = 0 ;
33781   int val3 ;
33782   int ecode3 = 0 ;
33783   int val4 ;
33784   int ecode4 = 0 ;
33785   int val5 ;
33786   int ecode5 = 0 ;
33787   PyObject * obj0 = 0 ;
33788   PyObject * obj1 = 0 ;
33789   PyObject * obj2 = 0 ;
33790   PyObject * obj3 = 0 ;
33791   PyObject * obj4 = 0 ;
33792   Hex::Quad *result = 0 ;
33793
33794   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getQuadIK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33795   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
33796   if (!SWIG_IsOK(res1)) {
33797     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getQuadIK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33798   }
33799   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33800   ecode2 = SWIG_AsVal_int(obj1, &val2);
33801   if (!SWIG_IsOK(ecode2)) {
33802     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getQuadIK" "', argument " "2"" of type '" "int""'");
33803   }
33804   arg2 = static_cast< int >(val2);
33805   ecode3 = SWIG_AsVal_int(obj2, &val3);
33806   if (!SWIG_IsOK(ecode3)) {
33807     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getQuadIK" "', argument " "3"" of type '" "int""'");
33808   }
33809   arg3 = static_cast< int >(val3);
33810   ecode4 = SWIG_AsVal_int(obj3, &val4);
33811   if (!SWIG_IsOK(ecode4)) {
33812     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getQuadIK" "', argument " "4"" of type '" "int""'");
33813   }
33814   arg4 = static_cast< int >(val4);
33815   ecode5 = SWIG_AsVal_int(obj4, &val5);
33816   if (!SWIG_IsOK(ecode5)) {
33817     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getQuadIK" "', argument " "5"" of type '" "int""'");
33818   }
33819   arg5 = static_cast< int >(val5);
33820   result = (Hex::Quad *)(arg1)->getQuadIK(arg2,arg3,arg4,arg5);
33821   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Quad, 0 |  0 );
33822   return resultobj;
33823 fail:
33824   return NULL;
33825 }
33826
33827
33828 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33829   PyObject *resultobj = 0;
33830   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33831   int arg2 ;
33832   int arg3 ;
33833   int arg4 ;
33834   int arg5 ;
33835   void *argp1 = 0 ;
33836   int res1 = 0 ;
33837   int val2 ;
33838   int ecode2 = 0 ;
33839   int val3 ;
33840   int ecode3 = 0 ;
33841   int val4 ;
33842   int ecode4 = 0 ;
33843   int val5 ;
33844   int ecode5 = 0 ;
33845   PyObject * obj0 = 0 ;
33846   PyObject * obj1 = 0 ;
33847   PyObject * obj2 = 0 ;
33848   PyObject * obj3 = 0 ;
33849   PyObject * obj4 = 0 ;
33850   Hex::Edge *result = 0 ;
33851
33852   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeI",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33853   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
33854   if (!SWIG_IsOK(res1)) {
33855     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeI" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33856   }
33857   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33858   ecode2 = SWIG_AsVal_int(obj1, &val2);
33859   if (!SWIG_IsOK(ecode2)) {
33860     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeI" "', argument " "2"" of type '" "int""'");
33861   }
33862   arg2 = static_cast< int >(val2);
33863   ecode3 = SWIG_AsVal_int(obj2, &val3);
33864   if (!SWIG_IsOK(ecode3)) {
33865     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeI" "', argument " "3"" of type '" "int""'");
33866   }
33867   arg3 = static_cast< int >(val3);
33868   ecode4 = SWIG_AsVal_int(obj3, &val4);
33869   if (!SWIG_IsOK(ecode4)) {
33870     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeI" "', argument " "4"" of type '" "int""'");
33871   }
33872   arg4 = static_cast< int >(val4);
33873   ecode5 = SWIG_AsVal_int(obj4, &val5);
33874   if (!SWIG_IsOK(ecode5)) {
33875     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeI" "', argument " "5"" of type '" "int""'");
33876   }
33877   arg5 = static_cast< int >(val5);
33878   result = (Hex::Edge *)(arg1)->getEdgeI(arg2,arg3,arg4,arg5);
33879   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
33880   return resultobj;
33881 fail:
33882   return NULL;
33883 }
33884
33885
33886 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33887   PyObject *resultobj = 0;
33888   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33889   int arg2 ;
33890   int arg3 ;
33891   int arg4 ;
33892   int arg5 ;
33893   void *argp1 = 0 ;
33894   int res1 = 0 ;
33895   int val2 ;
33896   int ecode2 = 0 ;
33897   int val3 ;
33898   int ecode3 = 0 ;
33899   int val4 ;
33900   int ecode4 = 0 ;
33901   int val5 ;
33902   int ecode5 = 0 ;
33903   PyObject * obj0 = 0 ;
33904   PyObject * obj1 = 0 ;
33905   PyObject * obj2 = 0 ;
33906   PyObject * obj3 = 0 ;
33907   PyObject * obj4 = 0 ;
33908   Hex::Edge *result = 0 ;
33909
33910   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeJ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33911   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
33912   if (!SWIG_IsOK(res1)) {
33913     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeJ" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33914   }
33915   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33916   ecode2 = SWIG_AsVal_int(obj1, &val2);
33917   if (!SWIG_IsOK(ecode2)) {
33918     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeJ" "', argument " "2"" of type '" "int""'");
33919   }
33920   arg2 = static_cast< int >(val2);
33921   ecode3 = SWIG_AsVal_int(obj2, &val3);
33922   if (!SWIG_IsOK(ecode3)) {
33923     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeJ" "', argument " "3"" of type '" "int""'");
33924   }
33925   arg3 = static_cast< int >(val3);
33926   ecode4 = SWIG_AsVal_int(obj3, &val4);
33927   if (!SWIG_IsOK(ecode4)) {
33928     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeJ" "', argument " "4"" of type '" "int""'");
33929   }
33930   arg4 = static_cast< int >(val4);
33931   ecode5 = SWIG_AsVal_int(obj4, &val5);
33932   if (!SWIG_IsOK(ecode5)) {
33933     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeJ" "', argument " "5"" of type '" "int""'");
33934   }
33935   arg5 = static_cast< int >(val5);
33936   result = (Hex::Edge *)(arg1)->getEdgeJ(arg2,arg3,arg4,arg5);
33937   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
33938   return resultobj;
33939 fail:
33940   return NULL;
33941 }
33942
33943
33944 SWIGINTERN PyObject *_wrap_BiCylinder_getEdgeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33945   PyObject *resultobj = 0;
33946   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
33947   int arg2 ;
33948   int arg3 ;
33949   int arg4 ;
33950   int arg5 ;
33951   void *argp1 = 0 ;
33952   int res1 = 0 ;
33953   int val2 ;
33954   int ecode2 = 0 ;
33955   int val3 ;
33956   int ecode3 = 0 ;
33957   int val4 ;
33958   int ecode4 = 0 ;
33959   int val5 ;
33960   int ecode5 = 0 ;
33961   PyObject * obj0 = 0 ;
33962   PyObject * obj1 = 0 ;
33963   PyObject * obj2 = 0 ;
33964   PyObject * obj3 = 0 ;
33965   PyObject * obj4 = 0 ;
33966   Hex::Edge *result = 0 ;
33967
33968   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getEdgeK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33969   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
33970   if (!SWIG_IsOK(res1)) {
33971     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getEdgeK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
33972   }
33973   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
33974   ecode2 = SWIG_AsVal_int(obj1, &val2);
33975   if (!SWIG_IsOK(ecode2)) {
33976     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getEdgeK" "', argument " "2"" of type '" "int""'");
33977   }
33978   arg2 = static_cast< int >(val2);
33979   ecode3 = SWIG_AsVal_int(obj2, &val3);
33980   if (!SWIG_IsOK(ecode3)) {
33981     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getEdgeK" "', argument " "3"" of type '" "int""'");
33982   }
33983   arg3 = static_cast< int >(val3);
33984   ecode4 = SWIG_AsVal_int(obj3, &val4);
33985   if (!SWIG_IsOK(ecode4)) {
33986     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getEdgeK" "', argument " "4"" of type '" "int""'");
33987   }
33988   arg4 = static_cast< int >(val4);
33989   ecode5 = SWIG_AsVal_int(obj4, &val5);
33990   if (!SWIG_IsOK(ecode5)) {
33991     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getEdgeK" "', argument " "5"" of type '" "int""'");
33992   }
33993   arg5 = static_cast< int >(val5);
33994   result = (Hex::Edge *)(arg1)->getEdgeK(arg2,arg3,arg4,arg5);
33995   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Edge, 0 |  0 );
33996   return resultobj;
33997 fail:
33998   return NULL;
33999 }
34000
34001
34002 SWIGINTERN PyObject *_wrap_BiCylinder_getVertexIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34003   PyObject *resultobj = 0;
34004   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
34005   int arg2 ;
34006   int arg3 ;
34007   int arg4 ;
34008   int arg5 ;
34009   void *argp1 = 0 ;
34010   int res1 = 0 ;
34011   int val2 ;
34012   int ecode2 = 0 ;
34013   int val3 ;
34014   int ecode3 = 0 ;
34015   int val4 ;
34016   int ecode4 = 0 ;
34017   int val5 ;
34018   int ecode5 = 0 ;
34019   PyObject * obj0 = 0 ;
34020   PyObject * obj1 = 0 ;
34021   PyObject * obj2 = 0 ;
34022   PyObject * obj3 = 0 ;
34023   PyObject * obj4 = 0 ;
34024   Hex::Vertex *result = 0 ;
34025
34026   if (!PyArg_ParseTuple(args,(char *)"OOOOO:BiCylinder_getVertexIJK",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34027   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, 0 |  0 );
34028   if (!SWIG_IsOK(res1)) {
34029     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCylinder_getVertexIJK" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
34030   }
34031   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
34032   ecode2 = SWIG_AsVal_int(obj1, &val2);
34033   if (!SWIG_IsOK(ecode2)) {
34034     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BiCylinder_getVertexIJK" "', argument " "2"" of type '" "int""'");
34035   }
34036   arg2 = static_cast< int >(val2);
34037   ecode3 = SWIG_AsVal_int(obj2, &val3);
34038   if (!SWIG_IsOK(ecode3)) {
34039     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BiCylinder_getVertexIJK" "', argument " "3"" of type '" "int""'");
34040   }
34041   arg3 = static_cast< int >(val3);
34042   ecode4 = SWIG_AsVal_int(obj3, &val4);
34043   if (!SWIG_IsOK(ecode4)) {
34044     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BiCylinder_getVertexIJK" "', argument " "4"" of type '" "int""'");
34045   }
34046   arg4 = static_cast< int >(val4);
34047   ecode5 = SWIG_AsVal_int(obj4, &val5);
34048   if (!SWIG_IsOK(ecode5)) {
34049     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BiCylinder_getVertexIJK" "', argument " "5"" of type '" "int""'");
34050   }
34051   arg5 = static_cast< int >(val5);
34052   result = (Hex::Vertex *)(arg1)->getVertexIJK(arg2,arg3,arg4,arg5);
34053   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Vertex, 0 |  0 );
34054   return resultobj;
34055 fail:
34056   return NULL;
34057 }
34058
34059
34060 SWIGINTERN PyObject *_wrap_delete_BiCylinder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34061   PyObject *resultobj = 0;
34062   Hex::BiCylinder *arg1 = (Hex::BiCylinder *) 0 ;
34063   void *argp1 = 0 ;
34064   int res1 = 0 ;
34065   PyObject * obj0 = 0 ;
34066
34067   if (!PyArg_ParseTuple(args,(char *)"O:delete_BiCylinder",&obj0)) SWIG_fail;
34068   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__BiCylinder, SWIG_POINTER_DISOWN |  0 );
34069   if (!SWIG_IsOK(res1)) {
34070     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCylinder" "', argument " "1"" of type '" "Hex::BiCylinder *""'");
34071   }
34072   arg1 = reinterpret_cast< Hex::BiCylinder * >(argp1);
34073   delete arg1;
34074   resultobj = SWIG_Py_Void();
34075   return resultobj;
34076 fail:
34077   return NULL;
34078 }
34079
34080
34081 SWIGINTERN PyObject *BiCylinder_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34082   PyObject *obj;
34083   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
34084   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__BiCylinder, SWIG_NewClientData(obj));
34085   return SWIG_Py_Void();
34086 }
34087
34088 SWIGINTERN PyObject *_wrap_NewShape_countVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34089   PyObject *resultobj = 0;
34090   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34091   void *argp1 = 0 ;
34092   int res1 = 0 ;
34093   PyObject * obj0 = 0 ;
34094   int result;
34095
34096   if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countVertex",&obj0)) SWIG_fail;
34097   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
34098   if (!SWIG_IsOK(res1)) {
34099     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
34100   }
34101   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34102   result = (int)(arg1)->countVertex();
34103   resultobj = SWIG_From_int(static_cast< int >(result));
34104   return resultobj;
34105 fail:
34106   return NULL;
34107 }
34108
34109
34110 SWIGINTERN PyObject *_wrap_NewShape_countEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34111   PyObject *resultobj = 0;
34112   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34113   void *argp1 = 0 ;
34114   int res1 = 0 ;
34115   PyObject * obj0 = 0 ;
34116   int result;
34117
34118   if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countEdge",&obj0)) SWIG_fail;
34119   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
34120   if (!SWIG_IsOK(res1)) {
34121     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
34122   }
34123   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34124   result = (int)(arg1)->countEdge();
34125   resultobj = SWIG_From_int(static_cast< int >(result));
34126   return resultobj;
34127 fail:
34128   return NULL;
34129 }
34130
34131
34132 SWIGINTERN PyObject *_wrap_NewShape_countFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34133   PyObject *resultobj = 0;
34134   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34135   void *argp1 = 0 ;
34136   int res1 = 0 ;
34137   PyObject * obj0 = 0 ;
34138   int result;
34139
34140   if (!PyArg_ParseTuple(args,(char *)"O:NewShape_countFace",&obj0)) SWIG_fail;
34141   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
34142   if (!SWIG_IsOK(res1)) {
34143     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_countFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
34144   }
34145   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34146   result = (int)(arg1)->countFace();
34147   resultobj = SWIG_From_int(static_cast< int >(result));
34148   return resultobj;
34149 fail:
34150   return NULL;
34151 }
34152
34153
34154 SWIGINTERN PyObject *_wrap_NewShape_getVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34155   PyObject *resultobj = 0;
34156   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34157   int arg2 ;
34158   void *argp1 = 0 ;
34159   int res1 = 0 ;
34160   int val2 ;
34161   int ecode2 = 0 ;
34162   PyObject * obj0 = 0 ;
34163   PyObject * obj1 = 0 ;
34164   int result;
34165
34166   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getVertex",&obj0,&obj1)) SWIG_fail;
34167   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
34168   if (!SWIG_IsOK(res1)) {
34169     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
34170   }
34171   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34172   ecode2 = SWIG_AsVal_int(obj1, &val2);
34173   if (!SWIG_IsOK(ecode2)) {
34174     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getVertex" "', argument " "2"" of type '" "int""'");
34175   }
34176   arg2 = static_cast< int >(val2);
34177   result = (int)(arg1)->getVertex(arg2);
34178   resultobj = SWIG_From_int(static_cast< int >(result));
34179   return resultobj;
34180 fail:
34181   return NULL;
34182 }
34183
34184
34185 SWIGINTERN PyObject *_wrap_NewShape_getEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34186   PyObject *resultobj = 0;
34187   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34188   int arg2 ;
34189   void *argp1 = 0 ;
34190   int res1 = 0 ;
34191   int val2 ;
34192   int ecode2 = 0 ;
34193   PyObject * obj0 = 0 ;
34194   PyObject * obj1 = 0 ;
34195   int result;
34196
34197   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getEdge",&obj0,&obj1)) SWIG_fail;
34198   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
34199   if (!SWIG_IsOK(res1)) {
34200     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
34201   }
34202   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34203   ecode2 = SWIG_AsVal_int(obj1, &val2);
34204   if (!SWIG_IsOK(ecode2)) {
34205     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getEdge" "', argument " "2"" of type '" "int""'");
34206   }
34207   arg2 = static_cast< int >(val2);
34208   result = (int)(arg1)->getEdge(arg2);
34209   resultobj = SWIG_From_int(static_cast< int >(result));
34210   return resultobj;
34211 fail:
34212   return NULL;
34213 }
34214
34215
34216 SWIGINTERN PyObject *_wrap_NewShape_getFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34217   PyObject *resultobj = 0;
34218   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34219   int arg2 ;
34220   void *argp1 = 0 ;
34221   int res1 = 0 ;
34222   int val2 ;
34223   int ecode2 = 0 ;
34224   PyObject * obj0 = 0 ;
34225   PyObject * obj1 = 0 ;
34226   int result;
34227
34228   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getFace",&obj0,&obj1)) SWIG_fail;
34229   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
34230   if (!SWIG_IsOK(res1)) {
34231     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
34232   }
34233   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34234   ecode2 = SWIG_AsVal_int(obj1, &val2);
34235   if (!SWIG_IsOK(ecode2)) {
34236     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getFace" "', argument " "2"" of type '" "int""'");
34237   }
34238   arg2 = static_cast< int >(val2);
34239   result = (int)(arg1)->getFace(arg2);
34240   resultobj = SWIG_From_int(static_cast< int >(result));
34241   return resultobj;
34242 fail:
34243   return NULL;
34244 }
34245
34246
34247 SWIGINTERN PyObject *_wrap_NewShape_getNameVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34248   PyObject *resultobj = 0;
34249   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34250   int arg2 ;
34251   void *argp1 = 0 ;
34252   int res1 = 0 ;
34253   int val2 ;
34254   int ecode2 = 0 ;
34255   PyObject * obj0 = 0 ;
34256   PyObject * obj1 = 0 ;
34257   cpchar result;
34258
34259   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameVertex",&obj0,&obj1)) SWIG_fail;
34260   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
34261   if (!SWIG_IsOK(res1)) {
34262     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameVertex" "', argument " "1"" of type '" "Hex::NewShape *""'");
34263   }
34264   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34265   ecode2 = SWIG_AsVal_int(obj1, &val2);
34266   if (!SWIG_IsOK(ecode2)) {
34267     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameVertex" "', argument " "2"" of type '" "int""'");
34268   }
34269   arg2 = static_cast< int >(val2);
34270   result = (cpchar)(arg1)->getNameVertex(arg2);
34271   resultobj = SWIG_FromCharPtr((const char *)result);
34272   return resultobj;
34273 fail:
34274   return NULL;
34275 }
34276
34277
34278 SWIGINTERN PyObject *_wrap_NewShape_getNameEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34279   PyObject *resultobj = 0;
34280   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34281   int arg2 ;
34282   void *argp1 = 0 ;
34283   int res1 = 0 ;
34284   int val2 ;
34285   int ecode2 = 0 ;
34286   PyObject * obj0 = 0 ;
34287   PyObject * obj1 = 0 ;
34288   cpchar result;
34289
34290   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameEdge",&obj0,&obj1)) SWIG_fail;
34291   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
34292   if (!SWIG_IsOK(res1)) {
34293     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameEdge" "', argument " "1"" of type '" "Hex::NewShape *""'");
34294   }
34295   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34296   ecode2 = SWIG_AsVal_int(obj1, &val2);
34297   if (!SWIG_IsOK(ecode2)) {
34298     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameEdge" "', argument " "2"" of type '" "int""'");
34299   }
34300   arg2 = static_cast< int >(val2);
34301   result = (cpchar)(arg1)->getNameEdge(arg2);
34302   resultobj = SWIG_FromCharPtr((const char *)result);
34303   return resultobj;
34304 fail:
34305   return NULL;
34306 }
34307
34308
34309 SWIGINTERN PyObject *_wrap_NewShape_getNameFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34310   PyObject *resultobj = 0;
34311   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34312   int arg2 ;
34313   void *argp1 = 0 ;
34314   int res1 = 0 ;
34315   int val2 ;
34316   int ecode2 = 0 ;
34317   PyObject * obj0 = 0 ;
34318   PyObject * obj1 = 0 ;
34319   cpchar result;
34320
34321   if (!PyArg_ParseTuple(args,(char *)"OO:NewShape_getNameFace",&obj0,&obj1)) SWIG_fail;
34322   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, 0 |  0 );
34323   if (!SWIG_IsOK(res1)) {
34324     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewShape_getNameFace" "', argument " "1"" of type '" "Hex::NewShape *""'");
34325   }
34326   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34327   ecode2 = SWIG_AsVal_int(obj1, &val2);
34328   if (!SWIG_IsOK(ecode2)) {
34329     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NewShape_getNameFace" "', argument " "2"" of type '" "int""'");
34330   }
34331   arg2 = static_cast< int >(val2);
34332   result = (cpchar)(arg1)->getNameFace(arg2);
34333   resultobj = SWIG_FromCharPtr((const char *)result);
34334   return resultobj;
34335 fail:
34336   return NULL;
34337 }
34338
34339
34340 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34341   PyObject *resultobj = 0;
34342   Hex::Document *arg1 = (Hex::Document *) 0 ;
34343   Hex::EnumShape arg2 ;
34344   void *argp1 = 0 ;
34345   int res1 = 0 ;
34346   int val2 ;
34347   int ecode2 = 0 ;
34348   PyObject * obj0 = 0 ;
34349   PyObject * obj1 = 0 ;
34350   Hex::NewShape *result = 0 ;
34351
34352   if (!PyArg_ParseTuple(args,(char *)"OO:new_NewShape",&obj0,&obj1)) SWIG_fail;
34353   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
34354   if (!SWIG_IsOK(res1)) {
34355     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
34356   }
34357   arg1 = reinterpret_cast< Hex::Document * >(argp1);
34358   ecode2 = SWIG_AsVal_int(obj1, &val2);
34359   if (!SWIG_IsOK(ecode2)) {
34360     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewShape" "', argument " "2"" of type '" "Hex::EnumShape""'");
34361   }
34362   arg2 = static_cast< Hex::EnumShape >(val2);
34363   result = (Hex::NewShape *)new Hex::NewShape(arg1,arg2);
34364   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_NEW |  0 );
34365   return resultobj;
34366 fail:
34367   return NULL;
34368 }
34369
34370
34371 SWIGINTERN PyObject *_wrap_new_NewShape__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34372   PyObject *resultobj = 0;
34373   Hex::Document *arg1 = (Hex::Document *) 0 ;
34374   void *argp1 = 0 ;
34375   int res1 = 0 ;
34376   PyObject * obj0 = 0 ;
34377   Hex::NewShape *result = 0 ;
34378
34379   if (!PyArg_ParseTuple(args,(char *)"O:new_NewShape",&obj0)) SWIG_fail;
34380   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
34381   if (!SWIG_IsOK(res1)) {
34382     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NewShape" "', argument " "1"" of type '" "Hex::Document *""'");
34383   }
34384   arg1 = reinterpret_cast< Hex::Document * >(argp1);
34385   result = (Hex::NewShape *)new Hex::NewShape(arg1);
34386   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_NEW |  0 );
34387   return resultobj;
34388 fail:
34389   return NULL;
34390 }
34391
34392
34393 SWIGINTERN PyObject *_wrap_new_NewShape(PyObject *self, PyObject *args) {
34394   Py_ssize_t argc;
34395   PyObject *argv[3] = {
34396     0
34397   };
34398   Py_ssize_t ii;
34399
34400   if (!PyTuple_Check(args)) SWIG_fail;
34401   argc = args ? PyObject_Length(args) : 0;
34402   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
34403     argv[ii] = PyTuple_GET_ITEM(args,ii);
34404   }
34405   if (argc == 1) {
34406     int _v;
34407     void *vptr = 0;
34408     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
34409     _v = SWIG_CheckState(res);
34410     if (_v) {
34411       return _wrap_new_NewShape__SWIG_1(self, args);
34412     }
34413   }
34414   if (argc == 2) {
34415     int _v;
34416     void *vptr = 0;
34417     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Document, 0);
34418     _v = SWIG_CheckState(res);
34419     if (_v) {
34420       {
34421         int res = SWIG_AsVal_int(argv[1], NULL);
34422         _v = SWIG_CheckState(res);
34423       }
34424       if (_v) {
34425         return _wrap_new_NewShape__SWIG_0(self, args);
34426       }
34427     }
34428   }
34429
34430 fail:
34431   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_NewShape'.\n"
34432     "  Possible C/C++ prototypes are:\n"
34433     "    Hex::NewShape::NewShape(Hex::Document *,Hex::EnumShape)\n"
34434     "    Hex::NewShape::NewShape(Hex::Document *)\n");
34435   return 0;
34436 }
34437
34438
34439 SWIGINTERN PyObject *_wrap_delete_NewShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34440   PyObject *resultobj = 0;
34441   Hex::NewShape *arg1 = (Hex::NewShape *) 0 ;
34442   void *argp1 = 0 ;
34443   int res1 = 0 ;
34444   PyObject * obj0 = 0 ;
34445
34446   if (!PyArg_ParseTuple(args,(char *)"O:delete_NewShape",&obj0)) SWIG_fail;
34447   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__NewShape, SWIG_POINTER_DISOWN |  0 );
34448   if (!SWIG_IsOK(res1)) {
34449     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewShape" "', argument " "1"" of type '" "Hex::NewShape *""'");
34450   }
34451   arg1 = reinterpret_cast< Hex::NewShape * >(argp1);
34452   delete arg1;
34453   resultobj = SWIG_Py_Void();
34454   return resultobj;
34455 fail:
34456   return NULL;
34457 }
34458
34459
34460 SWIGINTERN PyObject *NewShape_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34461   PyObject *obj;
34462   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
34463   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__NewShape, SWIG_NewClientData(obj));
34464   return SWIG_Py_Void();
34465 }
34466
34467 SWIGINTERN PyObject *_wrap_Group_addElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34468   PyObject *resultobj = 0;
34469   Hex::Group *arg1 = (Hex::Group *) 0 ;
34470   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
34471   void *argp1 = 0 ;
34472   int res1 = 0 ;
34473   void *argp2 = 0 ;
34474   int res2 = 0 ;
34475   PyObject * obj0 = 0 ;
34476   PyObject * obj1 = 0 ;
34477   int result;
34478
34479   if (!PyArg_ParseTuple(args,(char *)"OO:Group_addElement",&obj0,&obj1)) SWIG_fail;
34480   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
34481   if (!SWIG_IsOK(res1)) {
34482     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_addElement" "', argument " "1"" of type '" "Hex::Group *""'");
34483   }
34484   arg1 = reinterpret_cast< Hex::Group * >(argp1);
34485   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
34486   if (!SWIG_IsOK(res2)) {
34487     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_addElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
34488   }
34489   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
34490   result = (int)(arg1)->addElement(arg2);
34491   resultobj = SWIG_From_int(static_cast< int >(result));
34492   return resultobj;
34493 fail:
34494   return NULL;
34495 }
34496
34497
34498 SWIGINTERN PyObject *_wrap_Group_countElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34499   PyObject *resultobj = 0;
34500   Hex::Group *arg1 = (Hex::Group *) 0 ;
34501   void *argp1 = 0 ;
34502   int res1 = 0 ;
34503   PyObject * obj0 = 0 ;
34504   int result;
34505
34506   if (!PyArg_ParseTuple(args,(char *)"O:Group_countElement",&obj0)) SWIG_fail;
34507   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
34508   if (!SWIG_IsOK(res1)) {
34509     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_countElement" "', argument " "1"" of type '" "Hex::Group *""'");
34510   }
34511   arg1 = reinterpret_cast< Hex::Group * >(argp1);
34512   result = (int)(arg1)->countElement();
34513   resultobj = SWIG_From_int(static_cast< int >(result));
34514   return resultobj;
34515 fail:
34516   return NULL;
34517 }
34518
34519
34520 SWIGINTERN PyObject *_wrap_Group_getKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34521   PyObject *resultobj = 0;
34522   Hex::Group *arg1 = (Hex::Group *) 0 ;
34523   void *argp1 = 0 ;
34524   int res1 = 0 ;
34525   PyObject * obj0 = 0 ;
34526   Hex::EnumGroup result;
34527
34528   if (!PyArg_ParseTuple(args,(char *)"O:Group_getKind",&obj0)) SWIG_fail;
34529   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
34530   if (!SWIG_IsOK(res1)) {
34531     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getKind" "', argument " "1"" of type '" "Hex::Group *""'");
34532   }
34533   arg1 = reinterpret_cast< Hex::Group * >(argp1);
34534   result = (Hex::EnumGroup)(arg1)->getKind();
34535   resultobj = SWIG_From_int(static_cast< int >(result));
34536   return resultobj;
34537 fail:
34538   return NULL;
34539 }
34540
34541
34542 SWIGINTERN PyObject *_wrap_Group_removeElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34543   PyObject *resultobj = 0;
34544   Hex::Group *arg1 = (Hex::Group *) 0 ;
34545   int arg2 ;
34546   void *argp1 = 0 ;
34547   int res1 = 0 ;
34548   int val2 ;
34549   int ecode2 = 0 ;
34550   PyObject * obj0 = 0 ;
34551   PyObject * obj1 = 0 ;
34552   int result;
34553
34554   if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
34555   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
34556   if (!SWIG_IsOK(res1)) {
34557     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
34558   }
34559   arg1 = reinterpret_cast< Hex::Group * >(argp1);
34560   ecode2 = SWIG_AsVal_int(obj1, &val2);
34561   if (!SWIG_IsOK(ecode2)) {
34562     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "int""'");
34563   }
34564   arg2 = static_cast< int >(val2);
34565   result = (int)(arg1)->removeElement(arg2);
34566   resultobj = SWIG_From_int(static_cast< int >(result));
34567   return resultobj;
34568 fail:
34569   return NULL;
34570 }
34571
34572
34573 SWIGINTERN PyObject *_wrap_Group_clearElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34574   PyObject *resultobj = 0;
34575   Hex::Group *arg1 = (Hex::Group *) 0 ;
34576   void *argp1 = 0 ;
34577   int res1 = 0 ;
34578   PyObject * obj0 = 0 ;
34579
34580   if (!PyArg_ParseTuple(args,(char *)"O:Group_clearElement",&obj0)) SWIG_fail;
34581   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
34582   if (!SWIG_IsOK(res1)) {
34583     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_clearElement" "', argument " "1"" of type '" "Hex::Group *""'");
34584   }
34585   arg1 = reinterpret_cast< Hex::Group * >(argp1);
34586   (arg1)->clearElement();
34587   resultobj = SWIG_Py_Void();
34588   return resultobj;
34589 fail:
34590   return NULL;
34591 }
34592
34593
34594 SWIGINTERN PyObject *_wrap_Group_removeElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34595   PyObject *resultobj = 0;
34596   Hex::Group *arg1 = (Hex::Group *) 0 ;
34597   Hex::EltBase *arg2 = (Hex::EltBase *) 0 ;
34598   void *argp1 = 0 ;
34599   int res1 = 0 ;
34600   void *argp2 = 0 ;
34601   int res2 = 0 ;
34602   PyObject * obj0 = 0 ;
34603   PyObject * obj1 = 0 ;
34604   int result;
34605
34606   if (!PyArg_ParseTuple(args,(char *)"OO:Group_removeElement",&obj0,&obj1)) SWIG_fail;
34607   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
34608   if (!SWIG_IsOK(res1)) {
34609     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_removeElement" "', argument " "1"" of type '" "Hex::Group *""'");
34610   }
34611   arg1 = reinterpret_cast< Hex::Group * >(argp1);
34612   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Hex__EltBase, 0 |  0 );
34613   if (!SWIG_IsOK(res2)) {
34614     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Group_removeElement" "', argument " "2"" of type '" "Hex::EltBase *""'");
34615   }
34616   arg2 = reinterpret_cast< Hex::EltBase * >(argp2);
34617   result = (int)(arg1)->removeElement(arg2);
34618   resultobj = SWIG_From_int(static_cast< int >(result));
34619   return resultobj;
34620 fail:
34621   return NULL;
34622 }
34623
34624
34625 SWIGINTERN PyObject *_wrap_Group_removeElement(PyObject *self, PyObject *args) {
34626   Py_ssize_t argc;
34627   PyObject *argv[3] = {
34628     0
34629   };
34630   Py_ssize_t ii;
34631
34632   if (!PyTuple_Check(args)) SWIG_fail;
34633   argc = args ? PyObject_Length(args) : 0;
34634   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
34635     argv[ii] = PyTuple_GET_ITEM(args,ii);
34636   }
34637   if (argc == 2) {
34638     int _v;
34639     void *vptr = 0;
34640     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
34641     _v = SWIG_CheckState(res);
34642     if (_v) {
34643       void *vptr = 0;
34644       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Hex__EltBase, 0);
34645       _v = SWIG_CheckState(res);
34646       if (_v) {
34647         return _wrap_Group_removeElement__SWIG_1(self, args);
34648       }
34649     }
34650   }
34651   if (argc == 2) {
34652     int _v;
34653     void *vptr = 0;
34654     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Hex__Group, 0);
34655     _v = SWIG_CheckState(res);
34656     if (_v) {
34657       {
34658         int res = SWIG_AsVal_int(argv[1], NULL);
34659         _v = SWIG_CheckState(res);
34660       }
34661       if (_v) {
34662         return _wrap_Group_removeElement__SWIG_0(self, args);
34663       }
34664     }
34665   }
34666
34667 fail:
34668   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Group_removeElement'.\n"
34669     "  Possible C/C++ prototypes are:\n"
34670     "    Hex::Group::removeElement(int)\n"
34671     "    Hex::Group::removeElement(Hex::EltBase *)\n");
34672   return 0;
34673 }
34674
34675
34676 SWIGINTERN PyObject *_wrap_Group_getElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34677   PyObject *resultobj = 0;
34678   Hex::Group *arg1 = (Hex::Group *) 0 ;
34679   int arg2 ;
34680   void *argp1 = 0 ;
34681   int res1 = 0 ;
34682   int val2 ;
34683   int ecode2 = 0 ;
34684   PyObject * obj0 = 0 ;
34685   PyObject * obj1 = 0 ;
34686   Hex::EltBase *result = 0 ;
34687
34688   if (!PyArg_ParseTuple(args,(char *)"OO:Group_getElement",&obj0,&obj1)) SWIG_fail;
34689   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, 0 |  0 );
34690   if (!SWIG_IsOK(res1)) {
34691     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Group_getElement" "', argument " "1"" of type '" "Hex::Group *""'");
34692   }
34693   arg1 = reinterpret_cast< Hex::Group * >(argp1);
34694   ecode2 = SWIG_AsVal_int(obj1, &val2);
34695   if (!SWIG_IsOK(ecode2)) {
34696     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Group_getElement" "', argument " "2"" of type '" "int""'");
34697   }
34698   arg2 = static_cast< int >(val2);
34699   result = (Hex::EltBase *)(arg1)->getElement(arg2);
34700   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__EltBase, 0 |  0 );
34701   return resultobj;
34702 fail:
34703   return NULL;
34704 }
34705
34706
34707 SWIGINTERN PyObject *_wrap_new_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34708   PyObject *resultobj = 0;
34709   Hex::Document *arg1 = (Hex::Document *) 0 ;
34710   cpchar arg2 = (cpchar) 0 ;
34711   Hex::EnumGroup arg3 ;
34712   void *argp1 = 0 ;
34713   int res1 = 0 ;
34714   int res2 ;
34715   char *buf2 = 0 ;
34716   int alloc2 = 0 ;
34717   int val3 ;
34718   int ecode3 = 0 ;
34719   PyObject * obj0 = 0 ;
34720   PyObject * obj1 = 0 ;
34721   PyObject * obj2 = 0 ;
34722   Hex::Group *result = 0 ;
34723
34724   if (!PyArg_ParseTuple(args,(char *)"OOO:new_Group",&obj0,&obj1,&obj2)) SWIG_fail;
34725   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Document, 0 |  0 );
34726   if (!SWIG_IsOK(res1)) {
34727     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Group" "', argument " "1"" of type '" "Hex::Document *""'");
34728   }
34729   arg1 = reinterpret_cast< Hex::Document * >(argp1);
34730   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
34731   if (!SWIG_IsOK(res2)) {
34732     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Group" "', argument " "2"" of type '" "cpchar""'");
34733   }
34734   arg2 = reinterpret_cast< cpchar >(buf2);
34735   ecode3 = SWIG_AsVal_int(obj2, &val3);
34736   if (!SWIG_IsOK(ecode3)) {
34737     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Group" "', argument " "3"" of type '" "Hex::EnumGroup""'");
34738   }
34739   arg3 = static_cast< Hex::EnumGroup >(val3);
34740   result = (Hex::Group *)new Hex::Group(arg1,arg2,arg3);
34741   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Hex__Group, SWIG_POINTER_NEW |  0 );
34742   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
34743   return resultobj;
34744 fail:
34745   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
34746   return NULL;
34747 }
34748
34749
34750 SWIGINTERN PyObject *_wrap_delete_Group(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34751   PyObject *resultobj = 0;
34752   Hex::Group *arg1 = (Hex::Group *) 0 ;
34753   void *argp1 = 0 ;
34754   int res1 = 0 ;
34755   PyObject * obj0 = 0 ;
34756
34757   if (!PyArg_ParseTuple(args,(char *)"O:delete_Group",&obj0)) SWIG_fail;
34758   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Hex__Group, SWIG_POINTER_DISOWN |  0 );
34759   if (!SWIG_IsOK(res1)) {
34760     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Group" "', argument " "1"" of type '" "Hex::Group *""'");
34761   }
34762   arg1 = reinterpret_cast< Hex::Group * >(argp1);
34763   delete arg1;
34764   resultobj = SWIG_Py_Void();
34765   return resultobj;
34766 fail:
34767   return NULL;
34768 }
34769
34770
34771 SWIGINTERN PyObject *Group_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34772   PyObject *obj;
34773   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
34774   SWIG_TypeNewClientData(SWIGTYPE_p_Hex__Group, SWIG_NewClientData(obj));
34775   return SWIG_Py_Void();
34776 }
34777
34778 static PyMethodDef SwigMethods[] = {
34779          { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
34780          { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL},
34781          { (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL},
34782          { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
34783          { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
34784          { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
34785          { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
34786          { (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL},
34787          { (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL},
34788          { (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL},
34789          { (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL},
34790          { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
34791          { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
34792          { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
34793          { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
34794          { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
34795          { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
34796          { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
34797          { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
34798          { (char *)"VectorHexas_iterator", _wrap_VectorHexas_iterator, METH_VARARGS, NULL},
34799          { (char *)"VectorHexas___nonzero__", _wrap_VectorHexas___nonzero__, METH_VARARGS, NULL},
34800          { (char *)"VectorHexas___bool__", _wrap_VectorHexas___bool__, METH_VARARGS, NULL},
34801          { (char *)"VectorHexas___len__", _wrap_VectorHexas___len__, METH_VARARGS, NULL},
34802          { (char *)"VectorHexas___getslice__", _wrap_VectorHexas___getslice__, METH_VARARGS, NULL},
34803          { (char *)"VectorHexas___setslice__", _wrap_VectorHexas___setslice__, METH_VARARGS, NULL},
34804          { (char *)"VectorHexas___delslice__", _wrap_VectorHexas___delslice__, METH_VARARGS, NULL},
34805          { (char *)"VectorHexas___delitem__", _wrap_VectorHexas___delitem__, METH_VARARGS, NULL},
34806          { (char *)"VectorHexas___getitem__", _wrap_VectorHexas___getitem__, METH_VARARGS, NULL},
34807          { (char *)"VectorHexas___setitem__", _wrap_VectorHexas___setitem__, METH_VARARGS, NULL},
34808          { (char *)"VectorHexas_pop", _wrap_VectorHexas_pop, METH_VARARGS, NULL},
34809          { (char *)"VectorHexas_append", _wrap_VectorHexas_append, METH_VARARGS, NULL},
34810          { (char *)"VectorHexas_empty", _wrap_VectorHexas_empty, METH_VARARGS, NULL},
34811          { (char *)"VectorHexas_size", _wrap_VectorHexas_size, METH_VARARGS, NULL},
34812          { (char *)"VectorHexas_swap", _wrap_VectorHexas_swap, METH_VARARGS, NULL},
34813          { (char *)"VectorHexas_begin", _wrap_VectorHexas_begin, METH_VARARGS, NULL},
34814          { (char *)"VectorHexas_end", _wrap_VectorHexas_end, METH_VARARGS, NULL},
34815          { (char *)"VectorHexas_rbegin", _wrap_VectorHexas_rbegin, METH_VARARGS, NULL},
34816          { (char *)"VectorHexas_rend", _wrap_VectorHexas_rend, METH_VARARGS, NULL},
34817          { (char *)"VectorHexas_clear", _wrap_VectorHexas_clear, METH_VARARGS, NULL},
34818          { (char *)"VectorHexas_get_allocator", _wrap_VectorHexas_get_allocator, METH_VARARGS, NULL},
34819          { (char *)"VectorHexas_pop_back", _wrap_VectorHexas_pop_back, METH_VARARGS, NULL},
34820          { (char *)"VectorHexas_erase", _wrap_VectorHexas_erase, METH_VARARGS, NULL},
34821          { (char *)"new_VectorHexas", _wrap_new_VectorHexas, METH_VARARGS, NULL},
34822          { (char *)"VectorHexas_push_back", _wrap_VectorHexas_push_back, METH_VARARGS, NULL},
34823          { (char *)"VectorHexas_front", _wrap_VectorHexas_front, METH_VARARGS, NULL},
34824          { (char *)"VectorHexas_back", _wrap_VectorHexas_back, METH_VARARGS, NULL},
34825          { (char *)"VectorHexas_assign", _wrap_VectorHexas_assign, METH_VARARGS, NULL},
34826          { (char *)"VectorHexas_resize", _wrap_VectorHexas_resize, METH_VARARGS, NULL},
34827          { (char *)"VectorHexas_insert", _wrap_VectorHexas_insert, METH_VARARGS, NULL},
34828          { (char *)"VectorHexas_reserve", _wrap_VectorHexas_reserve, METH_VARARGS, NULL},
34829          { (char *)"VectorHexas_capacity", _wrap_VectorHexas_capacity, METH_VARARGS, NULL},
34830          { (char *)"delete_VectorHexas", _wrap_delete_VectorHexas, METH_VARARGS, NULL},
34831          { (char *)"VectorHexas_swigregister", VectorHexas_swigregister, METH_VARARGS, NULL},
34832          { (char *)"VectorQuads_iterator", _wrap_VectorQuads_iterator, METH_VARARGS, NULL},
34833          { (char *)"VectorQuads___nonzero__", _wrap_VectorQuads___nonzero__, METH_VARARGS, NULL},
34834          { (char *)"VectorQuads___bool__", _wrap_VectorQuads___bool__, METH_VARARGS, NULL},
34835          { (char *)"VectorQuads___len__", _wrap_VectorQuads___len__, METH_VARARGS, NULL},
34836          { (char *)"VectorQuads___getslice__", _wrap_VectorQuads___getslice__, METH_VARARGS, NULL},
34837          { (char *)"VectorQuads___setslice__", _wrap_VectorQuads___setslice__, METH_VARARGS, NULL},
34838          { (char *)"VectorQuads___delslice__", _wrap_VectorQuads___delslice__, METH_VARARGS, NULL},
34839          { (char *)"VectorQuads___delitem__", _wrap_VectorQuads___delitem__, METH_VARARGS, NULL},
34840          { (char *)"VectorQuads___getitem__", _wrap_VectorQuads___getitem__, METH_VARARGS, NULL},
34841          { (char *)"VectorQuads___setitem__", _wrap_VectorQuads___setitem__, METH_VARARGS, NULL},
34842          { (char *)"VectorQuads_pop", _wrap_VectorQuads_pop, METH_VARARGS, NULL},
34843          { (char *)"VectorQuads_append", _wrap_VectorQuads_append, METH_VARARGS, NULL},
34844          { (char *)"VectorQuads_empty", _wrap_VectorQuads_empty, METH_VARARGS, NULL},
34845          { (char *)"VectorQuads_size", _wrap_VectorQuads_size, METH_VARARGS, NULL},
34846          { (char *)"VectorQuads_swap", _wrap_VectorQuads_swap, METH_VARARGS, NULL},
34847          { (char *)"VectorQuads_begin", _wrap_VectorQuads_begin, METH_VARARGS, NULL},
34848          { (char *)"VectorQuads_end", _wrap_VectorQuads_end, METH_VARARGS, NULL},
34849          { (char *)"VectorQuads_rbegin", _wrap_VectorQuads_rbegin, METH_VARARGS, NULL},
34850          { (char *)"VectorQuads_rend", _wrap_VectorQuads_rend, METH_VARARGS, NULL},
34851          { (char *)"VectorQuads_clear", _wrap_VectorQuads_clear, METH_VARARGS, NULL},
34852          { (char *)"VectorQuads_get_allocator", _wrap_VectorQuads_get_allocator, METH_VARARGS, NULL},
34853          { (char *)"VectorQuads_pop_back", _wrap_VectorQuads_pop_back, METH_VARARGS, NULL},
34854          { (char *)"VectorQuads_erase", _wrap_VectorQuads_erase, METH_VARARGS, NULL},
34855          { (char *)"new_VectorQuads", _wrap_new_VectorQuads, METH_VARARGS, NULL},
34856          { (char *)"VectorQuads_push_back", _wrap_VectorQuads_push_back, METH_VARARGS, NULL},
34857          { (char *)"VectorQuads_front", _wrap_VectorQuads_front, METH_VARARGS, NULL},
34858          { (char *)"VectorQuads_back", _wrap_VectorQuads_back, METH_VARARGS, NULL},
34859          { (char *)"VectorQuads_assign", _wrap_VectorQuads_assign, METH_VARARGS, NULL},
34860          { (char *)"VectorQuads_resize", _wrap_VectorQuads_resize, METH_VARARGS, NULL},
34861          { (char *)"VectorQuads_insert", _wrap_VectorQuads_insert, METH_VARARGS, NULL},
34862          { (char *)"VectorQuads_reserve", _wrap_VectorQuads_reserve, METH_VARARGS, NULL},
34863          { (char *)"VectorQuads_capacity", _wrap_VectorQuads_capacity, METH_VARARGS, NULL},
34864          { (char *)"delete_VectorQuads", _wrap_delete_VectorQuads, METH_VARARGS, NULL},
34865          { (char *)"VectorQuads_swigregister", VectorQuads_swigregister, METH_VARARGS, NULL},
34866          { (char *)"VectorEdges_iterator", _wrap_VectorEdges_iterator, METH_VARARGS, NULL},
34867          { (char *)"VectorEdges___nonzero__", _wrap_VectorEdges___nonzero__, METH_VARARGS, NULL},
34868          { (char *)"VectorEdges___bool__", _wrap_VectorEdges___bool__, METH_VARARGS, NULL},
34869          { (char *)"VectorEdges___len__", _wrap_VectorEdges___len__, METH_VARARGS, NULL},
34870          { (char *)"VectorEdges___getslice__", _wrap_VectorEdges___getslice__, METH_VARARGS, NULL},
34871          { (char *)"VectorEdges___setslice__", _wrap_VectorEdges___setslice__, METH_VARARGS, NULL},
34872          { (char *)"VectorEdges___delslice__", _wrap_VectorEdges___delslice__, METH_VARARGS, NULL},
34873          { (char *)"VectorEdges___delitem__", _wrap_VectorEdges___delitem__, METH_VARARGS, NULL},
34874          { (char *)"VectorEdges___getitem__", _wrap_VectorEdges___getitem__, METH_VARARGS, NULL},
34875          { (char *)"VectorEdges___setitem__", _wrap_VectorEdges___setitem__, METH_VARARGS, NULL},
34876          { (char *)"VectorEdges_pop", _wrap_VectorEdges_pop, METH_VARARGS, NULL},
34877          { (char *)"VectorEdges_append", _wrap_VectorEdges_append, METH_VARARGS, NULL},
34878          { (char *)"VectorEdges_empty", _wrap_VectorEdges_empty, METH_VARARGS, NULL},
34879          { (char *)"VectorEdges_size", _wrap_VectorEdges_size, METH_VARARGS, NULL},
34880          { (char *)"VectorEdges_swap", _wrap_VectorEdges_swap, METH_VARARGS, NULL},
34881          { (char *)"VectorEdges_begin", _wrap_VectorEdges_begin, METH_VARARGS, NULL},
34882          { (char *)"VectorEdges_end", _wrap_VectorEdges_end, METH_VARARGS, NULL},
34883          { (char *)"VectorEdges_rbegin", _wrap_VectorEdges_rbegin, METH_VARARGS, NULL},
34884          { (char *)"VectorEdges_rend", _wrap_VectorEdges_rend, METH_VARARGS, NULL},
34885          { (char *)"VectorEdges_clear", _wrap_VectorEdges_clear, METH_VARARGS, NULL},
34886          { (char *)"VectorEdges_get_allocator", _wrap_VectorEdges_get_allocator, METH_VARARGS, NULL},
34887          { (char *)"VectorEdges_pop_back", _wrap_VectorEdges_pop_back, METH_VARARGS, NULL},
34888          { (char *)"VectorEdges_erase", _wrap_VectorEdges_erase, METH_VARARGS, NULL},
34889          { (char *)"new_VectorEdges", _wrap_new_VectorEdges, METH_VARARGS, NULL},
34890          { (char *)"VectorEdges_push_back", _wrap_VectorEdges_push_back, METH_VARARGS, NULL},
34891          { (char *)"VectorEdges_front", _wrap_VectorEdges_front, METH_VARARGS, NULL},
34892          { (char *)"VectorEdges_back", _wrap_VectorEdges_back, METH_VARARGS, NULL},
34893          { (char *)"VectorEdges_assign", _wrap_VectorEdges_assign, METH_VARARGS, NULL},
34894          { (char *)"VectorEdges_resize", _wrap_VectorEdges_resize, METH_VARARGS, NULL},
34895          { (char *)"VectorEdges_insert", _wrap_VectorEdges_insert, METH_VARARGS, NULL},
34896          { (char *)"VectorEdges_reserve", _wrap_VectorEdges_reserve, METH_VARARGS, NULL},
34897          { (char *)"VectorEdges_capacity", _wrap_VectorEdges_capacity, METH_VARARGS, NULL},
34898          { (char *)"delete_VectorEdges", _wrap_delete_VectorEdges, METH_VARARGS, NULL},
34899          { (char *)"VectorEdges_swigregister", VectorEdges_swigregister, METH_VARARGS, NULL},
34900          { (char *)"VectorVertices_iterator", _wrap_VectorVertices_iterator, METH_VARARGS, NULL},
34901          { (char *)"VectorVertices___nonzero__", _wrap_VectorVertices___nonzero__, METH_VARARGS, NULL},
34902          { (char *)"VectorVertices___bool__", _wrap_VectorVertices___bool__, METH_VARARGS, NULL},
34903          { (char *)"VectorVertices___len__", _wrap_VectorVertices___len__, METH_VARARGS, NULL},
34904          { (char *)"VectorVertices___getslice__", _wrap_VectorVertices___getslice__, METH_VARARGS, NULL},
34905          { (char *)"VectorVertices___setslice__", _wrap_VectorVertices___setslice__, METH_VARARGS, NULL},
34906          { (char *)"VectorVertices___delslice__", _wrap_VectorVertices___delslice__, METH_VARARGS, NULL},
34907          { (char *)"VectorVertices___delitem__", _wrap_VectorVertices___delitem__, METH_VARARGS, NULL},
34908          { (char *)"VectorVertices___getitem__", _wrap_VectorVertices___getitem__, METH_VARARGS, NULL},
34909          { (char *)"VectorVertices___setitem__", _wrap_VectorVertices___setitem__, METH_VARARGS, NULL},
34910          { (char *)"VectorVertices_pop", _wrap_VectorVertices_pop, METH_VARARGS, NULL},
34911          { (char *)"VectorVertices_append", _wrap_VectorVertices_append, METH_VARARGS, NULL},
34912          { (char *)"VectorVertices_empty", _wrap_VectorVertices_empty, METH_VARARGS, NULL},
34913          { (char *)"VectorVertices_size", _wrap_VectorVertices_size, METH_VARARGS, NULL},
34914          { (char *)"VectorVertices_swap", _wrap_VectorVertices_swap, METH_VARARGS, NULL},
34915          { (char *)"VectorVertices_begin", _wrap_VectorVertices_begin, METH_VARARGS, NULL},
34916          { (char *)"VectorVertices_end", _wrap_VectorVertices_end, METH_VARARGS, NULL},
34917          { (char *)"VectorVertices_rbegin", _wrap_VectorVertices_rbegin, METH_VARARGS, NULL},
34918          { (char *)"VectorVertices_rend", _wrap_VectorVertices_rend, METH_VARARGS, NULL},
34919          { (char *)"VectorVertices_clear", _wrap_VectorVertices_clear, METH_VARARGS, NULL},
34920          { (char *)"VectorVertices_get_allocator", _wrap_VectorVertices_get_allocator, METH_VARARGS, NULL},
34921          { (char *)"VectorVertices_pop_back", _wrap_VectorVertices_pop_back, METH_VARARGS, NULL},
34922          { (char *)"VectorVertices_erase", _wrap_VectorVertices_erase, METH_VARARGS, NULL},
34923          { (char *)"new_VectorVertices", _wrap_new_VectorVertices, METH_VARARGS, NULL},
34924          { (char *)"VectorVertices_push_back", _wrap_VectorVertices_push_back, METH_VARARGS, NULL},
34925          { (char *)"VectorVertices_front", _wrap_VectorVertices_front, METH_VARARGS, NULL},
34926          { (char *)"VectorVertices_back", _wrap_VectorVertices_back, METH_VARARGS, NULL},
34927          { (char *)"VectorVertices_assign", _wrap_VectorVertices_assign, METH_VARARGS, NULL},
34928          { (char *)"VectorVertices_resize", _wrap_VectorVertices_resize, METH_VARARGS, NULL},
34929          { (char *)"VectorVertices_insert", _wrap_VectorVertices_insert, METH_VARARGS, NULL},
34930          { (char *)"VectorVertices_reserve", _wrap_VectorVertices_reserve, METH_VARARGS, NULL},
34931          { (char *)"VectorVertices_capacity", _wrap_VectorVertices_capacity, METH_VARARGS, NULL},
34932          { (char *)"delete_VectorVertices", _wrap_delete_VectorVertices, METH_VARARGS, NULL},
34933          { (char *)"VectorVertices_swigregister", VectorVertices_swigregister, METH_VARARGS, NULL},
34934          { (char *)"VectorShapes_iterator", _wrap_VectorShapes_iterator, METH_VARARGS, NULL},
34935          { (char *)"VectorShapes___nonzero__", _wrap_VectorShapes___nonzero__, METH_VARARGS, NULL},
34936          { (char *)"VectorShapes___bool__", _wrap_VectorShapes___bool__, METH_VARARGS, NULL},
34937          { (char *)"VectorShapes___len__", _wrap_VectorShapes___len__, METH_VARARGS, NULL},
34938          { (char *)"VectorShapes___getslice__", _wrap_VectorShapes___getslice__, METH_VARARGS, NULL},
34939          { (char *)"VectorShapes___setslice__", _wrap_VectorShapes___setslice__, METH_VARARGS, NULL},
34940          { (char *)"VectorShapes___delslice__", _wrap_VectorShapes___delslice__, METH_VARARGS, NULL},
34941          { (char *)"VectorShapes___delitem__", _wrap_VectorShapes___delitem__, METH_VARARGS, NULL},
34942          { (char *)"VectorShapes___getitem__", _wrap_VectorShapes___getitem__, METH_VARARGS, NULL},
34943          { (char *)"VectorShapes___setitem__", _wrap_VectorShapes___setitem__, METH_VARARGS, NULL},
34944          { (char *)"VectorShapes_pop", _wrap_VectorShapes_pop, METH_VARARGS, NULL},
34945          { (char *)"VectorShapes_append", _wrap_VectorShapes_append, METH_VARARGS, NULL},
34946          { (char *)"VectorShapes_empty", _wrap_VectorShapes_empty, METH_VARARGS, NULL},
34947          { (char *)"VectorShapes_size", _wrap_VectorShapes_size, METH_VARARGS, NULL},
34948          { (char *)"VectorShapes_swap", _wrap_VectorShapes_swap, METH_VARARGS, NULL},
34949          { (char *)"VectorShapes_begin", _wrap_VectorShapes_begin, METH_VARARGS, NULL},
34950          { (char *)"VectorShapes_end", _wrap_VectorShapes_end, METH_VARARGS, NULL},
34951          { (char *)"VectorShapes_rbegin", _wrap_VectorShapes_rbegin, METH_VARARGS, NULL},
34952          { (char *)"VectorShapes_rend", _wrap_VectorShapes_rend, METH_VARARGS, NULL},
34953          { (char *)"VectorShapes_clear", _wrap_VectorShapes_clear, METH_VARARGS, NULL},
34954          { (char *)"VectorShapes_get_allocator", _wrap_VectorShapes_get_allocator, METH_VARARGS, NULL},
34955          { (char *)"VectorShapes_pop_back", _wrap_VectorShapes_pop_back, METH_VARARGS, NULL},
34956          { (char *)"VectorShapes_erase", _wrap_VectorShapes_erase, METH_VARARGS, NULL},
34957          { (char *)"new_VectorShapes", _wrap_new_VectorShapes, METH_VARARGS, NULL},
34958          { (char *)"VectorShapes_push_back", _wrap_VectorShapes_push_back, METH_VARARGS, NULL},
34959          { (char *)"VectorShapes_front", _wrap_VectorShapes_front, METH_VARARGS, NULL},
34960          { (char *)"VectorShapes_back", _wrap_VectorShapes_back, METH_VARARGS, NULL},
34961          { (char *)"VectorShapes_assign", _wrap_VectorShapes_assign, METH_VARARGS, NULL},
34962          { (char *)"VectorShapes_resize", _wrap_VectorShapes_resize, METH_VARARGS, NULL},
34963          { (char *)"VectorShapes_insert", _wrap_VectorShapes_insert, METH_VARARGS, NULL},
34964          { (char *)"VectorShapes_reserve", _wrap_VectorShapes_reserve, METH_VARARGS, NULL},
34965          { (char *)"VectorShapes_capacity", _wrap_VectorShapes_capacity, METH_VARARGS, NULL},
34966          { (char *)"delete_VectorShapes", _wrap_delete_VectorShapes, METH_VARARGS, NULL},
34967          { (char *)"VectorShapes_swigregister", VectorShapes_swigregister, METH_VARARGS, NULL},
34968          { (char *)"VectorReal_iterator", _wrap_VectorReal_iterator, METH_VARARGS, NULL},
34969          { (char *)"VectorReal___nonzero__", _wrap_VectorReal___nonzero__, METH_VARARGS, NULL},
34970          { (char *)"VectorReal___bool__", _wrap_VectorReal___bool__, METH_VARARGS, NULL},
34971          { (char *)"VectorReal___len__", _wrap_VectorReal___len__, METH_VARARGS, NULL},
34972          { (char *)"VectorReal___getslice__", _wrap_VectorReal___getslice__, METH_VARARGS, NULL},
34973          { (char *)"VectorReal___setslice__", _wrap_VectorReal___setslice__, METH_VARARGS, NULL},
34974          { (char *)"VectorReal___delslice__", _wrap_VectorReal___delslice__, METH_VARARGS, NULL},
34975          { (char *)"VectorReal___delitem__", _wrap_VectorReal___delitem__, METH_VARARGS, NULL},
34976          { (char *)"VectorReal___getitem__", _wrap_VectorReal___getitem__, METH_VARARGS, NULL},
34977          { (char *)"VectorReal___setitem__", _wrap_VectorReal___setitem__, METH_VARARGS, NULL},
34978          { (char *)"VectorReal_pop", _wrap_VectorReal_pop, METH_VARARGS, NULL},
34979          { (char *)"VectorReal_append", _wrap_VectorReal_append, METH_VARARGS, NULL},
34980          { (char *)"VectorReal_empty", _wrap_VectorReal_empty, METH_VARARGS, NULL},
34981          { (char *)"VectorReal_size", _wrap_VectorReal_size, METH_VARARGS, NULL},
34982          { (char *)"VectorReal_swap", _wrap_VectorReal_swap, METH_VARARGS, NULL},
34983          { (char *)"VectorReal_begin", _wrap_VectorReal_begin, METH_VARARGS, NULL},
34984          { (char *)"VectorReal_end", _wrap_VectorReal_end, METH_VARARGS, NULL},
34985          { (char *)"VectorReal_rbegin", _wrap_VectorReal_rbegin, METH_VARARGS, NULL},
34986          { (char *)"VectorReal_rend", _wrap_VectorReal_rend, METH_VARARGS, NULL},
34987          { (char *)"VectorReal_clear", _wrap_VectorReal_clear, METH_VARARGS, NULL},
34988          { (char *)"VectorReal_get_allocator", _wrap_VectorReal_get_allocator, METH_VARARGS, NULL},
34989          { (char *)"VectorReal_pop_back", _wrap_VectorReal_pop_back, METH_VARARGS, NULL},
34990          { (char *)"VectorReal_erase", _wrap_VectorReal_erase, METH_VARARGS, NULL},
34991          { (char *)"new_VectorReal", _wrap_new_VectorReal, METH_VARARGS, NULL},
34992          { (char *)"VectorReal_push_back", _wrap_VectorReal_push_back, METH_VARARGS, NULL},
34993          { (char *)"VectorReal_front", _wrap_VectorReal_front, METH_VARARGS, NULL},
34994          { (char *)"VectorReal_back", _wrap_VectorReal_back, METH_VARARGS, NULL},
34995          { (char *)"VectorReal_assign", _wrap_VectorReal_assign, METH_VARARGS, NULL},
34996          { (char *)"VectorReal_resize", _wrap_VectorReal_resize, METH_VARARGS, NULL},
34997          { (char *)"VectorReal_insert", _wrap_VectorReal_insert, METH_VARARGS, NULL},
34998          { (char *)"VectorReal_reserve", _wrap_VectorReal_reserve, METH_VARARGS, NULL},
34999          { (char *)"VectorReal_capacity", _wrap_VectorReal_capacity, METH_VARARGS, NULL},
35000          { (char *)"delete_VectorReal", _wrap_delete_VectorReal, METH_VARARGS, NULL},
35001          { (char *)"VectorReal_swigregister", VectorReal_swigregister, METH_VARARGS, NULL},
35002          { (char *)"VectorInt_iterator", _wrap_VectorInt_iterator, METH_VARARGS, NULL},
35003          { (char *)"VectorInt___nonzero__", _wrap_VectorInt___nonzero__, METH_VARARGS, NULL},
35004          { (char *)"VectorInt___bool__", _wrap_VectorInt___bool__, METH_VARARGS, NULL},
35005          { (char *)"VectorInt___len__", _wrap_VectorInt___len__, METH_VARARGS, NULL},
35006          { (char *)"VectorInt___getslice__", _wrap_VectorInt___getslice__, METH_VARARGS, NULL},
35007          { (char *)"VectorInt___setslice__", _wrap_VectorInt___setslice__, METH_VARARGS, NULL},
35008          { (char *)"VectorInt___delslice__", _wrap_VectorInt___delslice__, METH_VARARGS, NULL},
35009          { (char *)"VectorInt___delitem__", _wrap_VectorInt___delitem__, METH_VARARGS, NULL},
35010          { (char *)"VectorInt___getitem__", _wrap_VectorInt___getitem__, METH_VARARGS, NULL},
35011          { (char *)"VectorInt___setitem__", _wrap_VectorInt___setitem__, METH_VARARGS, NULL},
35012          { (char *)"VectorInt_pop", _wrap_VectorInt_pop, METH_VARARGS, NULL},
35013          { (char *)"VectorInt_append", _wrap_VectorInt_append, METH_VARARGS, NULL},
35014          { (char *)"VectorInt_empty", _wrap_VectorInt_empty, METH_VARARGS, NULL},
35015          { (char *)"VectorInt_size", _wrap_VectorInt_size, METH_VARARGS, NULL},
35016          { (char *)"VectorInt_swap", _wrap_VectorInt_swap, METH_VARARGS, NULL},
35017          { (char *)"VectorInt_begin", _wrap_VectorInt_begin, METH_VARARGS, NULL},
35018          { (char *)"VectorInt_end", _wrap_VectorInt_end, METH_VARARGS, NULL},
35019          { (char *)"VectorInt_rbegin", _wrap_VectorInt_rbegin, METH_VARARGS, NULL},
35020          { (char *)"VectorInt_rend", _wrap_VectorInt_rend, METH_VARARGS, NULL},
35021          { (char *)"VectorInt_clear", _wrap_VectorInt_clear, METH_VARARGS, NULL},
35022          { (char *)"VectorInt_get_allocator", _wrap_VectorInt_get_allocator, METH_VARARGS, NULL},
35023          { (char *)"VectorInt_pop_back", _wrap_VectorInt_pop_back, METH_VARARGS, NULL},
35024          { (char *)"VectorInt_erase", _wrap_VectorInt_erase, METH_VARARGS, NULL},
35025          { (char *)"new_VectorInt", _wrap_new_VectorInt, METH_VARARGS, NULL},
35026          { (char *)"VectorInt_push_back", _wrap_VectorInt_push_back, METH_VARARGS, NULL},
35027          { (char *)"VectorInt_front", _wrap_VectorInt_front, METH_VARARGS, NULL},
35028          { (char *)"VectorInt_back", _wrap_VectorInt_back, METH_VARARGS, NULL},
35029          { (char *)"VectorInt_assign", _wrap_VectorInt_assign, METH_VARARGS, NULL},
35030          { (char *)"VectorInt_resize", _wrap_VectorInt_resize, METH_VARARGS, NULL},
35031          { (char *)"VectorInt_insert", _wrap_VectorInt_insert, METH_VARARGS, NULL},
35032          { (char *)"VectorInt_reserve", _wrap_VectorInt_reserve, METH_VARARGS, NULL},
35033          { (char *)"VectorInt_capacity", _wrap_VectorInt_capacity, METH_VARARGS, NULL},
35034          { (char *)"delete_VectorInt", _wrap_delete_VectorInt, METH_VARARGS, NULL},
35035          { (char *)"VectorInt_swigregister", VectorInt_swigregister, METH_VARARGS, NULL},
35036          { (char *)"get_temp_name", _wrap_get_temp_name, METH_VARARGS, NULL},
35037          { (char *)"fatal_error", _wrap_fatal_error, METH_VARARGS, NULL},
35038          { (char *)"prod_scalaire", _wrap_prod_scalaire, METH_VARARGS, NULL},
35039          { (char *)"prod_vectoriel", _wrap_prod_vectoriel, METH_VARARGS, NULL},
35040          { (char *)"prod_mixte", _wrap_prod_mixte, METH_VARARGS, NULL},
35041          { (char *)"deg2radians", _wrap_deg2radians, METH_VARARGS, NULL},
35042          { (char *)"rad2degres", _wrap_rad2degres, METH_VARARGS, NULL},
35043          { (char *)"calc_norme", _wrap_calc_norme, METH_VARARGS, NULL},
35044          { (char *)"calc_distance", _wrap_calc_distance, METH_VARARGS, NULL},
35045          { (char *)"calc_d2", _wrap_calc_d2, METH_VARARGS, NULL},
35046          { (char *)"calc_vecteur", _wrap_calc_vecteur, METH_VARARGS, NULL},
35047          { (char *)"copy_vecteur", _wrap_copy_vecteur, METH_VARARGS, NULL},
35048          { (char *)"calc_milieu", _wrap_calc_milieu, METH_VARARGS, NULL},
35049          { (char *)"normer_vecteur", _wrap_normer_vecteur, METH_VARARGS, NULL},
35050          { (char *)"carre", _wrap_carre, METH_VARARGS, NULL},
35051          { (char *)"same_coords", _wrap_same_coords, METH_VARARGS, NULL},
35052          { (char *)"requals", _wrap_requals, METH_VARARGS, NULL},
35053          { (char *)"on_debug", _wrap_on_debug, METH_VARARGS, NULL},
35054          { (char *)"in_test", _wrap_in_test, METH_VARARGS, NULL},
35055          { (char *)"niv_debug", _wrap_niv_debug, METH_VARARGS, NULL},
35056          { (char *)"set_minus", _wrap_set_minus, METH_VARARGS, NULL},
35057          { (char *)"special_option", _wrap_special_option, METH_VARARGS, NULL},
35058          { (char *)"set_special_option", _wrap_set_special_option, METH_VARARGS, NULL},
35059          { (char *)"sizeof_file", _wrap_sizeof_file, METH_VARARGS, NULL},
35060          { (char *)"read_file", _wrap_read_file, METH_VARARGS, NULL},
35061          { (char *)"get_time", _wrap_get_time, METH_VARARGS, NULL},
35062          { (char *)"make_basename", _wrap_make_basename, METH_VARARGS, NULL},
35063          { (char *)"EltBase_countHexa", _wrap_EltBase_countHexa, METH_VARARGS, NULL},
35064          { (char *)"EltBase_countQuad", _wrap_EltBase_countQuad, METH_VARARGS, NULL},
35065          { (char *)"EltBase_countEdge", _wrap_EltBase_countEdge, METH_VARARGS, NULL},
35066          { (char *)"EltBase_countVertex", _wrap_EltBase_countVertex, METH_VARARGS, NULL},
35067          { (char *)"EltBase_setError", _wrap_EltBase_setError, METH_VARARGS, NULL},
35068          { (char *)"EltBase_getError", _wrap_EltBase_getError, METH_VARARGS, NULL},
35069          { (char *)"EltBase_isValid", _wrap_EltBase_isValid, METH_VARARGS, NULL},
35070          { (char *)"EltBase_isBad", _wrap_EltBase_isBad, METH_VARARGS, NULL},
35071          { (char *)"EltBase_duplicate", _wrap_EltBase_duplicate, METH_VARARGS, NULL},
35072          { (char *)"EltBase_clearAssociation", _wrap_EltBase_clearAssociation, METH_VARARGS, NULL},
35073          { (char *)"EltBase_replaceEdge", _wrap_EltBase_replaceEdge, METH_VARARGS, NULL},
35074          { (char *)"EltBase_replaceVertex", _wrap_EltBase_replaceVertex, METH_VARARGS, NULL},
35075          { (char *)"new_EltBase", _wrap_new_EltBase, METH_VARARGS, NULL},
35076          { (char *)"delete_EltBase", _wrap_delete_EltBase, METH_VARARGS, NULL},
35077          { (char *)"EltBase_remove", _wrap_EltBase_remove, METH_VARARGS, NULL},
35078          { (char *)"EltBase_suppress", _wrap_EltBase_suppress, METH_VARARGS, NULL},
35079          { (char *)"EltBase_dump", _wrap_EltBase_dump, METH_VARARGS, NULL},
35080          { (char *)"EltBase_saveXml", _wrap_EltBase_saveXml, METH_VARARGS, NULL},
35081          { (char *)"EltBase_majReferences", _wrap_EltBase_majReferences, METH_VARARGS, NULL},
35082          { (char *)"EltBase_makeVarName", _wrap_EltBase_makeVarName, METH_VARARGS, NULL},
35083          { (char *)"EltBase_makeName", _wrap_EltBase_makeName, METH_VARARGS, NULL},
35084          { (char *)"EltBase_next", _wrap_EltBase_next, METH_VARARGS, NULL},
35085          { (char *)"EltBase_setNext", _wrap_EltBase_setNext, METH_VARARGS, NULL},
35086          { (char *)"EltBase_getId", _wrap_EltBase_getId, METH_VARARGS, NULL},
35087          { (char *)"EltBase_setId", _wrap_EltBase_setId, METH_VARARGS, NULL},
35088          { (char *)"EltBase_dad", _wrap_EltBase_dad, METH_VARARGS, NULL},
35089          { (char *)"EltBase_getType", _wrap_EltBase_getType, METH_VARARGS, NULL},
35090          { (char *)"EltBase_isHere", _wrap_EltBase_isHere, METH_VARARGS, NULL},
35091          { (char *)"EltBase_isDeleted", _wrap_EltBase_isDeleted, METH_VARARGS, NULL},
35092          { (char *)"EltBase_razReferences", _wrap_EltBase_razReferences, METH_VARARGS, NULL},
35093          { (char *)"EltBase_addParent", _wrap_EltBase_addParent, METH_VARARGS, NULL},
35094          { (char *)"EltBase_getNbrParents", _wrap_EltBase_getNbrParents, METH_VARARGS, NULL},
35095          { (char *)"EltBase_hasParents", _wrap_EltBase_hasParents, METH_VARARGS, NULL},
35096          { (char *)"EltBase_getFather", _wrap_EltBase_getFather, METH_VARARGS, NULL},
35097          { (char *)"EltBase_getMark", _wrap_EltBase_getMark, METH_VARARGS, NULL},
35098          { (char *)"EltBase_setMark", _wrap_EltBase_setMark, METH_VARARGS, NULL},
35099          { (char *)"EltBase_printName", _wrap_EltBase_printName, METH_VARARGS, NULL},
35100          { (char *)"EltBase_dumpRef", _wrap_EltBase_dumpRef, METH_VARARGS, NULL},
35101          { (char *)"EltBase_getName", _wrap_EltBase_getName, METH_VARARGS, NULL},
35102          { (char *)"EltBase_setName", _wrap_EltBase_setName, METH_VARARGS, NULL},
35103          { (char *)"EltBase_debug", _wrap_EltBase_debug, METH_VARARGS, NULL},
35104          { (char *)"EltBase_isAssociated", _wrap_EltBase_isAssociated, METH_VARARGS, NULL},
35105          { (char *)"EltBase_getNextName", _wrap_EltBase_getNextName, METH_VARARGS, NULL},
35106          { (char *)"EltBase_swigregister", EltBase_swigregister, METH_VARARGS, NULL},
35107          { (char *)"Vertex_getX", _wrap_Vertex_getX, METH_VARARGS, NULL},
35108          { (char *)"Vertex_getY", _wrap_Vertex_getY, METH_VARARGS, NULL},
35109          { (char *)"Vertex_getZ", _wrap_Vertex_getZ, METH_VARARGS, NULL},
35110          { (char *)"Vertex_setX", _wrap_Vertex_setX, METH_VARARGS, NULL},
35111          { (char *)"Vertex_setY", _wrap_Vertex_setY, METH_VARARGS, NULL},
35112          { (char *)"Vertex_setZ", _wrap_Vertex_setZ, METH_VARARGS, NULL},
35113          { (char *)"Vertex_getAssoX", _wrap_Vertex_getAssoX, METH_VARARGS, NULL},
35114          { (char *)"Vertex_getAssoY", _wrap_Vertex_getAssoY, METH_VARARGS, NULL},
35115          { (char *)"Vertex_getAssoZ", _wrap_Vertex_getAssoZ, METH_VARARGS, NULL},
35116          { (char *)"Vertex_setAssociation", _wrap_Vertex_setAssociation, METH_VARARGS, NULL},
35117          { (char *)"Vertex_clearAssociation", _wrap_Vertex_clearAssociation, METH_VARARGS, NULL},
35118          { (char *)"Vertex_setColor", _wrap_Vertex_setColor, METH_VARARGS, NULL},
35119          { (char *)"new_Vertex", _wrap_new_Vertex, METH_VARARGS, NULL},
35120          { (char *)"delete_Vertex", _wrap_delete_Vertex, METH_VARARGS, NULL},
35121          { (char *)"Vertex_swigregister", Vertex_swigregister, METH_VARARGS, NULL},
35122          { (char *)"Edge_getVertex", _wrap_Edge_getVertex, METH_VARARGS, NULL},
35123          { (char *)"Edge_addAssociation", _wrap_Edge_addAssociation, METH_VARARGS, NULL},
35124          { (char *)"Edge_setAssociation", _wrap_Edge_setAssociation, METH_VARARGS, NULL},
35125          { (char *)"Edge_findAssociation", _wrap_Edge_findAssociation, METH_VARARGS, NULL},
35126          { (char *)"Edge_clearAssociation", _wrap_Edge_clearAssociation, METH_VARARGS, NULL},
35127          { (char *)"Edge_setColor", _wrap_Edge_setColor, METH_VARARGS, NULL},
35128          { (char *)"Edge_getWay", _wrap_Edge_getWay, METH_VARARGS, NULL},
35129          { (char *)"Edge_getLength", _wrap_Edge_getLength, METH_VARARGS, NULL},
35130          { (char *)"new_Edge", _wrap_new_Edge, METH_VARARGS, NULL},
35131          { (char *)"delete_Edge", _wrap_delete_Edge, METH_VARARGS, NULL},
35132          { (char *)"Edge_swigregister", Edge_swigregister, METH_VARARGS, NULL},
35133          { (char *)"Quad_getEdge", _wrap_Quad_getEdge, METH_VARARGS, NULL},
35134          { (char *)"Quad_getVertex", _wrap_Quad_getVertex, METH_VARARGS, NULL},
35135          { (char *)"Quad_addAssociation", _wrap_Quad_addAssociation, METH_VARARGS, NULL},
35136          { (char *)"Quad_clearAssociation", _wrap_Quad_clearAssociation, METH_VARARGS, NULL},
35137          { (char *)"Quad_setColor", _wrap_Quad_setColor, METH_VARARGS, NULL},
35138          { (char *)"Quad_nearestVertex", _wrap_Quad_nearestVertex, METH_VARARGS, NULL},
35139          { (char *)"Quad_getCenter", _wrap_Quad_getCenter, METH_VARARGS, NULL},
35140          { (char *)"new_Quad", _wrap_new_Quad, METH_VARARGS, NULL},
35141          { (char *)"delete_Quad", _wrap_delete_Quad, METH_VARARGS, NULL},
35142          { (char *)"Quad_swigregister", Quad_swigregister, METH_VARARGS, NULL},
35143          { (char *)"Hexa_getQuad", _wrap_Hexa_getQuad, METH_VARARGS, NULL},
35144          { (char *)"Hexa_getEdge", _wrap_Hexa_getEdge, METH_VARARGS, NULL},
35145          { (char *)"Hexa_getVertex", _wrap_Hexa_getVertex, METH_VARARGS, NULL},
35146          { (char *)"Hexa_setColor", _wrap_Hexa_setColor, METH_VARARGS, NULL},
35147          { (char *)"new_Hexa", _wrap_new_Hexa, METH_VARARGS, NULL},
35148          { (char *)"delete_Hexa", _wrap_delete_Hexa, METH_VARARGS, NULL},
35149          { (char *)"Hexa_swigregister", Hexa_swigregister, METH_VARARGS, NULL},
35150          { (char *)"Vector_getDx", _wrap_Vector_getDx, METH_VARARGS, NULL},
35151          { (char *)"Vector_getDy", _wrap_Vector_getDy, METH_VARARGS, NULL},
35152          { (char *)"Vector_getDz", _wrap_Vector_getDz, METH_VARARGS, NULL},
35153          { (char *)"Vector_getNorm", _wrap_Vector_getNorm, METH_VARARGS, NULL},
35154          { (char *)"Vector_getAngleX", _wrap_Vector_getAngleX, METH_VARARGS, NULL},
35155          { (char *)"new_Vector", _wrap_new_Vector, METH_VARARGS, NULL},
35156          { (char *)"delete_Vector", _wrap_delete_Vector, METH_VARARGS, NULL},
35157          { (char *)"Vector_swigregister", Vector_swigregister, METH_VARARGS, NULL},
35158          { (char *)"new_Document", _wrap_new_Document, METH_VARARGS, NULL},
35159          { (char *)"Document_dump", _wrap_Document_dump, METH_VARARGS, NULL},
35160          { (char *)"Document_setName", _wrap_Document_setName, METH_VARARGS, NULL},
35161          { (char *)"Document_setLevel", _wrap_Document_setLevel, METH_VARARGS, NULL},
35162          { (char *)"Document_save", _wrap_Document_save, METH_VARARGS, NULL},
35163          { (char *)"Document_saveVtk", _wrap_Document_saveVtk, METH_VARARGS, NULL},
35164          { (char *)"Document_purge", _wrap_Document_purge, METH_VARARGS, NULL},
35165          { (char *)"Document_setTolerance", _wrap_Document_setTolerance, METH_VARARGS, NULL},
35166          { (char *)"Document_getTolerance", _wrap_Document_getTolerance, METH_VARARGS, NULL},
35167          { (char *)"Document_addVertex", _wrap_Document_addVertex, METH_VARARGS, NULL},
35168          { (char *)"Document_addEdge", _wrap_Document_addEdge, METH_VARARGS, NULL},
35169          { (char *)"Document_addEdgeVector", _wrap_Document_addEdgeVector, METH_VARARGS, NULL},
35170          { (char *)"Document_addQuad", _wrap_Document_addQuad, METH_VARARGS, NULL},
35171          { (char *)"Document_addQuadVertices", _wrap_Document_addQuadVertices, METH_VARARGS, NULL},
35172          { (char *)"Document_addHexa", _wrap_Document_addHexa, METH_VARARGS, NULL},
35173          { (char *)"Document_addHexaVertices", _wrap_Document_addHexaVertices, METH_VARARGS, NULL},
35174          { (char *)"Document_addHexa2Quads", _wrap_Document_addHexa2Quads, METH_VARARGS, NULL},
35175          { (char *)"Document_addHexa3Quads", _wrap_Document_addHexa3Quads, METH_VARARGS, NULL},
35176          { (char *)"Document_addHexa4Quads", _wrap_Document_addHexa4Quads, METH_VARARGS, NULL},
35177          { (char *)"Document_addHexa5Quads", _wrap_Document_addHexa5Quads, METH_VARARGS, NULL},
35178          { (char *)"Document_addVector", _wrap_Document_addVector, METH_VARARGS, NULL},
35179          { (char *)"Document_addVectorVertices", _wrap_Document_addVectorVertices, METH_VARARGS, NULL},
35180          { (char *)"Document_addLaws", _wrap_Document_addLaws, METH_VARARGS, NULL},
35181          { (char *)"Document_addHexaGroup", _wrap_Document_addHexaGroup, METH_VARARGS, NULL},
35182          { (char *)"Document_addQuadGroup", _wrap_Document_addQuadGroup, METH_VARARGS, NULL},
35183          { (char *)"Document_addQuadNodeGroup", _wrap_Document_addQuadNodeGroup, METH_VARARGS, NULL},
35184          { (char *)"Document_addHexaNodeGroup", _wrap_Document_addHexaNodeGroup, METH_VARARGS, NULL},
35185          { (char *)"Document_addEdgeGroup", _wrap_Document_addEdgeGroup, METH_VARARGS, NULL},
35186          { (char *)"Document_addEdgeNodeGroup", _wrap_Document_addEdgeNodeGroup, METH_VARARGS, NULL},
35187          { (char *)"Document_addVertexNodeGroup", _wrap_Document_addVertexNodeGroup, METH_VARARGS, NULL},
35188          { (char *)"Document_makeTranslation", _wrap_Document_makeTranslation, METH_VARARGS, NULL},
35189          { (char *)"Document_makeScale", _wrap_Document_makeScale, METH_VARARGS, NULL},
35190          { (char *)"Document_makeRotation", _wrap_Document_makeRotation, METH_VARARGS, NULL},
35191          { (char *)"Document_makeSymmetryPoint", _wrap_Document_makeSymmetryPoint, METH_VARARGS, NULL},
35192          { (char *)"Document_makeSymmetryLine", _wrap_Document_makeSymmetryLine, METH_VARARGS, NULL},
35193          { (char *)"Document_makeSymmetryPlane", _wrap_Document_makeSymmetryPlane, METH_VARARGS, NULL},
35194          { (char *)"Document_performTranslation", _wrap_Document_performTranslation, METH_VARARGS, NULL},
35195          { (char *)"Document_performScale", _wrap_Document_performScale, METH_VARARGS, NULL},
35196          { (char *)"Document_performRotation", _wrap_Document_performRotation, METH_VARARGS, NULL},
35197          { (char *)"Document_performSymmetryPoint", _wrap_Document_performSymmetryPoint, METH_VARARGS, NULL},
35198          { (char *)"Document_performSymmetryLine", _wrap_Document_performSymmetryLine, METH_VARARGS, NULL},
35199          { (char *)"Document_performSymmetryPlane", _wrap_Document_performSymmetryPlane, METH_VARARGS, NULL},
35200          { (char *)"Document_disconnectQuad", _wrap_Document_disconnectQuad, METH_VARARGS, NULL},
35201          { (char *)"Document_disconnectEdge", _wrap_Document_disconnectEdge, METH_VARARGS, NULL},
35202          { (char *)"Document_disconnectVertex", _wrap_Document_disconnectVertex, METH_VARARGS, NULL},
35203          { (char *)"Document_disconnectEdges", _wrap_Document_disconnectEdges, METH_VARARGS, NULL},
35204          { (char *)"Document_replace", _wrap_Document_replace, METH_VARARGS, NULL},
35205          { (char *)"Document_mergeVertices", _wrap_Document_mergeVertices, METH_VARARGS, NULL},
35206          { (char *)"Document_mergeEdges", _wrap_Document_mergeEdges, METH_VARARGS, NULL},
35207          { (char *)"Document_mergeQuads", _wrap_Document_mergeQuads, METH_VARARGS, NULL},
35208          { (char *)"Document_clearAssociation", _wrap_Document_clearAssociation, METH_VARARGS, NULL},
35209          { (char *)"Document_associateOpenedLine", _wrap_Document_associateOpenedLine, METH_VARARGS, NULL},
35210          { (char *)"Document_associateClosedLine", _wrap_Document_associateClosedLine, METH_VARARGS, NULL},
35211          { (char *)"Document_countHexa", _wrap_Document_countHexa, METH_VARARGS, NULL},
35212          { (char *)"Document_countQuad", _wrap_Document_countQuad, METH_VARARGS, NULL},
35213          { (char *)"Document_countEdge", _wrap_Document_countEdge, METH_VARARGS, NULL},
35214          { (char *)"Document_countVertex", _wrap_Document_countVertex, METH_VARARGS, NULL},
35215          { (char *)"Document_countVector", _wrap_Document_countVector, METH_VARARGS, NULL},
35216          { (char *)"Document_countGroup", _wrap_Document_countGroup, METH_VARARGS, NULL},
35217          { (char *)"Document_countLaw", _wrap_Document_countLaw, METH_VARARGS, NULL},
35218          { (char *)"Document_countPropagation", _wrap_Document_countPropagation, METH_VARARGS, NULL},
35219          { (char *)"Document_countShape", _wrap_Document_countShape, METH_VARARGS, NULL},
35220          { (char *)"Document_countUsedHexa", _wrap_Document_countUsedHexa, METH_VARARGS, NULL},
35221          { (char *)"Document_countUsedQuad", _wrap_Document_countUsedQuad, METH_VARARGS, NULL},
35222          { (char *)"Document_countUsedEdge", _wrap_Document_countUsedEdge, METH_VARARGS, NULL},
35223          { (char *)"Document_countUsedVertex", _wrap_Document_countUsedVertex, METH_VARARGS, NULL},
35224          { (char *)"Document_getHexa", _wrap_Document_getHexa, METH_VARARGS, NULL},
35225          { (char *)"Document_getQuad", _wrap_Document_getQuad, METH_VARARGS, NULL},
35226          { (char *)"Document_getEdge", _wrap_Document_getEdge, METH_VARARGS, NULL},
35227          { (char *)"Document_getVertex", _wrap_Document_getVertex, METH_VARARGS, NULL},
35228          { (char *)"Document_getUsedHexa", _wrap_Document_getUsedHexa, METH_VARARGS, NULL},
35229          { (char *)"Document_getUsedQuad", _wrap_Document_getUsedQuad, METH_VARARGS, NULL},
35230          { (char *)"Document_getUsedEdge", _wrap_Document_getUsedEdge, METH_VARARGS, NULL},
35231          { (char *)"Document_getUsedVertex", _wrap_Document_getUsedVertex, METH_VARARGS, NULL},
35232          { (char *)"Document_getVector", _wrap_Document_getVector, METH_VARARGS, NULL},
35233          { (char *)"Document_getShape", _wrap_Document_getShape, METH_VARARGS, NULL},
35234          { (char *)"Document_getGroup", _wrap_Document_getGroup, METH_VARARGS, NULL},
35235          { (char *)"Document_getLaw", _wrap_Document_getLaw, METH_VARARGS, NULL},
35236          { (char *)"Document_getPropagation", _wrap_Document_getPropagation, METH_VARARGS, NULL},
35237          { (char *)"Document_getFirstExplicitShape", _wrap_Document_getFirstExplicitShape, METH_VARARGS, NULL},
35238          { (char *)"Document_findEdge", _wrap_Document_findEdge, METH_VARARGS, NULL},
35239          { (char *)"Document_findQuad", _wrap_Document_findQuad, METH_VARARGS, NULL},
35240          { (char *)"Document_findHexa", _wrap_Document_findHexa, METH_VARARGS, NULL},
35241          { (char *)"Document_findGroup", _wrap_Document_findGroup, METH_VARARGS, NULL},
35242          { (char *)"Document_findLaw", _wrap_Document_findLaw, METH_VARARGS, NULL},
35243          { (char *)"Document_findPropagation", _wrap_Document_findPropagation, METH_VARARGS, NULL},
35244          { (char *)"Document_removeHexa", _wrap_Document_removeHexa, METH_VARARGS, NULL},
35245          { (char *)"Document_removeQuad", _wrap_Document_removeQuad, METH_VARARGS, NULL},
35246          { (char *)"Document_removeConnectedHexa", _wrap_Document_removeConnectedHexa, METH_VARARGS, NULL},
35247          { (char *)"Document_removeElements", _wrap_Document_removeElements, METH_VARARGS, NULL},
35248          { (char *)"Document_removeGroup", _wrap_Document_removeGroup, METH_VARARGS, NULL},
35249          { (char *)"Document_removeLaw", _wrap_Document_removeLaw, METH_VARARGS, NULL},
35250          { (char *)"Document_makeCartesianTop", _wrap_Document_makeCartesianTop, METH_VARARGS, NULL},
35251          { (char *)"Document_makeCartesianUni", _wrap_Document_makeCartesianUni, METH_VARARGS, NULL},
35252          { (char *)"Document_makeCartesian", _wrap_Document_makeCartesian, METH_VARARGS, NULL},
35253          { (char *)"Document_makeCylinderTop", _wrap_Document_makeCylinderTop, METH_VARARGS, NULL},
35254          { (char *)"Document_makeCylinderUni", _wrap_Document_makeCylinderUni, METH_VARARGS, NULL},
35255          { (char *)"Document_makeCylinder", _wrap_Document_makeCylinder, METH_VARARGS, NULL},
35256          { (char *)"Document_makePipeTop", _wrap_Document_makePipeTop, METH_VARARGS, NULL},
35257          { (char *)"Document_makePipeUni", _wrap_Document_makePipeUni, METH_VARARGS, NULL},
35258          { (char *)"Document_makePipe", _wrap_Document_makePipe, METH_VARARGS, NULL},
35259          { (char *)"Document_makeSphericalTop", _wrap_Document_makeSphericalTop, METH_VARARGS, NULL},
35260          { (char *)"Document_makeSphericalUni", _wrap_Document_makeSphericalUni, METH_VARARGS, NULL},
35261          { (char *)"Document_makeSpherical", _wrap_Document_makeSpherical, METH_VARARGS, NULL},
35262          { (char *)"Document_makeSphereTop", _wrap_Document_makeSphereTop, METH_VARARGS, NULL},
35263          { (char *)"Document_makeSphereUni", _wrap_Document_makeSphereUni, METH_VARARGS, NULL},
35264          { (char *)"Document_makeSphere", _wrap_Document_makeSphere, METH_VARARGS, NULL},
35265          { (char *)"Document_makeRindTop", _wrap_Document_makeRindTop, METH_VARARGS, NULL},
35266          { (char *)"Document_makeRindUni", _wrap_Document_makeRindUni, METH_VARARGS, NULL},
35267          { (char *)"Document_makeRind", _wrap_Document_makeRind, METH_VARARGS, NULL},
35268          { (char *)"Document_makeCylinders", _wrap_Document_makeCylinders, METH_VARARGS, NULL},
35269          { (char *)"Document_makePipes", _wrap_Document_makePipes, METH_VARARGS, NULL},
35270          { (char *)"Document_extrudeQuadTop", _wrap_Document_extrudeQuadTop, METH_VARARGS, NULL},
35271          { (char *)"Document_extrudeQuadUni", _wrap_Document_extrudeQuadUni, METH_VARARGS, NULL},
35272          { (char *)"Document_extrudeQuad", _wrap_Document_extrudeQuad, METH_VARARGS, NULL},
35273          { (char *)"Document_extrudeQuadsTop", _wrap_Document_extrudeQuadsTop, METH_VARARGS, NULL},
35274          { (char *)"Document_extrudeQuadsUni", _wrap_Document_extrudeQuadsUni, METH_VARARGS, NULL},
35275          { (char *)"Document_extrudeQuads", _wrap_Document_extrudeQuads, METH_VARARGS, NULL},
35276          { (char *)"Document_revolutionQuadUni", _wrap_Document_revolutionQuadUni, METH_VARARGS, NULL},
35277          { (char *)"Document_revolutionQuad", _wrap_Document_revolutionQuad, METH_VARARGS, NULL},
35278          { (char *)"Document_revolutionQuadsUni", _wrap_Document_revolutionQuadsUni, METH_VARARGS, NULL},
35279          { (char *)"Document_revolutionQuads", _wrap_Document_revolutionQuads, METH_VARARGS, NULL},
35280          { (char *)"Document_joinQuadUni", _wrap_Document_joinQuadUni, METH_VARARGS, NULL},
35281          { (char *)"Document_joinQuadsUni", _wrap_Document_joinQuadsUni, METH_VARARGS, NULL},
35282          { (char *)"Document_joinQuad", _wrap_Document_joinQuad, METH_VARARGS, NULL},
35283          { (char *)"Document_joinQuads", _wrap_Document_joinQuads, METH_VARARGS, NULL},
35284          { (char *)"Document_cutUni", _wrap_Document_cutUni, METH_VARARGS, NULL},
35285          { (char *)"Document_cut", _wrap_Document_cut, METH_VARARGS, NULL},
35286          { (char *)"Document_addGroup", _wrap_Document_addGroup, METH_VARARGS, NULL},
35287          { (char *)"Document_isSaved", _wrap_Document_isSaved, METH_VARARGS, NULL},
35288          { (char *)"Document_appendXml", _wrap_Document_appendXml, METH_VARARGS, NULL},
35289          { (char *)"Document_getXml", _wrap_Document_getXml, METH_VARARGS, NULL},
35290          { (char *)"Document_getLevel", _wrap_Document_getLevel, METH_VARARGS, NULL},
35291          { (char *)"Document_findVertex", _wrap_Document_findVertex, METH_VARARGS, NULL},
35292          { (char *)"Document_closeQuads", _wrap_Document_closeQuads, METH_VARARGS, NULL},
35293          { (char *)"Document_addLaw", _wrap_Document_addLaw, METH_VARARGS, NULL},
35294          { (char *)"Document_checkAssociations", _wrap_Document_checkAssociations, METH_VARARGS, NULL},
35295          { (char *)"Document_addShape", _wrap_Document_addShape, METH_VARARGS, NULL},
35296          { (char *)"delete_Document", _wrap_delete_Document, METH_VARARGS, NULL},
35297          { (char *)"Document_swigregister", Document_swigregister, METH_VARARGS, NULL},
35298          { (char *)"Propagation_getEdges", _wrap_Propagation_getEdges, METH_VARARGS, NULL},
35299          { (char *)"Propagation_getLaw", _wrap_Propagation_getLaw, METH_VARARGS, NULL},
35300          { (char *)"Propagation_getWay", _wrap_Propagation_getWay, METH_VARARGS, NULL},
35301          { (char *)"Propagation_setWay", _wrap_Propagation_setWay, METH_VARARGS, NULL},
35302          { (char *)"Propagation_setLaw", _wrap_Propagation_setLaw, METH_VARARGS, NULL},
35303          { (char *)"new_Propagation", _wrap_new_Propagation, METH_VARARGS, NULL},
35304          { (char *)"Propagation_saveXml", _wrap_Propagation_saveXml, METH_VARARGS, NULL},
35305          { (char *)"Propagation_addEdge", _wrap_Propagation_addEdge, METH_VARARGS, NULL},
35306          { (char *)"Propagation_majLaw", _wrap_Propagation_majLaw, METH_VARARGS, NULL},
35307          { (char *)"delete_Propagation", _wrap_delete_Propagation, METH_VARARGS, NULL},
35308          { (char *)"Propagation_swigregister", Propagation_swigregister, METH_VARARGS, NULL},
35309          { (char *)"hex_instance", _wrap_hex_instance, METH_VARARGS, NULL},
35310          { (char *)"Hex_getInstance", _wrap_Hex_getInstance, METH_VARARGS, NULL},
35311          { (char *)"Hex_countDocument", _wrap_Hex_countDocument, METH_VARARGS, NULL},
35312          { (char *)"Hex_getDocument", _wrap_Hex_getDocument, METH_VARARGS, NULL},
35313          { (char *)"Hex_removeDocument", _wrap_Hex_removeDocument, METH_VARARGS, NULL},
35314          { (char *)"Hex_addDocument", _wrap_Hex_addDocument, METH_VARARGS, NULL},
35315          { (char *)"Hex_loadDocument", _wrap_Hex_loadDocument, METH_VARARGS, NULL},
35316          { (char *)"Hex_findDocument", _wrap_Hex_findDocument, METH_VARARGS, NULL},
35317          { (char *)"Hex_what", _wrap_Hex_what, METH_VARARGS, NULL},
35318          { (char *)"Hex_sizeofMessage", _wrap_Hex_sizeofMessage, METH_VARARGS, NULL},
35319          { (char *)"Hex_getMessageLine", _wrap_Hex_getMessageLine, METH_VARARGS, NULL},
35320          { (char *)"new_Hex", _wrap_new_Hex, METH_VARARGS, NULL},
35321          { (char *)"delete_Hex", _wrap_delete_Hex, METH_VARARGS, NULL},
35322          { (char *)"Hex_swigregister", Hex_swigregister, METH_VARARGS, NULL},
35323          { (char *)"what", _wrap_what, METH_VARARGS, NULL},
35324          { (char *)"Elements_getHexa", _wrap_Elements_getHexa, METH_VARARGS, NULL},
35325          { (char *)"Elements_getQuad", _wrap_Elements_getQuad, METH_VARARGS, NULL},
35326          { (char *)"Elements_getEdge", _wrap_Elements_getEdge, METH_VARARGS, NULL},
35327          { (char *)"Elements_getVertex", _wrap_Elements_getVertex, METH_VARARGS, NULL},
35328          { (char *)"Elements_getHexaIJK", _wrap_Elements_getHexaIJK, METH_VARARGS, NULL},
35329          { (char *)"Elements_getQuadIJ", _wrap_Elements_getQuadIJ, METH_VARARGS, NULL},
35330          { (char *)"Elements_getQuadJK", _wrap_Elements_getQuadJK, METH_VARARGS, NULL},
35331          { (char *)"Elements_getQuadIK", _wrap_Elements_getQuadIK, METH_VARARGS, NULL},
35332          { (char *)"Elements_getEdgeI", _wrap_Elements_getEdgeI, METH_VARARGS, NULL},
35333          { (char *)"Elements_getEdgeJ", _wrap_Elements_getEdgeJ, METH_VARARGS, NULL},
35334          { (char *)"Elements_getEdgeK", _wrap_Elements_getEdgeK, METH_VARARGS, NULL},
35335          { (char *)"Elements_getVertexIJK", _wrap_Elements_getVertexIJK, METH_VARARGS, NULL},
35336          { (char *)"Elements_countHexa", _wrap_Elements_countHexa, METH_VARARGS, NULL},
35337          { (char *)"Elements_countQuad", _wrap_Elements_countQuad, METH_VARARGS, NULL},
35338          { (char *)"Elements_countEdge", _wrap_Elements_countEdge, METH_VARARGS, NULL},
35339          { (char *)"Elements_countVertex", _wrap_Elements_countVertex, METH_VARARGS, NULL},
35340          { (char *)"Elements_nearestVertex", _wrap_Elements_nearestVertex, METH_VARARGS, NULL},
35341          { (char *)"Elements_findVertex", _wrap_Elements_findVertex, METH_VARARGS, NULL},
35342          { (char *)"Elements_clearAssociation", _wrap_Elements_clearAssociation, METH_VARARGS, NULL},
35343          { (char *)"Elements_saveVtk", _wrap_Elements_saveVtk, METH_VARARGS, NULL},
35344          { (char *)"new_Elements", _wrap_new_Elements, METH_VARARGS, NULL},
35345          { (char *)"delete_Elements", _wrap_delete_Elements, METH_VARARGS, NULL},
35346          { (char *)"Elements_swigregister", Elements_swigregister, METH_VARARGS, NULL},
35347          { (char *)"new_BiCylinder", _wrap_new_BiCylinder, METH_VARARGS, NULL},
35348          { (char *)"BiCylinder_getHexaIJK", _wrap_BiCylinder_getHexaIJK, METH_VARARGS, NULL},
35349          { (char *)"BiCylinder_getQuadIJ", _wrap_BiCylinder_getQuadIJ, METH_VARARGS, NULL},
35350          { (char *)"BiCylinder_getQuadJK", _wrap_BiCylinder_getQuadJK, METH_VARARGS, NULL},
35351          { (char *)"BiCylinder_getQuadIK", _wrap_BiCylinder_getQuadIK, METH_VARARGS, NULL},
35352          { (char *)"BiCylinder_getEdgeI", _wrap_BiCylinder_getEdgeI, METH_VARARGS, NULL},
35353          { (char *)"BiCylinder_getEdgeJ", _wrap_BiCylinder_getEdgeJ, METH_VARARGS, NULL},
35354          { (char *)"BiCylinder_getEdgeK", _wrap_BiCylinder_getEdgeK, METH_VARARGS, NULL},
35355          { (char *)"BiCylinder_getVertexIJK", _wrap_BiCylinder_getVertexIJK, METH_VARARGS, NULL},
35356          { (char *)"delete_BiCylinder", _wrap_delete_BiCylinder, METH_VARARGS, NULL},
35357          { (char *)"BiCylinder_swigregister", BiCylinder_swigregister, METH_VARARGS, NULL},
35358          { (char *)"NewShape_countVertex", _wrap_NewShape_countVertex, METH_VARARGS, NULL},
35359          { (char *)"NewShape_countEdge", _wrap_NewShape_countEdge, METH_VARARGS, NULL},
35360          { (char *)"NewShape_countFace", _wrap_NewShape_countFace, METH_VARARGS, NULL},
35361          { (char *)"NewShape_getVertex", _wrap_NewShape_getVertex, METH_VARARGS, NULL},
35362          { (char *)"NewShape_getEdge", _wrap_NewShape_getEdge, METH_VARARGS, NULL},
35363          { (char *)"NewShape_getFace", _wrap_NewShape_getFace, METH_VARARGS, NULL},
35364          { (char *)"NewShape_getNameVertex", _wrap_NewShape_getNameVertex, METH_VARARGS, NULL},
35365          { (char *)"NewShape_getNameEdge", _wrap_NewShape_getNameEdge, METH_VARARGS, NULL},
35366          { (char *)"NewShape_getNameFace", _wrap_NewShape_getNameFace, METH_VARARGS, NULL},
35367          { (char *)"new_NewShape", _wrap_new_NewShape, METH_VARARGS, NULL},
35368          { (char *)"delete_NewShape", _wrap_delete_NewShape, METH_VARARGS, NULL},
35369          { (char *)"NewShape_swigregister", NewShape_swigregister, METH_VARARGS, NULL},
35370          { (char *)"Group_addElement", _wrap_Group_addElement, METH_VARARGS, NULL},
35371          { (char *)"Group_countElement", _wrap_Group_countElement, METH_VARARGS, NULL},
35372          { (char *)"Group_getKind", _wrap_Group_getKind, METH_VARARGS, NULL},
35373          { (char *)"Group_clearElement", _wrap_Group_clearElement, METH_VARARGS, NULL},
35374          { (char *)"Group_removeElement", _wrap_Group_removeElement, METH_VARARGS, NULL},
35375          { (char *)"Group_getElement", _wrap_Group_getElement, METH_VARARGS, NULL},
35376          { (char *)"new_Group", _wrap_new_Group, METH_VARARGS, NULL},
35377          { (char *)"delete_Group", _wrap_delete_Group, METH_VARARGS, NULL},
35378          { (char *)"Group_swigregister", Group_swigregister, METH_VARARGS, NULL},
35379          { NULL, NULL, 0, NULL }
35380 };
35381
35382
35383 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
35384
35385 static void *_p_Hex__VectorTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35386     return (void *)((Hex::EltBase *)  ((Hex::Vector *) x));
35387 }
35388 static void *_p_Hex__NewShapeTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35389     return (void *)((Hex::EltBase *)  ((Hex::NewShape *) x));
35390 }
35391 static void *_p_Hex__GroupTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35392     return (void *)((Hex::EltBase *)  ((Hex::Group *) x));
35393 }
35394 static void *_p_Hex__PropagationTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35395     return (void *)((Hex::EltBase *)  ((Hex::Propagation *) x));
35396 }
35397 static void *_p_Hex__VertexTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35398     return (void *)((Hex::EltBase *)  ((Hex::Vertex *) x));
35399 }
35400 static void *_p_Hex__HexaTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35401     return (void *)((Hex::EltBase *)  ((Hex::Hexa *) x));
35402 }
35403 static void *_p_Hex__EdgeTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35404     return (void *)((Hex::EltBase *)  ((Hex::Edge *) x));
35405 }
35406 static void *_p_Hex__QuadTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35407     return (void *)((Hex::EltBase *)  ((Hex::Quad *) x));
35408 }
35409 static void *_p_Hex__ElementsTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35410     return (void *)((Hex::EltBase *)  ((Hex::Elements *) x));
35411 }
35412 static void *_p_Hex__DocumentTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35413     return (void *)((Hex::EltBase *)  ((Hex::Document *) x));
35414 }
35415 static void *_p_Hex__BiCylinderTo_p_Hex__EltBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35416     return (void *)((Hex::EltBase *) (Hex::Elements *) ((Hex::BiCylinder *) x));
35417 }
35418 static void *_p_Hex__BiCylinderTo_p_Hex__Elements(void *x, int *SWIGUNUSEDPARM(newmemory)) {
35419     return (void *)((Hex::Elements *)  ((Hex::BiCylinder *) x));
35420 }
35421 static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *|pfile", 0, 0, (void*)0, 0};
35422 static swig_type_info _swigt__p_Hex__BiCylinder = {"_p_Hex__BiCylinder", "Hex::BiCylinder *", 0, 0, (void*)0, 0};
35423 static swig_type_info _swigt__p_Hex__Document = {"_p_Hex__Document", "Hex::Document *", 0, 0, (void*)0, 0};
35424 static swig_type_info _swigt__p_Hex__Edge = {"_p_Hex__Edge", "std::vector< Hex::Edge * >::value_type|Hex::Edge *", 0, 0, (void*)0, 0};
35425 static swig_type_info _swigt__p_Hex__Elements = {"_p_Hex__Elements", "Hex::Elements *", 0, 0, (void*)0, 0};
35426 static swig_type_info _swigt__p_Hex__EltBase = {"_p_Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
35427 static swig_type_info _swigt__p_Hex__Group = {"_p_Hex__Group", "Hex::Group *", 0, 0, (void*)0, 0};
35428 static swig_type_info _swigt__p_Hex__Hex = {"_p_Hex__Hex", "Hex::Hex *", 0, 0, (void*)0, 0};
35429 static swig_type_info _swigt__p_Hex__Hex__Elements = {"_p_Hex__Hex__Elements", "Hex::Elements *", 0, 0, (void*)0, 0};
35430 static swig_type_info _swigt__p_Hex__Hex__EltBase = {"_p_Hex__Hex__EltBase", "Hex::EltBase *", 0, 0, (void*)0, 0};
35431 static swig_type_info _swigt__p_Hex__Hexa = {"_p_Hex__Hexa", "Hex::Hexa *|std::vector< Hex::Hexa * >::value_type", 0, 0, (void*)0, 0};
35432 static swig_type_info _swigt__p_Hex__Law = {"_p_Hex__Law", "Hex::Law *", 0, 0, (void*)0, 0};
35433 static swig_type_info _swigt__p_Hex__NewShape = {"_p_Hex__NewShape", "std::vector< Hex::NewShape * >::value_type|Hex::NewShape *", 0, 0, (void*)0, 0};
35434 static swig_type_info _swigt__p_Hex__Propagation = {"_p_Hex__Propagation", "Hex::Propagation *", 0, 0, (void*)0, 0};
35435 static swig_type_info _swigt__p_Hex__Quad = {"_p_Hex__Quad", "std::vector< Hex::Quad * >::value_type|Hex::Quad *", 0, 0, (void*)0, 0};
35436 static swig_type_info _swigt__p_Hex__Shape = {"_p_Hex__Shape", "Hex::Shape *|Hex::OldShape *", 0, 0, (void*)0, 0};
35437 static swig_type_info _swigt__p_Hex__Vector = {"_p_Hex__Vector", "Hex::Vector *", 0, 0, (void*)0, 0};
35438 static swig_type_info _swigt__p_Hex__Vertex = {"_p_Hex__Vertex", "std::vector< Hex::Vertex * >::value_type|Hex::Vertex *", 0, 0, (void*)0, 0};
35439 static swig_type_info _swigt__p_Hex__XmlWriter = {"_p_Hex__XmlWriter", "Hex::XmlWriter *", 0, 0, (void*)0, 0};
35440 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};
35441 static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
35442 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
35443 static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
35444 static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
35445 static swig_type_info _swigt__p_double = {"_p_double", "double *|Hex::Real *", 0, 0, (void*)0, 0};
35446 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
35447 static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
35448 static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
35449 static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
35450 static swig_type_info _swigt__p_std__allocatorT_Hex__Edge_p_t = {"_p_std__allocatorT_Hex__Edge_p_t", "std::vector< Hex::Edge * >::allocator_type *|std::allocator< Hex::Edge * > *", 0, 0, (void*)0, 0};
35451 static swig_type_info _swigt__p_std__allocatorT_Hex__Hexa_p_t = {"_p_std__allocatorT_Hex__Hexa_p_t", "std::vector< Hex::Hexa * >::allocator_type *|std::allocator< Hex::Hexa * > *", 0, 0, (void*)0, 0};
35452 static swig_type_info _swigt__p_std__allocatorT_Hex__NewShape_p_t = {"_p_std__allocatorT_Hex__NewShape_p_t", "std::vector< Hex::NewShape * >::allocator_type *|std::allocator< Hex::NewShape * > *", 0, 0, (void*)0, 0};
35453 static swig_type_info _swigt__p_std__allocatorT_Hex__Quad_p_t = {"_p_std__allocatorT_Hex__Quad_p_t", "std::vector< Hex::Quad * >::allocator_type *|std::allocator< Hex::Quad * > *", 0, 0, (void*)0, 0};
35454 static swig_type_info _swigt__p_std__allocatorT_Hex__Vertex_p_t = {"_p_std__allocatorT_Hex__Vertex_p_t", "std::vector< Hex::Vertex * >::allocator_type *|std::allocator< Hex::Vertex * > *", 0, 0, (void*)0, 0};
35455 static swig_type_info _swigt__p_std__allocatorT_double_t = {"_p_std__allocatorT_double_t", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
35456 static swig_type_info _swigt__p_std__allocatorT_int_t = {"_p_std__allocatorT_int_t", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0};
35457 static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
35458 static swig_type_info _swigt__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t = {"_p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t", "std::vector< Hex::AssoEdge *,std::allocator< Hex::AssoEdge * > > *|Hex::AssoEdges *", 0, 0, (void*)0, 0};
35459 static swig_type_info _swigt__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t = {"_p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t", "Hex::EdgeShapes *|std::vector< Hex::EdgeShape *,std::allocator< Hex::EdgeShape * > > *", 0, 0, (void*)0, 0};
35460 static swig_type_info _swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t = {"_p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t", "std::vector< Hex::Edge *,std::allocator< Hex::Edge * > > *|std::vector< Hex::Edge * > *|Hex::Edges *", 0, 0, (void*)0, 0};
35461 static swig_type_info _swigt__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t = {"_p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t", "std::vector< Hex::EltBase *,std::allocator< Hex::EltBase * > > *|Hex::TabElts *", 0, 0, (void*)0, 0};
35462 static swig_type_info _swigt__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t = {"_p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t", "Hex::FaceShapes *|std::vector< Hex::FaceShape *,std::allocator< Hex::FaceShape * > > *", 0, 0, (void*)0, 0};
35463 static swig_type_info _swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t = {"_p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t", "Hex::Hexas *|std::vector< Hex::Hexa *,std::allocator< Hex::Hexa * > > *|std::vector< Hex::Hexa * > *", 0, 0, (void*)0, 0};
35464 static swig_type_info _swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t = {"_p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t", "Hex::NewShapes *|std::vector< Hex::NewShape *,std::allocator< Hex::NewShape * > > *|std::vector< Hex::NewShape * > *", 0, 0, (void*)0, 0};
35465 static swig_type_info _swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t = {"_p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t", "std::vector< Hex::Quad *,std::allocator< Hex::Quad * > > *|std::vector< Hex::Quad * > *|Hex::Quads *", 0, 0, (void*)0, 0};
35466 static swig_type_info _swigt__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t = {"_p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t", "Hex::Shapes *|std::vector< Hex::Shape *,std::allocator< Hex::Shape * > > *", 0, 0, (void*)0, 0};
35467 static swig_type_info _swigt__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t = {"_p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t", "Hex::SubShapes *|std::vector< Hex::SubShape *,std::allocator< Hex::SubShape * > > *", 0, 0, (void*)0, 0};
35468 static swig_type_info _swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t = {"_p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t", "std::vector< Hex::Vertex *,std::allocator< Hex::Vertex * > > *|std::vector< Hex::Vertex * > *|Hex::Vertices *", 0, 0, (void*)0, 0};
35469 static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|Hex::RealVector *|std::vector< double > *", 0, 0, (void*)0, 0};
35470 static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|Hex::IntVector *|std::vector< int > *", 0, 0, (void*)0, 0};
35471 static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "Hex::TabText *|std::vector< std::string,std::allocator< std::string > > *", 0, 0, (void*)0, 0};
35472 static swig_type_info _swigt__p_string = {"_p_string", "string *", 0, 0, (void*)0, 0};
35473 static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
35474 static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
35475
35476 static swig_type_info *swig_type_initial[] = {
35477   &_swigt__p_FILE,
35478   &_swigt__p_Hex__BiCylinder,
35479   &_swigt__p_Hex__Document,
35480   &_swigt__p_Hex__Edge,
35481   &_swigt__p_Hex__Elements,
35482   &_swigt__p_Hex__EltBase,
35483   &_swigt__p_Hex__Group,
35484   &_swigt__p_Hex__Hex,
35485   &_swigt__p_Hex__Hex__Elements,
35486   &_swigt__p_Hex__Hex__EltBase,
35487   &_swigt__p_Hex__Hexa,
35488   &_swigt__p_Hex__Law,
35489   &_swigt__p_Hex__NewShape,
35490   &_swigt__p_Hex__Propagation,
35491   &_swigt__p_Hex__Quad,
35492   &_swigt__p_Hex__Shape,
35493   &_swigt__p_Hex__Vector,
35494   &_swigt__p_Hex__Vertex,
35495   &_swigt__p_Hex__XmlWriter,
35496   &_swigt__p_a_Hex__DIM3__double,
35497   &_swigt__p_allocator_type,
35498   &_swigt__p_char,
35499   &_swigt__p_const_reference,
35500   &_swigt__p_difference_type,
35501   &_swigt__p_double,
35502   &_swigt__p_int,
35503   &_swigt__p_p_PyObject,
35504   &_swigt__p_reference,
35505   &_swigt__p_size_type,
35506   &_swigt__p_std__allocatorT_Hex__Edge_p_t,
35507   &_swigt__p_std__allocatorT_Hex__Hexa_p_t,
35508   &_swigt__p_std__allocatorT_Hex__NewShape_p_t,
35509   &_swigt__p_std__allocatorT_Hex__Quad_p_t,
35510   &_swigt__p_std__allocatorT_Hex__Vertex_p_t,
35511   &_swigt__p_std__allocatorT_double_t,
35512   &_swigt__p_std__allocatorT_int_t,
35513   &_swigt__p_std__invalid_argument,
35514   &_swigt__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t,
35515   &_swigt__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t,
35516   &_swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t,
35517   &_swigt__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t,
35518   &_swigt__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t,
35519   &_swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t,
35520   &_swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t,
35521   &_swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t,
35522   &_swigt__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t,
35523   &_swigt__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t,
35524   &_swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t,
35525   &_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
35526   &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
35527   &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
35528   &_swigt__p_string,
35529   &_swigt__p_swig__SwigPyIterator,
35530   &_swigt__p_value_type,
35531 };
35532
35533 static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
35534 static swig_cast_info _swigc__p_Hex__BiCylinder[] = {  {&_swigt__p_Hex__BiCylinder, 0, 0, 0},{0, 0, 0, 0}};
35535 static swig_cast_info _swigc__p_Hex__Document[] = {  {&_swigt__p_Hex__Document, 0, 0, 0},{0, 0, 0, 0}};
35536 static swig_cast_info _swigc__p_Hex__Edge[] = {  {&_swigt__p_Hex__Edge, 0, 0, 0},{0, 0, 0, 0}};
35537 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}};
35538 static swig_cast_info _swigc__p_Hex__EltBase[] = {  {&_swigt__p_Hex__EltBase, 0, 0, 0},  {&_swigt__p_Hex__NewShape, _p_Hex__NewShapeTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Vector, _p_Hex__VectorTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Group, _p_Hex__GroupTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Propagation, _p_Hex__PropagationTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Vertex, _p_Hex__VertexTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Elements, _p_Hex__ElementsTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Document, _p_Hex__DocumentTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__BiCylinder, _p_Hex__BiCylinderTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Hexa, _p_Hex__HexaTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Edge, _p_Hex__EdgeTo_p_Hex__EltBase, 0, 0},  {&_swigt__p_Hex__Quad, _p_Hex__QuadTo_p_Hex__EltBase, 0, 0},{0, 0, 0, 0}};
35539 static swig_cast_info _swigc__p_Hex__Group[] = {  {&_swigt__p_Hex__Group, 0, 0, 0},{0, 0, 0, 0}};
35540 static swig_cast_info _swigc__p_Hex__Hex[] = {  {&_swigt__p_Hex__Hex, 0, 0, 0},{0, 0, 0, 0}};
35541 static swig_cast_info _swigc__p_Hex__Hex__Elements[] = {  {&_swigt__p_Hex__Hex__Elements, 0, 0, 0},{0, 0, 0, 0}};
35542 static swig_cast_info _swigc__p_Hex__Hex__EltBase[] = {  {&_swigt__p_Hex__Hex__EltBase, 0, 0, 0},{0, 0, 0, 0}};
35543 static swig_cast_info _swigc__p_Hex__Hexa[] = {  {&_swigt__p_Hex__Hexa, 0, 0, 0},{0, 0, 0, 0}};
35544 static swig_cast_info _swigc__p_Hex__Law[] = {  {&_swigt__p_Hex__Law, 0, 0, 0},{0, 0, 0, 0}};
35545 static swig_cast_info _swigc__p_Hex__NewShape[] = {  {&_swigt__p_Hex__NewShape, 0, 0, 0},{0, 0, 0, 0}};
35546 static swig_cast_info _swigc__p_Hex__Propagation[] = {  {&_swigt__p_Hex__Propagation, 0, 0, 0},{0, 0, 0, 0}};
35547 static swig_cast_info _swigc__p_Hex__Quad[] = {  {&_swigt__p_Hex__Quad, 0, 0, 0},{0, 0, 0, 0}};
35548 static swig_cast_info _swigc__p_Hex__Shape[] = {  {&_swigt__p_Hex__Shape, 0, 0, 0},{0, 0, 0, 0}};
35549 static swig_cast_info _swigc__p_Hex__Vector[] = {  {&_swigt__p_Hex__Vector, 0, 0, 0},{0, 0, 0, 0}};
35550 static swig_cast_info _swigc__p_Hex__Vertex[] = {  {&_swigt__p_Hex__Vertex, 0, 0, 0},{0, 0, 0, 0}};
35551 static swig_cast_info _swigc__p_Hex__XmlWriter[] = {  {&_swigt__p_Hex__XmlWriter, 0, 0, 0},{0, 0, 0, 0}};
35552 static swig_cast_info _swigc__p_a_Hex__DIM3__double[] = {  {&_swigt__p_a_Hex__DIM3__double, 0, 0, 0},{0, 0, 0, 0}};
35553 static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
35554 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
35555 static swig_cast_info _swigc__p_const_reference[] = {  {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
35556 static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
35557 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
35558 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
35559 static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
35560 static swig_cast_info _swigc__p_reference[] = {  {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
35561 static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
35562 static swig_cast_info _swigc__p_std__allocatorT_Hex__Edge_p_t[] = {  {&_swigt__p_std__allocatorT_Hex__Edge_p_t, 0, 0, 0},{0, 0, 0, 0}};
35563 static swig_cast_info _swigc__p_std__allocatorT_Hex__Hexa_p_t[] = {  {&_swigt__p_std__allocatorT_Hex__Hexa_p_t, 0, 0, 0},{0, 0, 0, 0}};
35564 static swig_cast_info _swigc__p_std__allocatorT_Hex__NewShape_p_t[] = {  {&_swigt__p_std__allocatorT_Hex__NewShape_p_t, 0, 0, 0},{0, 0, 0, 0}};
35565 static swig_cast_info _swigc__p_std__allocatorT_Hex__Quad_p_t[] = {  {&_swigt__p_std__allocatorT_Hex__Quad_p_t, 0, 0, 0},{0, 0, 0, 0}};
35566 static swig_cast_info _swigc__p_std__allocatorT_Hex__Vertex_p_t[] = {  {&_swigt__p_std__allocatorT_Hex__Vertex_p_t, 0, 0, 0},{0, 0, 0, 0}};
35567 static swig_cast_info _swigc__p_std__allocatorT_double_t[] = {  {&_swigt__p_std__allocatorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
35568 static swig_cast_info _swigc__p_std__allocatorT_int_t[] = {  {&_swigt__p_std__allocatorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
35569 static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
35570 static swig_cast_info _swigc__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35571 static swig_cast_info _swigc__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35572 static swig_cast_info _swigc__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35573 static swig_cast_info _swigc__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35574 static swig_cast_info _swigc__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35575 static swig_cast_info _swigc__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35576 static swig_cast_info _swigc__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35577 static swig_cast_info _swigc__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35578 static swig_cast_info _swigc__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35579 static swig_cast_info _swigc__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35580 static swig_cast_info _swigc__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t[] = {  {&_swigt__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
35581 static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t[] = {  {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
35582 static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = {  {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
35583 static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
35584 static swig_cast_info _swigc__p_string[] = {  {&_swigt__p_string, 0, 0, 0},{0, 0, 0, 0}};
35585 static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
35586 static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
35587
35588 static swig_cast_info *swig_cast_initial[] = {
35589   _swigc__p_FILE,
35590   _swigc__p_Hex__BiCylinder,
35591   _swigc__p_Hex__Document,
35592   _swigc__p_Hex__Edge,
35593   _swigc__p_Hex__Elements,
35594   _swigc__p_Hex__EltBase,
35595   _swigc__p_Hex__Group,
35596   _swigc__p_Hex__Hex,
35597   _swigc__p_Hex__Hex__Elements,
35598   _swigc__p_Hex__Hex__EltBase,
35599   _swigc__p_Hex__Hexa,
35600   _swigc__p_Hex__Law,
35601   _swigc__p_Hex__NewShape,
35602   _swigc__p_Hex__Propagation,
35603   _swigc__p_Hex__Quad,
35604   _swigc__p_Hex__Shape,
35605   _swigc__p_Hex__Vector,
35606   _swigc__p_Hex__Vertex,
35607   _swigc__p_Hex__XmlWriter,
35608   _swigc__p_a_Hex__DIM3__double,
35609   _swigc__p_allocator_type,
35610   _swigc__p_char,
35611   _swigc__p_const_reference,
35612   _swigc__p_difference_type,
35613   _swigc__p_double,
35614   _swigc__p_int,
35615   _swigc__p_p_PyObject,
35616   _swigc__p_reference,
35617   _swigc__p_size_type,
35618   _swigc__p_std__allocatorT_Hex__Edge_p_t,
35619   _swigc__p_std__allocatorT_Hex__Hexa_p_t,
35620   _swigc__p_std__allocatorT_Hex__NewShape_p_t,
35621   _swigc__p_std__allocatorT_Hex__Quad_p_t,
35622   _swigc__p_std__allocatorT_Hex__Vertex_p_t,
35623   _swigc__p_std__allocatorT_double_t,
35624   _swigc__p_std__allocatorT_int_t,
35625   _swigc__p_std__invalid_argument,
35626   _swigc__p_std__vectorT_Hex__AssoEdge_p_std__allocatorT_Hex__AssoEdge_p_t_t,
35627   _swigc__p_std__vectorT_Hex__EdgeShape_p_std__allocatorT_Hex__EdgeShape_p_t_t,
35628   _swigc__p_std__vectorT_Hex__Edge_p_std__allocatorT_Hex__Edge_p_t_t,
35629   _swigc__p_std__vectorT_Hex__EltBase_p_std__allocatorT_Hex__EltBase_p_t_t,
35630   _swigc__p_std__vectorT_Hex__FaceShape_p_std__allocatorT_Hex__FaceShape_p_t_t,
35631   _swigc__p_std__vectorT_Hex__Hexa_p_std__allocatorT_Hex__Hexa_p_t_t,
35632   _swigc__p_std__vectorT_Hex__NewShape_p_std__allocatorT_Hex__NewShape_p_t_t,
35633   _swigc__p_std__vectorT_Hex__Quad_p_std__allocatorT_Hex__Quad_p_t_t,
35634   _swigc__p_std__vectorT_Hex__Shape_p_std__allocatorT_Hex__Shape_p_t_t,
35635   _swigc__p_std__vectorT_Hex__SubShape_p_std__allocatorT_Hex__SubShape_p_t_t,
35636   _swigc__p_std__vectorT_Hex__Vertex_p_std__allocatorT_Hex__Vertex_p_t_t,
35637   _swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
35638   _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
35639   _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
35640   _swigc__p_string,
35641   _swigc__p_swig__SwigPyIterator,
35642   _swigc__p_value_type,
35643 };
35644
35645
35646 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
35647
35648 static swig_const_info swig_const_table[] = {
35649 {0, 0, 0, 0.0, 0, 0}};
35650
35651 #ifdef __cplusplus
35652 }
35653 #endif
35654 /* -----------------------------------------------------------------------------
35655  * Type initialization:
35656  * This problem is tough by the requirement that no dynamic
35657  * memory is used. Also, since swig_type_info structures store pointers to
35658  * swig_cast_info structures and swig_cast_info structures store pointers back
35659  * to swig_type_info structures, we need some lookup code at initialization.
35660  * The idea is that swig generates all the structures that are needed.
35661  * The runtime then collects these partially filled structures.
35662  * The SWIG_InitializeModule function takes these initial arrays out of
35663  * swig_module, and does all the lookup, filling in the swig_module.types
35664  * array with the correct data and linking the correct swig_cast_info
35665  * structures together.
35666  *
35667  * The generated swig_type_info structures are assigned statically to an initial
35668  * array. We just loop through that array, and handle each type individually.
35669  * First we lookup if this type has been already loaded, and if so, use the
35670  * loaded structure instead of the generated one. Then we have to fill in the
35671  * cast linked list. The cast data is initially stored in something like a
35672  * two-dimensional array. Each row corresponds to a type (there are the same
35673  * number of rows as there are in the swig_type_initial array). Each entry in
35674  * a column is one of the swig_cast_info structures for that type.
35675  * The cast_initial array is actually an array of arrays, because each row has
35676  * a variable number of columns. So to actually build the cast linked list,
35677  * we find the array of casts associated with the type, and loop through it
35678  * adding the casts to the list. The one last trick we need to do is making
35679  * sure the type pointer in the swig_cast_info struct is correct.
35680  *
35681  * First off, we lookup the cast->type name to see if it is already loaded.
35682  * There are three cases to handle:
35683  *  1) If the cast->type has already been loaded AND the type we are adding
35684  *     casting info to has not been loaded (it is in this module), THEN we
35685  *     replace the cast->type pointer with the type pointer that has already
35686  *     been loaded.
35687  *  2) If BOTH types (the one we are adding casting info to, and the
35688  *     cast->type) are loaded, THEN the cast info has already been loaded by
35689  *     the previous module so we just ignore it.
35690  *  3) Finally, if cast->type has not already been loaded, then we add that
35691  *     swig_cast_info to the linked list (because the cast->type) pointer will
35692  *     be correct.
35693  * ----------------------------------------------------------------------------- */
35694
35695 #ifdef __cplusplus
35696 extern "C" {
35697 #if 0
35698 } /* c-mode */
35699 #endif
35700 #endif
35701
35702 #if 0
35703 #define SWIGRUNTIME_DEBUG
35704 #endif
35705
35706
35707 SWIGRUNTIME void
35708 SWIG_InitializeModule(void *clientdata) {
35709   size_t i;
35710   swig_module_info *module_head, *iter;
35711   int init;
35712
35713   /* check to see if the circular list has been setup, if not, set it up */
35714   if (swig_module.next==0) {
35715     /* Initialize the swig_module */
35716     swig_module.type_initial = swig_type_initial;
35717     swig_module.cast_initial = swig_cast_initial;
35718     swig_module.next = &swig_module;
35719     init = 1;
35720   } else {
35721     init = 0;
35722   }
35723
35724   /* Try and load any already created modules */
35725   module_head = SWIG_GetModule(clientdata);
35726   if (!module_head) {
35727     /* This is the first module loaded for this interpreter */
35728     /* so set the swig module into the interpreter */
35729     SWIG_SetModule(clientdata, &swig_module);
35730   } else {
35731     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
35732     iter=module_head;
35733     do {
35734       if (iter==&swig_module) {
35735         /* Our module is already in the list, so there's nothing more to do. */
35736         return;
35737       }
35738       iter=iter->next;
35739     } while (iter!= module_head);
35740
35741     /* otherwise we must add our module into the list */
35742     swig_module.next = module_head->next;
35743     module_head->next = &swig_module;
35744   }
35745
35746   /* When multiple interpreters are used, a module could have already been initialized in
35747        a different interpreter, but not yet have a pointer in this interpreter.
35748        In this case, we do not want to continue adding types... everything should be
35749        set up already */
35750   if (init == 0) return;
35751
35752   /* Now work on filling in swig_module.types */
35753 #ifdef SWIGRUNTIME_DEBUG
35754   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
35755 #endif
35756   for (i = 0; i < swig_module.size; ++i) {
35757     swig_type_info *type = 0;
35758     swig_type_info *ret;
35759     swig_cast_info *cast;
35760
35761 #ifdef SWIGRUNTIME_DEBUG
35762     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
35763 #endif
35764
35765     /* if there is another module already loaded */
35766     if (swig_module.next != &swig_module) {
35767       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
35768     }
35769     if (type) {
35770       /* Overwrite clientdata field */
35771 #ifdef SWIGRUNTIME_DEBUG
35772       printf("SWIG_InitializeModule: found type %s\n", type->name);
35773 #endif
35774       if (swig_module.type_initial[i]->clientdata) {
35775         type->clientdata = swig_module.type_initial[i]->clientdata;
35776 #ifdef SWIGRUNTIME_DEBUG
35777         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
35778 #endif
35779       }
35780     } else {
35781       type = swig_module.type_initial[i];
35782     }
35783
35784     /* Insert casting types */
35785     cast = swig_module.cast_initial[i];
35786     while (cast->type) {
35787       /* Don't need to add information already in the list */
35788       ret = 0;
35789 #ifdef SWIGRUNTIME_DEBUG
35790       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
35791 #endif
35792       if (swig_module.next != &swig_module) {
35793         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
35794 #ifdef SWIGRUNTIME_DEBUG
35795         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
35796 #endif
35797       }
35798       if (ret) {
35799         if (type == swig_module.type_initial[i]) {
35800 #ifdef SWIGRUNTIME_DEBUG
35801           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
35802 #endif
35803           cast->type = ret;
35804           ret = 0;
35805         } else {
35806           /* Check for casting already in the list */
35807           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
35808 #ifdef SWIGRUNTIME_DEBUG
35809           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
35810 #endif
35811           if (!ocast) ret = 0;
35812         }
35813       }
35814
35815       if (!ret) {
35816 #ifdef SWIGRUNTIME_DEBUG
35817         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
35818 #endif
35819         if (type->cast) {
35820           type->cast->prev = cast;
35821           cast->next = type->cast;
35822         }
35823         type->cast = cast;
35824       }
35825       cast++;
35826     }
35827     /* Set entry in modules->types array equal to the type */
35828     swig_module.types[i] = type;
35829   }
35830   swig_module.types[i] = 0;
35831
35832 #ifdef SWIGRUNTIME_DEBUG
35833   printf("**** SWIG_InitializeModule: Cast List ******\n");
35834   for (i = 0; i < swig_module.size; ++i) {
35835     int j = 0;
35836     swig_cast_info *cast = swig_module.cast_initial[i];
35837     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
35838     while (cast->type) {
35839       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
35840       cast++;
35841       ++j;
35842     }
35843     printf("---- Total casts: %d\n",j);
35844   }
35845   printf("**** SWIG_InitializeModule: Cast List ******\n");
35846 #endif
35847 }
35848
35849 /* This function will propagate the clientdata field of type to
35850 * any new swig_type_info structures that have been added into the list
35851 * of equivalent types.  It is like calling
35852 * SWIG_TypeClientData(type, clientdata) a second time.
35853 */
35854 SWIGRUNTIME void
35855 SWIG_PropagateClientData(void) {
35856   size_t i;
35857   swig_cast_info *equiv;
35858   static int init_run = 0;
35859
35860   if (init_run) return;
35861   init_run = 1;
35862
35863   for (i = 0; i < swig_module.size; i++) {
35864     if (swig_module.types[i]->clientdata) {
35865       equiv = swig_module.types[i]->cast;
35866       while (equiv) {
35867         if (!equiv->converter) {
35868           if (equiv->type && !equiv->type->clientdata)
35869           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
35870         }
35871         equiv = equiv->next;
35872       }
35873     }
35874   }
35875 }
35876
35877 #ifdef __cplusplus
35878 #if 0
35879 {
35880   /* c-mode */
35881 #endif
35882 }
35883 #endif
35884
35885
35886
35887 #ifdef __cplusplus
35888 extern "C" {
35889 #endif
35890
35891   /* Python-specific SWIG API */
35892 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
35893 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
35894 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
35895
35896   /* -----------------------------------------------------------------------------
35897    * global variable support code.
35898    * ----------------------------------------------------------------------------- */
35899
35900   typedef struct swig_globalvar {
35901     char       *name;                  /* Name of global variable */
35902     PyObject *(*get_attr)(void);       /* Return the current value */
35903     int       (*set_attr)(PyObject *); /* Set the value */
35904     struct swig_globalvar *next;
35905   } swig_globalvar;
35906
35907   typedef struct swig_varlinkobject {
35908     PyObject_HEAD
35909     swig_globalvar *vars;
35910   } swig_varlinkobject;
35911
35912   SWIGINTERN PyObject *
35913   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
35914 #if PY_VERSION_HEX >= 0x03000000
35915     return PyUnicode_InternFromString("<Swig global variables>");
35916 #else
35917     return PyString_FromString("<Swig global variables>");
35918 #endif
35919   }
35920
35921   SWIGINTERN PyObject *
35922   swig_varlink_str(swig_varlinkobject *v) {
35923 #if PY_VERSION_HEX >= 0x03000000
35924     PyObject *str = PyUnicode_InternFromString("(");
35925     PyObject *tail;
35926     PyObject *joined;
35927     swig_globalvar *var;
35928     for (var = v->vars; var; var=var->next) {
35929       tail = PyUnicode_FromString(var->name);
35930       joined = PyUnicode_Concat(str, tail);
35931       Py_DecRef(str);
35932       Py_DecRef(tail);
35933       str = joined;
35934       if (var->next) {
35935         tail = PyUnicode_InternFromString(", ");
35936         joined = PyUnicode_Concat(str, tail);
35937         Py_DecRef(str);
35938         Py_DecRef(tail);
35939         str = joined;
35940       }
35941     }
35942     tail = PyUnicode_InternFromString(")");
35943     joined = PyUnicode_Concat(str, tail);
35944     Py_DecRef(str);
35945     Py_DecRef(tail);
35946     str = joined;
35947 #else
35948     PyObject *str = PyString_FromString("(");
35949     swig_globalvar *var;
35950     for (var = v->vars; var; var=var->next) {
35951       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
35952       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
35953     }
35954     PyString_ConcatAndDel(&str,PyString_FromString(")"));
35955 #endif
35956     return str;
35957   }
35958
35959   SWIGINTERN int
35960   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
35961     char *tmp;
35962     PyObject *str = swig_varlink_str(v);
35963     fprintf(fp,"Swig global variables ");
35964     fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
35965     SWIG_Python_str_DelForPy3(tmp);
35966     Py_DECREF(str);
35967     return 0;
35968   }
35969
35970   SWIGINTERN void
35971   swig_varlink_dealloc(swig_varlinkobject *v) {
35972     swig_globalvar *var = v->vars;
35973     while (var) {
35974       swig_globalvar *n = var->next;
35975       free(var->name);
35976       free(var);
35977       var = n;
35978     }
35979   }
35980
35981   SWIGINTERN PyObject *
35982   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
35983     PyObject *res = NULL;
35984     swig_globalvar *var = v->vars;
35985     while (var) {
35986       if (strcmp(var->name,n) == 0) {
35987         res = (*var->get_attr)();
35988         break;
35989       }
35990       var = var->next;
35991     }
35992     if (res == NULL && !PyErr_Occurred()) {
35993       PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
35994     }
35995     return res;
35996   }
35997
35998   SWIGINTERN int
35999   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
36000     int res = 1;
36001     swig_globalvar *var = v->vars;
36002     while (var) {
36003       if (strcmp(var->name,n) == 0) {
36004         res = (*var->set_attr)(p);
36005         break;
36006       }
36007       var = var->next;
36008     }
36009     if (res == 1 && !PyErr_Occurred()) {
36010       PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
36011     }
36012     return res;
36013   }
36014
36015   SWIGINTERN PyTypeObject*
36016   swig_varlink_type(void) {
36017     static char varlink__doc__[] = "Swig var link object";
36018     static PyTypeObject varlink_type;
36019     static int type_init = 0;
36020     if (!type_init) {
36021       const PyTypeObject tmp = {
36022 #if PY_VERSION_HEX >= 0x03000000
36023         PyVarObject_HEAD_INIT(NULL, 0)
36024 #else
36025         PyObject_HEAD_INIT(NULL)
36026         0,                                  /* ob_size */
36027 #endif
36028         (char *)"swigvarlink",              /* tp_name */
36029         sizeof(swig_varlinkobject),         /* tp_basicsize */
36030         0,                                  /* tp_itemsize */
36031         (destructor) swig_varlink_dealloc,  /* tp_dealloc */
36032         (printfunc) swig_varlink_print,     /* tp_print */
36033         (getattrfunc) swig_varlink_getattr, /* tp_getattr */
36034         (setattrfunc) swig_varlink_setattr, /* tp_setattr */
36035         0,                                  /* tp_compare */
36036         (reprfunc) swig_varlink_repr,       /* tp_repr */
36037         0,                                  /* tp_as_number */
36038         0,                                  /* tp_as_sequence */
36039         0,                                  /* tp_as_mapping */
36040         0,                                  /* tp_hash */
36041         0,                                  /* tp_call */
36042         (reprfunc) swig_varlink_str,        /* tp_str */
36043         0,                                  /* tp_getattro */
36044         0,                                  /* tp_setattro */
36045         0,                                  /* tp_as_buffer */
36046         0,                                  /* tp_flags */
36047         varlink__doc__,                     /* tp_doc */
36048         0,                                  /* tp_traverse */
36049         0,                                  /* tp_clear */
36050         0,                                  /* tp_richcompare */
36051         0,                                  /* tp_weaklistoffset */
36052 #if PY_VERSION_HEX >= 0x02020000
36053         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
36054 #endif
36055 #if PY_VERSION_HEX >= 0x02030000
36056         0,                                  /* tp_del */
36057 #endif
36058 #if PY_VERSION_HEX >= 0x02060000
36059         0,                                  /* tp_version_tag */
36060 #endif
36061 #if PY_VERSION_HEX >= 0x03040000
36062         0,                                  /* tp_finalize */
36063 #endif
36064 #ifdef COUNT_ALLOCS
36065         0,                                  /* tp_allocs */
36066         0,                                  /* tp_frees */
36067         0,                                  /* tp_maxalloc */
36068 #if PY_VERSION_HEX >= 0x02050000
36069         0,                                  /* tp_prev */
36070 #endif
36071         0                                   /* tp_next */
36072 #endif
36073       };
36074       varlink_type = tmp;
36075       type_init = 1;
36076 #if PY_VERSION_HEX < 0x02020000
36077       varlink_type.ob_type = &PyType_Type;
36078 #else
36079       if (PyType_Ready(&varlink_type) < 0)
36080       return NULL;
36081 #endif
36082     }
36083     return &varlink_type;
36084   }
36085
36086   /* Create a variable linking object for use later */
36087   SWIGINTERN PyObject *
36088   SWIG_Python_newvarlink(void) {
36089     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
36090     if (result) {
36091       result->vars = 0;
36092     }
36093     return ((PyObject*) result);
36094   }
36095
36096   SWIGINTERN void
36097   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
36098     swig_varlinkobject *v = (swig_varlinkobject *) p;
36099     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
36100     if (gv) {
36101       size_t size = strlen(name)+1;
36102       gv->name = (char *)malloc(size);
36103       if (gv->name) {
36104         strncpy(gv->name,name,size);
36105         gv->get_attr = get_attr;
36106         gv->set_attr = set_attr;
36107         gv->next = v->vars;
36108       }
36109     }
36110     v->vars = gv;
36111   }
36112
36113   SWIGINTERN PyObject *
36114   SWIG_globals(void) {
36115     static PyObject *_SWIG_globals = 0;
36116     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
36117     return _SWIG_globals;
36118   }
36119
36120   /* -----------------------------------------------------------------------------
36121    * constants/methods manipulation
36122    * ----------------------------------------------------------------------------- */
36123
36124   /* Install Constants */
36125   SWIGINTERN void
36126   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
36127     PyObject *obj = 0;
36128     size_t i;
36129     for (i = 0; constants[i].type; ++i) {
36130       switch(constants[i].type) {
36131       case SWIG_PY_POINTER:
36132         obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
36133         break;
36134       case SWIG_PY_BINARY:
36135         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
36136         break;
36137       default:
36138         obj = 0;
36139         break;
36140       }
36141       if (obj) {
36142         PyDict_SetItemString(d, constants[i].name, obj);
36143         Py_DECREF(obj);
36144       }
36145     }
36146   }
36147
36148   /* -----------------------------------------------------------------------------*/
36149   /* Fix SwigMethods to carry the callback ptrs when needed */
36150   /* -----------------------------------------------------------------------------*/
36151
36152   SWIGINTERN void
36153   SWIG_Python_FixMethods(PyMethodDef *methods,
36154     swig_const_info *const_table,
36155     swig_type_info **types,
36156     swig_type_info **types_initial) {
36157     size_t i;
36158     for (i = 0; methods[i].ml_name; ++i) {
36159       const char *c = methods[i].ml_doc;
36160       if (!c) continue;
36161       c = strstr(c, "swig_ptr: ");
36162       if (c) {
36163         int j;
36164         swig_const_info *ci = 0;
36165         const char *name = c + 10;
36166         for (j = 0; const_table[j].type; ++j) {
36167           if (strncmp(const_table[j].name, name,
36168               strlen(const_table[j].name)) == 0) {
36169             ci = &(const_table[j]);
36170             break;
36171           }
36172         }
36173         if (ci) {
36174           void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
36175           if (ptr) {
36176             size_t shift = (ci->ptype) - types;
36177             swig_type_info *ty = types_initial[shift];
36178             size_t ldoc = (c - methods[i].ml_doc);
36179             size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
36180             char *ndoc = (char*)malloc(ldoc + lptr + 10);
36181             if (ndoc) {
36182               char *buff = ndoc;
36183               strncpy(buff, methods[i].ml_doc, ldoc);
36184               buff += ldoc;
36185               strncpy(buff, "swig_ptr: ", 10);
36186               buff += 10;
36187               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
36188               methods[i].ml_doc = ndoc;
36189             }
36190           }
36191         }
36192       }
36193     }
36194   }
36195
36196 #ifdef __cplusplus
36197 }
36198 #endif
36199
36200 /* -----------------------------------------------------------------------------*
36201  *  Partial Init method
36202  * -----------------------------------------------------------------------------*/
36203
36204 #ifdef __cplusplus
36205 extern "C"
36206 #endif
36207
36208 SWIGEXPORT
36209 #if PY_VERSION_HEX >= 0x03000000
36210 PyObject*
36211 #else
36212 void
36213 #endif
36214 SWIG_init(void) {
36215   PyObject *m, *d, *md;
36216 #if PY_VERSION_HEX >= 0x03000000
36217   static struct PyModuleDef SWIG_module = {
36218 # if PY_VERSION_HEX >= 0x03020000
36219     PyModuleDef_HEAD_INIT,
36220 # else
36221     {
36222       PyObject_HEAD_INIT(NULL)
36223       NULL, /* m_init */
36224       0,    /* m_index */
36225       NULL, /* m_copy */
36226     },
36227 # endif
36228     (char *) SWIG_name,
36229     NULL,
36230     -1,
36231     SwigMethods,
36232     NULL,
36233     NULL,
36234     NULL,
36235     NULL
36236   };
36237 #endif
36238
36239 #if defined(SWIGPYTHON_BUILTIN)
36240   static SwigPyClientData SwigPyObject_clientdata = {
36241     0, 0, 0, 0, 0, 0, 0
36242   };
36243   static PyGetSetDef this_getset_def = {
36244     (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
36245   };
36246   static SwigPyGetSet thisown_getset_closure = {
36247     (PyCFunction) SwigPyObject_own,
36248     (PyCFunction) SwigPyObject_own
36249   };
36250   static PyGetSetDef thisown_getset_def = {
36251     (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
36252   };
36253   PyTypeObject *builtin_pytype;
36254   int builtin_base_count;
36255   swig_type_info *builtin_basetype;
36256   PyObject *tuple;
36257   PyGetSetDescrObject *static_getset;
36258   PyTypeObject *metatype;
36259   PyTypeObject *swigpyobject;
36260   SwigPyClientData *cd;
36261   PyObject *public_interface, *public_symbol;
36262   PyObject *this_descr;
36263   PyObject *thisown_descr;
36264   PyObject *self = 0;
36265   int i;
36266
36267   (void)builtin_pytype;
36268   (void)builtin_base_count;
36269   (void)builtin_basetype;
36270   (void)tuple;
36271   (void)static_getset;
36272   (void)self;
36273
36274   /* Metaclass is used to implement static member variables */
36275   metatype = SwigPyObjectType();
36276   assert(metatype);
36277 #endif
36278
36279   /* Fix SwigMethods to carry the callback ptrs when needed */
36280   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
36281
36282 #if PY_VERSION_HEX >= 0x03000000
36283   m = PyModule_Create(&SWIG_module);
36284 #else
36285   m = Py_InitModule((char *) SWIG_name, SwigMethods);
36286 #endif
36287
36288   md = d = PyModule_GetDict(m);
36289   (void)md;
36290
36291   SWIG_InitializeModule(0);
36292
36293 #ifdef SWIGPYTHON_BUILTIN
36294   swigpyobject = SwigPyObject_TypeOnce();
36295
36296   SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
36297   assert(SwigPyObject_stype);
36298   cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
36299   if (!cd) {
36300     SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
36301     SwigPyObject_clientdata.pytype = swigpyobject;
36302   } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
36303     PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
36304 # if PY_VERSION_HEX >= 0x03000000
36305     return NULL;
36306 # else
36307     return;
36308 # endif
36309   }
36310
36311   /* All objects have a 'this' attribute */
36312   this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
36313   (void)this_descr;
36314
36315   /* All objects have a 'thisown' attribute */
36316   thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
36317   (void)thisown_descr;
36318
36319   public_interface = PyList_New(0);
36320   public_symbol = 0;
36321   (void)public_symbol;
36322
36323   PyDict_SetItemString(md, "__all__", public_interface);
36324   Py_DECREF(public_interface);
36325   for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
36326   SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
36327   for (i = 0; swig_const_table[i].name != 0; ++i)
36328   SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
36329 #endif
36330
36331   SWIG_InstallConstants(d,swig_const_table);
36332
36333   SWIG_Python_SetConstant(d, "DumpActif",SWIG_From_bool(static_cast< bool >(true)));
36334   SWIG_Python_SetConstant(d, "HOK",SWIG_From_int(static_cast< int >(0)));
36335   SWIG_Python_SetConstant(d, "HERR",SWIG_From_int(static_cast< int >(1)));
36336   SWIG_Python_SetConstant(d, "NOTHING",SWIG_From_int(static_cast< int >(-1)));
36337   SWIG_Python_SetConstant(d, "EOL",SWIG_From_char(static_cast< char >('\n')));
36338   SWIG_Python_SetConstant(d, "EOS",SWIG_From_int(static_cast< int >(0)));
36339   SWIG_Python_SetConstant(d, "CHVIDE",SWIG_FromCharPtr(""));
36340   SWIG_Python_SetConstant(d, "ZEROR",SWIG_From_double(static_cast< double >(0.0)));
36341   SWIG_Python_SetConstant(d, "UNR",SWIG_From_double(static_cast< double >(1.0)));
36342   SWIG_Python_SetConstant(d, "DEMI",SWIG_From_double(static_cast< double >(0.5)));
36343   SWIG_Python_SetConstant(d, "DIM2",SWIG_From_int(static_cast< int >(2)));
36344   SWIG_Python_SetConstant(d, "M_PI",SWIG_From_double(static_cast< double >(3.14159265358979323846)));
36345   SWIG_Python_SetConstant(d, "Degre2Radian",SWIG_From_double(static_cast< double >(3.14159265358979323846/180)));
36346   SWIG_Python_SetConstant(d, "dir_x",SWIG_From_int(static_cast< int >(Hex::dir_x)));
36347   SWIG_Python_SetConstant(d, "dir_y",SWIG_From_int(static_cast< int >(Hex::dir_y)));
36348   SWIG_Python_SetConstant(d, "dir_z",SWIG_From_int(static_cast< int >(Hex::dir_z)));
36349   SWIG_Python_SetConstant(d, "DIM3",SWIG_From_int(static_cast< int >(Hex::DIM3)));
36350   SWIG_Python_SetConstant(d, "EL_NONE",SWIG_From_int(static_cast< int >(Hex::EL_NONE)));
36351   SWIG_Python_SetConstant(d, "EL_VERTEX",SWIG_From_int(static_cast< int >(Hex::EL_VERTEX)));
36352   SWIG_Python_SetConstant(d, "EL_EDGE",SWIG_From_int(static_cast< int >(Hex::EL_EDGE)));
36353   SWIG_Python_SetConstant(d, "EL_QUAD",SWIG_From_int(static_cast< int >(Hex::EL_QUAD)));
36354   SWIG_Python_SetConstant(d, "EL_HEXA",SWIG_From_int(static_cast< int >(Hex::EL_HEXA)));
36355   SWIG_Python_SetConstant(d, "EL_VECTOR",SWIG_From_int(static_cast< int >(Hex::EL_VECTOR)));
36356   SWIG_Python_SetConstant(d, "EL_GRID",SWIG_From_int(static_cast< int >(Hex::EL_GRID)));
36357   SWIG_Python_SetConstant(d, "EL_CYLINDER",SWIG_From_int(static_cast< int >(Hex::EL_CYLINDER)));
36358   SWIG_Python_SetConstant(d, "EL_PIPE",SWIG_From_int(static_cast< int >(Hex::EL_PIPE)));
36359   SWIG_Python_SetConstant(d, "EL_GROUP",SWIG_From_int(static_cast< int >(Hex::EL_GROUP)));
36360   SWIG_Python_SetConstant(d, "EL_LAW",SWIG_From_int(static_cast< int >(Hex::EL_LAW)));
36361   SWIG_Python_SetConstant(d, "EL_SHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SHAPE)));
36362   SWIG_Python_SetConstant(d, "EL_SUBSHAPE",SWIG_From_int(static_cast< int >(Hex::EL_SUBSHAPE)));
36363   SWIG_Python_SetConstant(d, "EL_PROPAGATION",SWIG_From_int(static_cast< int >(Hex::EL_PROPAGATION)));
36364   SWIG_Python_SetConstant(d, "EL_DOCU",SWIG_From_int(static_cast< int >(Hex::EL_DOCU)));
36365   SWIG_Python_SetConstant(d, "EL_REMOVED",SWIG_From_int(static_cast< int >(Hex::EL_REMOVED)));
36366   SWIG_Python_SetConstant(d, "EL_MAXI",SWIG_From_int(static_cast< int >(Hex::EL_MAXI)));
36367   PyDict_SetItemString(md,(char *)"cvar", SWIG_globals());
36368   SWIG_addvarlink(SWIG_globals(),(char *)"ABR_TYPES",Swig_var_ABR_TYPES_get, Swig_var_ABR_TYPES_set);
36369   SWIG_Python_SetConstant(d, "HexaCell",SWIG_From_int(static_cast< int >(Hex::HexaCell)));
36370   SWIG_Python_SetConstant(d, "QuadCell",SWIG_From_int(static_cast< int >(Hex::QuadCell)));
36371   SWIG_Python_SetConstant(d, "EdgeCell",SWIG_From_int(static_cast< int >(Hex::EdgeCell)));
36372   SWIG_Python_SetConstant(d, "HexaNode",SWIG_From_int(static_cast< int >(Hex::HexaNode)));
36373   SWIG_Python_SetConstant(d, "QuadNode",SWIG_From_int(static_cast< int >(Hex::QuadNode)));
36374   SWIG_Python_SetConstant(d, "EdgeNode",SWIG_From_int(static_cast< int >(Hex::EdgeNode)));
36375   SWIG_Python_SetConstant(d, "VertexNode",SWIG_From_int(static_cast< int >(Hex::VertexNode)));
36376   SWIG_Python_SetConstant(d, "SH_NONE",SWIG_From_int(static_cast< int >(Hex::SH_NONE)));
36377   SWIG_Python_SetConstant(d, "SH_IMPORT",SWIG_From_int(static_cast< int >(Hex::SH_IMPORT)));
36378   SWIG_Python_SetConstant(d, "SH_CYLINDER",SWIG_From_int(static_cast< int >(Hex::SH_CYLINDER)));
36379   SWIG_Python_SetConstant(d, "SH_INTER",SWIG_From_int(static_cast< int >(Hex::SH_INTER)));
36380   SWIG_Python_SetConstant(d, "SH_SPHERE",SWIG_From_int(static_cast< int >(Hex::SH_SPHERE)));
36381   SWIG_Python_SetConstant(d, "SH_CLOUD",SWIG_From_int(static_cast< int >(Hex::SH_CLOUD)));
36382   SWIG_Python_SetConstant(d, "SH_EXTRUD",SWIG_From_int(static_cast< int >(Hex::SH_EXTRUD)));
36383   SWIG_Python_SetConstant(d, "CYL_NOFILL",SWIG_From_int(static_cast< int >(Hex::CYL_NOFILL)));
36384   SWIG_Python_SetConstant(d, "CYL_CL4",SWIG_From_int(static_cast< int >(Hex::CYL_CL4)));
36385   SWIG_Python_SetConstant(d, "CYL_CL6",SWIG_From_int(static_cast< int >(Hex::CYL_CL6)));
36386   SWIG_Python_SetConstant(d, "CYL_CLOSED",SWIG_From_int(static_cast< int >(Hex::CYL_CLOSED)));
36387   SWIG_Python_SetConstant(d, "CYL_PEER",SWIG_From_int(static_cast< int >(Hex::CYL_PEER)));
36388   SWIG_Python_SetConstant(d, "CYL_ODD",SWIG_From_int(static_cast< int >(Hex::CYL_ODD)));
36389   SWIG_Python_SetConstant(d, "GR_NONE",SWIG_From_int(static_cast< int >(Hex::GR_NONE)));
36390   SWIG_Python_SetConstant(d, "GR_CARTESIAN",SWIG_From_int(static_cast< int >(Hex::GR_CARTESIAN)));
36391   SWIG_Python_SetConstant(d, "GR_CYLINDRIC",SWIG_From_int(static_cast< int >(Hex::GR_CYLINDRIC)));
36392   SWIG_Python_SetConstant(d, "GR_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_SPHERIC)));
36393   SWIG_Python_SetConstant(d, "GR_JOINT",SWIG_From_int(static_cast< int >(Hex::GR_JOINT)));
36394   SWIG_Python_SetConstant(d, "GR_BICYL",SWIG_From_int(static_cast< int >(Hex::GR_BICYL)));
36395   SWIG_Python_SetConstant(d, "GR_BIPIPE",SWIG_From_int(static_cast< int >(Hex::GR_BIPIPE)));
36396   SWIG_Python_SetConstant(d, "GR_REPLACE",SWIG_From_int(static_cast< int >(Hex::GR_REPLACE)));
36397   SWIG_Python_SetConstant(d, "GR_HEMISPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_HEMISPHERIC)));
36398   SWIG_Python_SetConstant(d, "GR_RIND",SWIG_From_int(static_cast< int >(Hex::GR_RIND)));
36399   SWIG_Python_SetConstant(d, "GR_PART_SPHERIC",SWIG_From_int(static_cast< int >(Hex::GR_PART_SPHERIC)));
36400   SWIG_Python_SetConstant(d, "GR_PART_RIND",SWIG_From_int(static_cast< int >(Hex::GR_PART_RIND)));
36401   SWIG_Python_SetConstant(d, "S_E",SWIG_From_int(static_cast< int >(Hex::S_E)));
36402   SWIG_Python_SetConstant(d, "S_NE",SWIG_From_int(static_cast< int >(Hex::S_NE)));
36403   SWIG_Python_SetConstant(d, "S_N",SWIG_From_int(static_cast< int >(Hex::S_N)));
36404   SWIG_Python_SetConstant(d, "S_NW",SWIG_From_int(static_cast< int >(Hex::S_NW)));
36405   SWIG_Python_SetConstant(d, "S_W",SWIG_From_int(static_cast< int >(Hex::S_W)));
36406   SWIG_Python_SetConstant(d, "S_SW",SWIG_From_int(static_cast< int >(Hex::S_SW)));
36407   SWIG_Python_SetConstant(d, "S_S",SWIG_From_int(static_cast< int >(Hex::S_S)));
36408   SWIG_Python_SetConstant(d, "S_SE",SWIG_From_int(static_cast< int >(Hex::S_SE)));
36409   SWIG_Python_SetConstant(d, "S_MAXI",SWIG_From_int(static_cast< int >(Hex::S_MAXI)));
36410   SWIG_Python_SetConstant(d, "Uniform",SWIG_From_int(static_cast< int >(Hex::Uniform)));
36411   SWIG_Python_SetConstant(d, "Arithmetic",SWIG_From_int(static_cast< int >(Hex::Arithmetic)));
36412   SWIG_Python_SetConstant(d, "Geometric",SWIG_From_int(static_cast< int >(Hex::Geometric)));
36413   SWIG_Python_SetConstant(d, "OR_FRONT",SWIG_From_int(static_cast< int >(Hex::OR_FRONT)));
36414   SWIG_Python_SetConstant(d, "OR_LEFT",SWIG_From_int(static_cast< int >(Hex::OR_LEFT)));
36415   SWIG_Python_SetConstant(d, "OR_RIGHT",SWIG_From_int(static_cast< int >(Hex::OR_RIGHT)));
36416   SWIG_Python_SetConstant(d, "OR_BACK",SWIG_From_int(static_cast< int >(Hex::OR_BACK)));
36417   SWIG_Python_SetConstant(d, "IS_NONE",SWIG_From_int(static_cast< int >(Hex::IS_NONE)));
36418   SWIG_Python_SetConstant(d, "IS_MARRIED",SWIG_From_int(static_cast< int >(Hex::IS_MARRIED)));
36419   SWIG_Python_SetConstant(d, "NO_COUNTED",SWIG_From_int(static_cast< int >(Hex::NO_COUNTED)));
36420   SWIG_Python_SetConstant(d, "NO_USED",SWIG_From_int(static_cast< int >(Hex::NO_USED)));
36421   SWIG_Python_SetConstant(d, "IS_USED",SWIG_From_int(static_cast< int >(Hex::IS_USED)));
36422   SWIG_Python_SetConstant(d, "V_AMONT",SWIG_From_int(static_cast< int >(Hex::V_AMONT)));
36423   SWIG_Python_SetConstant(d, "V_AVAL",SWIG_From_int(static_cast< int >(Hex::V_AVAL)));
36424   SWIG_Python_SetConstant(d, "V_TWO",SWIG_From_int(static_cast< int >(Hex::V_TWO)));
36425   SWIG_Python_SetConstant(d, "E_A",SWIG_From_int(static_cast< int >(Hex::E_A)));
36426   SWIG_Python_SetConstant(d, "E_B",SWIG_From_int(static_cast< int >(Hex::E_B)));
36427   SWIG_Python_SetConstant(d, "E_C",SWIG_From_int(static_cast< int >(Hex::E_C)));
36428   SWIG_Python_SetConstant(d, "E_D",SWIG_From_int(static_cast< int >(Hex::E_D)));
36429   SWIG_Python_SetConstant(d, "QUAD4",SWIG_From_int(static_cast< int >(Hex::QUAD4)));
36430   SWIG_Python_SetConstant(d, "Q_A",SWIG_From_int(static_cast< int >(Hex::Q_A)));
36431   SWIG_Python_SetConstant(d, "Q_B",SWIG_From_int(static_cast< int >(Hex::Q_B)));
36432   SWIG_Python_SetConstant(d, "Q_C",SWIG_From_int(static_cast< int >(Hex::Q_C)));
36433   SWIG_Python_SetConstant(d, "Q_D",SWIG_From_int(static_cast< int >(Hex::Q_D)));
36434   SWIG_Python_SetConstant(d, "Q_E",SWIG_From_int(static_cast< int >(Hex::Q_E)));
36435   SWIG_Python_SetConstant(d, "Q_F",SWIG_From_int(static_cast< int >(Hex::Q_F)));
36436   SWIG_Python_SetConstant(d, "HQ_MAXI",SWIG_From_int(static_cast< int >(Hex::HQ_MAXI)));
36437   SWIG_Python_SetConstant(d, "E_AC",SWIG_From_int(static_cast< int >(Hex::E_AC)));
36438   SWIG_Python_SetConstant(d, "E_AD",SWIG_From_int(static_cast< int >(Hex::E_AD)));
36439   SWIG_Python_SetConstant(d, "E_BC",SWIG_From_int(static_cast< int >(Hex::E_BC)));
36440   SWIG_Python_SetConstant(d, "E_BD",SWIG_From_int(static_cast< int >(Hex::E_BD)));
36441   SWIG_Python_SetConstant(d, "E_AE",SWIG_From_int(static_cast< int >(Hex::E_AE)));
36442   SWIG_Python_SetConstant(d, "E_AF",SWIG_From_int(static_cast< int >(Hex::E_AF)));
36443   SWIG_Python_SetConstant(d, "E_BE",SWIG_From_int(static_cast< int >(Hex::E_BE)));
36444   SWIG_Python_SetConstant(d, "E_BF",SWIG_From_int(static_cast< int >(Hex::E_BF)));
36445   SWIG_Python_SetConstant(d, "E_CE",SWIG_From_int(static_cast< int >(Hex::E_CE)));
36446   SWIG_Python_SetConstant(d, "E_CF",SWIG_From_int(static_cast< int >(Hex::E_CF)));
36447   SWIG_Python_SetConstant(d, "E_DE",SWIG_From_int(static_cast< int >(Hex::E_DE)));
36448   SWIG_Python_SetConstant(d, "E_DF",SWIG_From_int(static_cast< int >(Hex::E_DF)));
36449   SWIG_Python_SetConstant(d, "HE_MAXI",SWIG_From_int(static_cast< int >(Hex::HE_MAXI)));
36450   SWIG_Python_SetConstant(d, "V_ACE",SWIG_From_int(static_cast< int >(Hex::V_ACE)));
36451   SWIG_Python_SetConstant(d, "V_ACF",SWIG_From_int(static_cast< int >(Hex::V_ACF)));
36452   SWIG_Python_SetConstant(d, "V_ADE",SWIG_From_int(static_cast< int >(Hex::V_ADE)));
36453   SWIG_Python_SetConstant(d, "V_ADF",SWIG_From_int(static_cast< int >(Hex::V_ADF)));
36454   SWIG_Python_SetConstant(d, "V_BCE",SWIG_From_int(static_cast< int >(Hex::V_BCE)));
36455   SWIG_Python_SetConstant(d, "V_BCF",SWIG_From_int(static_cast< int >(Hex::V_BCF)));
36456   SWIG_Python_SetConstant(d, "V_BDE",SWIG_From_int(static_cast< int >(Hex::V_BDE)));
36457   SWIG_Python_SetConstant(d, "V_BDF",SWIG_From_int(static_cast< int >(Hex::V_BDF)));
36458   SWIG_Python_SetConstant(d, "HV_MAXI",SWIG_From_int(static_cast< int >(Hex::HV_MAXI)));
36459   SWIG_Python_SetConstant(d, "Q_INSIDE",SWIG_From_int(static_cast< int >(Hex::Q_INSIDE)));
36460   SWIG_Python_SetConstant(d, "Q_DIRECT",SWIG_From_int(static_cast< int >(Hex::Q_DIRECT)));
36461   SWIG_Python_SetConstant(d, "Q_INVERSE",SWIG_From_int(static_cast< int >(Hex::Q_INVERSE)));
36462   SWIG_Python_SetConstant(d, "Q_UNDEFINED",SWIG_From_int(static_cast< int >(Hex::Q_UNDEFINED)));
36463   SWIG_Python_SetConstant(d, "Q_WAITING",SWIG_From_int(static_cast< int >(Hex::Q_WAITING)));
36464   SWIG_Python_SetConstant(d, "KS_Line",SWIG_From_int(static_cast< int >(Hex::KS_Line)));
36465   SWIG_Python_SetConstant(d, "KS_Circle",SWIG_From_int(static_cast< int >(Hex::KS_Circle)));
36466   SWIG_Python_SetConstant(d, "KS_Ellipse",SWIG_From_int(static_cast< int >(Hex::KS_Ellipse)));
36467   SWIG_Python_SetConstant(d, "KS_Hyperbola",SWIG_From_int(static_cast< int >(Hex::KS_Hyperbola)));
36468   SWIG_Python_SetConstant(d, "KS_Parabola",SWIG_From_int(static_cast< int >(Hex::KS_Parabola)));
36469   SWIG_Python_SetConstant(d, "KS_BezierCurve",SWIG_From_int(static_cast< int >(Hex::KS_BezierCurve)));
36470   SWIG_Python_SetConstant(d, "KS_BSplineCurve",SWIG_From_int(static_cast< int >(Hex::KS_BSplineCurve)));
36471   SWIG_Python_SetConstant(d, "KS_OtherCurve",SWIG_From_int(static_cast< int >(Hex::KS_OtherCurve)));
36472   SWIG_Python_SetConstant(d, "KS_None",SWIG_From_int(static_cast< int >(Hex::KS_None)));
36473   SWIG_Python_SetConstant(d, "CylSmall",SWIG_From_int(static_cast< int >(Hex::CylSmall)));
36474   SWIG_Python_SetConstant(d, "CylBig",SWIG_From_int(static_cast< int >(Hex::CylBig)));
36475   SWIG_Python_SetConstant(d, "NxInt",SWIG_From_int(static_cast< int >(Hex::NxInt)));
36476   SWIG_Python_SetConstant(d, "NxExt",SWIG_From_int(static_cast< int >(Hex::NxExt)));
36477   SWIG_addvarlink(SWIG_globals(),(char *)"Epsil",Swig_var_Epsil_get, Swig_var_Epsil_set);
36478   SWIG_addvarlink(SWIG_globals(),(char *)"UnEpsil",Swig_var_UnEpsil_get, Swig_var_UnEpsil_set);
36479   SWIG_addvarlink(SWIG_globals(),(char *)"Epsil2",Swig_var_Epsil2_get, Swig_var_Epsil2_set);
36480 #if PY_VERSION_HEX >= 0x03000000
36481   return m;
36482 #else
36483   return;
36484 #endif
36485 }
36486