LCOV - code coverage report
Current view: top level - build directory/src/bindings/swig/python2 - kdbPYTHON_wrap.cxx (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 1580 4016 39.3 %
Date: 2019-09-12 12:28:41 Functions: 148 322 46.0 %

          Line data    Source code
       1             : /* ----------------------------------------------------------------------------
       2             :  * This file was automatically generated by SWIG (http://www.swig.org).
       3             :  * Version 3.0.10
       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_NO_BUILD_NONE
      17             : #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
      18             : #define SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
      19             : 
      20             : 
      21             : #ifdef __cplusplus
      22             : /* SwigValueWrapper is described in swig.swg */
      23             : template<typename T> class SwigValueWrapper {
      24             :   struct SwigMovePointer {
      25             :     T *ptr;
      26             :     SwigMovePointer(T *p) : ptr(p) { }
      27             :     ~SwigMovePointer() { delete ptr; }
      28             :     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
      29             :   } pointer;
      30             :   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
      31             :   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
      32             : public:
      33             :   SwigValueWrapper() : pointer(0) { }
      34             :   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
      35             :   operator T&() const { return *pointer.ptr; }
      36             :   T *operator&() { return pointer.ptr; }
      37             : };
      38             : 
      39             : template <typename T> T SwigValueInit() {
      40             :   return T();
      41             : }
      42             : #endif
      43             : 
      44             : /* -----------------------------------------------------------------------------
      45             :  *  This section contains generic SWIG labels for method/variable
      46             :  *  declarations/attributes, and other compiler dependent labels.
      47             :  * ----------------------------------------------------------------------------- */
      48             : 
      49             : /* template workaround for compilers that cannot correctly implement the C++ standard */
      50             : #ifndef SWIGTEMPLATEDISAMBIGUATOR
      51             : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
      52             : #  define SWIGTEMPLATEDISAMBIGUATOR template
      53             : # elif defined(__HP_aCC)
      54             : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
      55             : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
      56             : #  define SWIGTEMPLATEDISAMBIGUATOR template
      57             : # else
      58             : #  define SWIGTEMPLATEDISAMBIGUATOR
      59             : # endif
      60             : #endif
      61             : 
      62             : /* inline attribute */
      63             : #ifndef SWIGINLINE
      64             : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
      65             : #   define SWIGINLINE inline
      66             : # else
      67             : #   define SWIGINLINE
      68             : # endif
      69             : #endif
      70             : 
      71             : /* attribute recognised by some compilers to avoid 'unused' warnings */
      72             : #ifndef SWIGUNUSED
      73             : # if defined(__GNUC__)
      74             : #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
      75             : #     define SWIGUNUSED __attribute__ ((__unused__))
      76             : #   else
      77             : #     define SWIGUNUSED
      78             : #   endif
      79             : # elif defined(__ICC)
      80             : #   define SWIGUNUSED __attribute__ ((__unused__))
      81             : # else
      82             : #   define SWIGUNUSED
      83             : # endif
      84             : #endif
      85             : 
      86             : #ifndef SWIG_MSC_UNSUPPRESS_4505
      87             : # if defined(_MSC_VER)
      88             : #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
      89             : # endif
      90             : #endif
      91             : 
      92             : #ifndef SWIGUNUSEDPARM
      93             : # ifdef __cplusplus
      94             : #   define SWIGUNUSEDPARM(p)
      95             : # else
      96             : #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
      97             : # endif
      98             : #endif
      99             : 
     100             : /* internal SWIG method */
     101             : #ifndef SWIGINTERN
     102             : # define SWIGINTERN static SWIGUNUSED
     103             : #endif
     104             : 
     105             : /* internal inline SWIG method */
     106             : #ifndef SWIGINTERNINLINE
     107             : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
     108             : #endif
     109             : 
     110             : /* exporting methods */
     111             : #if defined(__GNUC__)
     112             : #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
     113             : #    ifndef GCC_HASCLASSVISIBILITY
     114             : #      define GCC_HASCLASSVISIBILITY
     115             : #    endif
     116             : #  endif
     117             : #endif
     118             : 
     119             : #ifndef SWIGEXPORT
     120             : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
     121             : #   if defined(STATIC_LINKED)
     122             : #     define SWIGEXPORT
     123             : #   else
     124             : #     define SWIGEXPORT __declspec(dllexport)
     125             : #   endif
     126             : # else
     127             : #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
     128             : #     define SWIGEXPORT __attribute__ ((visibility("default")))
     129             : #   else
     130             : #     define SWIGEXPORT
     131             : #   endif
     132             : # endif
     133             : #endif
     134             : 
     135             : /* calling conventions for Windows */
     136             : #ifndef SWIGSTDCALL
     137             : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
     138             : #   define SWIGSTDCALL __stdcall
     139             : # else
     140             : #   define SWIGSTDCALL
     141             : # endif
     142             : #endif
     143             : 
     144             : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
     145             : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
     146             : # define _CRT_SECURE_NO_DEPRECATE
     147             : #endif
     148             : 
     149             : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
     150             : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
     151             : # define _SCL_SECURE_NO_DEPRECATE
     152             : #endif
     153             : 
     154             : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
     155             : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
     156             : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
     157             : #endif
     158             : 
     159             : /* Intel's compiler complains if a variable which was never initialised is
     160             :  * cast to void, which is a common idiom which we use to indicate that we
     161             :  * are aware a variable isn't used.  So we just silence that warning.
     162             :  * See: https://github.com/swig/swig/issues/192 for more discussion.
     163             :  */
     164             : #ifdef __INTEL_COMPILER
     165             : # pragma warning disable 592
     166             : #endif
     167             : 
     168             : 
     169             : #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
     170             : /* Use debug wrappers with the Python release dll */
     171             : # undef _DEBUG
     172             : # include <Python.h>
     173             : # define _DEBUG
     174             : #else
     175             : # include <Python.h>
     176             : #endif
     177             : 
     178             : /* -----------------------------------------------------------------------------
     179             :  * swigrun.swg
     180             :  *
     181             :  * This file contains generic C API SWIG runtime support for pointer
     182             :  * type checking.
     183             :  * ----------------------------------------------------------------------------- */
     184             : 
     185             : /* This should only be incremented when either the layout of swig_type_info changes,
     186             :    or for whatever reason, the runtime changes incompatibly */
     187             : #define SWIG_RUNTIME_VERSION "4"
     188             : 
     189             : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
     190             : #ifdef SWIG_TYPE_TABLE
     191             : # define SWIG_QUOTE_STRING(x) #x
     192             : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
     193             : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
     194             : #else
     195             : # define SWIG_TYPE_TABLE_NAME
     196             : #endif
     197             : 
     198             : /*
     199             :   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
     200             :   creating a static or dynamic library from the SWIG runtime code.
     201             :   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
     202             : 
     203             :   But only do this if strictly necessary, ie, if you have problems
     204             :   with your compiler or suchlike.
     205             : */
     206             : 
     207             : #ifndef SWIGRUNTIME
     208             : # define SWIGRUNTIME SWIGINTERN
     209             : #endif
     210             : 
     211             : #ifndef SWIGRUNTIMEINLINE
     212             : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
     213             : #endif
     214             : 
     215             : /*  Generic buffer size */
     216             : #ifndef SWIG_BUFFER_SIZE
     217             : # define SWIG_BUFFER_SIZE 1024
     218             : #endif
     219             : 
     220             : /* Flags for pointer conversions */
     221             : #define SWIG_POINTER_DISOWN        0x1
     222             : #define SWIG_CAST_NEW_MEMORY       0x2
     223             : 
     224             : /* Flags for new pointer objects */
     225             : #define SWIG_POINTER_OWN           0x1
     226             : 
     227             : 
     228             : /*
     229             :    Flags/methods for returning states.
     230             : 
     231             :    The SWIG conversion methods, as ConvertPtr, return an integer
     232             :    that tells if the conversion was successful or not. And if not,
     233             :    an error code can be returned (see swigerrors.swg for the codes).
     234             : 
     235             :    Use the following macros/flags to set or process the returning
     236             :    states.
     237             : 
     238             :    In old versions of SWIG, code such as the following was usually written:
     239             : 
     240             :      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
     241             :        // success code
     242             :      } else {
     243             :        //fail code
     244             :      }
     245             : 
     246             :    Now you can be more explicit:
     247             : 
     248             :     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
     249             :     if (SWIG_IsOK(res)) {
     250             :       // success code
     251             :     } else {
     252             :       // fail code
     253             :     }
     254             : 
     255             :    which is the same really, but now you can also do
     256             : 
     257             :     Type *ptr;
     258             :     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
     259             :     if (SWIG_IsOK(res)) {
     260             :       // success code
     261             :       if (SWIG_IsNewObj(res) {
     262             :         ...
     263             :         delete *ptr;
     264             :       } else {
     265             :         ...
     266             :       }
     267             :     } else {
     268             :       // fail code
     269             :     }
     270             : 
     271             :    I.e., now SWIG_ConvertPtr can return new objects and you can
     272             :    identify the case and take care of the deallocation. Of course that
     273             :    also requires SWIG_ConvertPtr to return new result values, such as
     274             : 
     275             :       int SWIG_ConvertPtr(obj, ptr,...) {
     276             :         if (<obj is ok>) {
     277             :           if (<need new object>) {
     278             :             *ptr = <ptr to new allocated object>;
     279             :             return SWIG_NEWOBJ;
     280             :           } else {
     281             :             *ptr = <ptr to old object>;
     282             :             return SWIG_OLDOBJ;
     283             :           }
     284             :         } else {
     285             :           return SWIG_BADOBJ;
     286             :         }
     287             :       }
     288             : 
     289             :    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
     290             :    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
     291             :    SWIG errors code.
     292             : 
     293             :    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
     294             :    allows to return the 'cast rank', for example, if you have this
     295             : 
     296             :        int food(double)
     297             :        int fooi(int);
     298             : 
     299             :    and you call
     300             : 
     301             :       food(1)   // cast rank '1'  (1 -> 1.0)
     302             :       fooi(1)   // cast rank '0'
     303             : 
     304             :    just use the SWIG_AddCast()/SWIG_CheckState()
     305             : */
     306             : 
     307             : #define SWIG_OK                    (0)
     308             : #define SWIG_ERROR                 (-1)
     309             : #define SWIG_IsOK(r)               (r >= 0)
     310             : #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
     311             : 
     312             : /* The CastRankLimit says how many bits are used for the cast rank */
     313             : #define SWIG_CASTRANKLIMIT         (1 << 8)
     314             : /* The NewMask denotes the object was created (using new/malloc) */
     315             : #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
     316             : /* The TmpMask is for in/out typemaps that use temporal objects */
     317             : #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
     318             : /* Simple returning values */
     319             : #define SWIG_BADOBJ                (SWIG_ERROR)
     320             : #define SWIG_OLDOBJ                (SWIG_OK)
     321             : #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
     322             : #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
     323             : /* Check, add and del mask methods */
     324             : #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
     325             : #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
     326             : #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
     327             : #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
     328             : #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
     329             : #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
     330             : 
     331             : /* Cast-Rank Mode */
     332             : #if defined(SWIG_CASTRANK_MODE)
     333             : #  ifndef SWIG_TypeRank
     334             : #    define SWIG_TypeRank             unsigned long
     335             : #  endif
     336             : #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
     337             : #    define SWIG_MAXCASTRANK          (2)
     338             : #  endif
     339             : #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
     340             : #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
     341             : SWIGINTERNINLINE int SWIG_AddCast(int r) {
     342             :   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
     343             : }
     344             : SWIGINTERNINLINE int SWIG_CheckState(int r) {
     345             :   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
     346             : }
     347             : #else /* no cast-rank mode */
     348             : #  define SWIG_AddCast(r) (r)
     349             : #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
     350             : #endif
     351             : 
     352             : 
     353             : #include <string.h>
     354             : 
     355             : #ifdef __cplusplus
     356             : extern "C" {
     357             : #endif
     358             : 
     359             : typedef void *(*swig_converter_func)(void *, int *);
     360             : typedef struct swig_type_info *(*swig_dycast_func)(void **);
     361             : 
     362             : /* Structure to store information on one type */
     363             : typedef struct swig_type_info {
     364             :   const char             *name;                 /* mangled name of this type */
     365             :   const char             *str;                  /* human readable name of this type */
     366             :   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
     367             :   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
     368             :   void                   *clientdata;           /* language specific type data */
     369             :   int                    owndata;               /* flag if the structure owns the clientdata */
     370             : } swig_type_info;
     371             : 
     372             : /* Structure to store a type and conversion function used for casting */
     373             : typedef struct swig_cast_info {
     374             :   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
     375             :   swig_converter_func     converter;            /* function to cast the void pointers */
     376             :   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
     377             :   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
     378             : } swig_cast_info;
     379             : 
     380             : /* Structure used to store module information
     381             :  * Each module generates one structure like this, and the runtime collects
     382             :  * all of these structures and stores them in a circularly linked list.*/
     383             : typedef struct swig_module_info {
     384             :   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
     385             :   size_t                 size;                  /* Number of types in this module */
     386             :   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
     387             :   swig_type_info         **type_initial;        /* Array of initially generated type structures */
     388             :   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
     389             :   void                    *clientdata;          /* Language specific module data */
     390             : } swig_module_info;
     391             : 
     392             : /*
     393             :   Compare two type names skipping the space characters, therefore
     394             :   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
     395             : 
     396             :   Return 0 when the two name types are equivalent, as in
     397             :   strncmp, but skipping ' '.
     398             : */
     399             : SWIGRUNTIME int
     400          21 : SWIG_TypeNameComp(const char *f1, const char *l1,
     401             :                   const char *f2, const char *l2) {
     402         115 :   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
     403          68 :     while ((*f1 == ' ') && (f1 != l1)) ++f1;
     404          70 :     while ((*f2 == ' ') && (f2 != l2)) ++f2;
     405          67 :     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
     406             :   }
     407           1 :   return (int)((l1 - f1) - (l2 - f2));
     408             : }
     409             : 
     410             : /*
     411             :   Check type equivalence in a name list like <name1>|<name2>|...
     412             :   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
     413             : */
     414             : SWIGRUNTIME int
     415          12 : SWIG_TypeCmp(const char *nb, const char *tb) {
     416          12 :   int equiv = 1;
     417          12 :   const char* te = tb + strlen(tb);
     418          12 :   const char* ne = nb;
     419          33 :   while (equiv != 0 && *ne) {
     420         593 :     for (nb = ne; *ne; ++ne) {
     421         295 :       if (*ne == '|') break;
     422             :     }
     423          21 :     equiv = SWIG_TypeNameComp(nb, ne, tb, te);
     424          21 :     if (*ne) ++ne;
     425             :   }
     426          12 :   return equiv;
     427             : }
     428             : 
     429             : /*
     430             :   Check type equivalence in a name list like <name1>|<name2>|...
     431             :   Return 0 if not equal, 1 if equal
     432             : */
     433             : SWIGRUNTIME int
     434             : SWIG_TypeEquiv(const char *nb, const char *tb) {
     435          12 :   return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
     436             : }
     437             : 
     438             : /*
     439             :   Check the typename
     440             : */
     441             : SWIGRUNTIME swig_cast_info *
     442           3 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
     443           3 :   if (ty) {
     444           3 :     swig_cast_info *iter = ty->cast;
     445           9 :     while (iter) {
     446           3 :       if (strcmp(iter->type->name, c) == 0) {
     447           0 :         if (iter == ty->cast)
     448             :           return iter;
     449             :         /* Move iter to the top of the linked list */
     450           0 :         iter->prev->next = iter->next;
     451           0 :         if (iter->next)
     452           0 :           iter->next->prev = iter->prev;
     453           0 :         iter->next = ty->cast;
     454           0 :         iter->prev = 0;
     455           0 :         if (ty->cast) ty->cast->prev = iter;
     456           0 :         ty->cast = iter;
     457           0 :         return iter;
     458             :       }
     459           3 :       iter = iter->next;
     460             :     }
     461             :   }
     462             :   return 0;
     463             : }
     464             : 
     465             : /*
     466             :   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
     467             : */
     468             : SWIGRUNTIME swig_cast_info *
     469             : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
     470             :   if (ty) {
     471             :     swig_cast_info *iter = ty->cast;
     472             :     while (iter) {
     473             :       if (iter->type == from) {
     474             :         if (iter == ty->cast)
     475             :           return iter;
     476             :         /* Move iter to the top of the linked list */
     477             :         iter->prev->next = iter->next;
     478             :         if (iter->next)
     479             :           iter->next->prev = iter->prev;
     480             :         iter->next = ty->cast;
     481             :         iter->prev = 0;
     482             :         if (ty->cast) ty->cast->prev = iter;
     483             :         ty->cast = iter;
     484             :         return iter;
     485             :       }
     486             :       iter = iter->next;
     487             :     }
     488             :   }
     489             :   return 0;
     490             : }
     491             : 
     492             : /*
     493             :   Cast a pointer up an inheritance hierarchy
     494             : */
     495             : SWIGRUNTIMEINLINE void *
     496             : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
     497           0 :   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
     498             : }
     499             : 
     500             : /*
     501             :    Dynamic pointer casting. Down an inheritance hierarchy
     502             : */
     503             : SWIGRUNTIME swig_type_info *
     504             : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
     505             :   swig_type_info *lastty = ty;
     506             :   if (!ty || !ty->dcast) return ty;
     507             :   while (ty && (ty->dcast)) {
     508             :     ty = (*ty->dcast)(ptr);
     509             :     if (ty) lastty = ty;
     510             :   }
     511             :   return lastty;
     512             : }
     513             : 
     514             : /*
     515             :   Return the name associated with this type
     516             : */
     517             : SWIGRUNTIMEINLINE const char *
     518             : SWIG_TypeName(const swig_type_info *ty) {
     519             :   return ty->name;
     520             : }
     521             : 
     522             : /*
     523             :   Return the pretty name associated with this type,
     524             :   that is an unmangled type name in a form presentable to the user.
     525             : */
     526             : SWIGRUNTIME const char *
     527             : SWIG_TypePrettyName(const swig_type_info *type) {
     528             :   /* The "str" field contains the equivalent pretty names of the
     529             :      type, separated by vertical-bar characters.  We choose
     530             :      to print the last name, as it is often (?) the most
     531             :      specific. */
     532           0 :   if (!type) return NULL;
     533           0 :   if (type->str != NULL) {
     534             :     const char *last_name = type->str;
     535             :     const char *s;
     536           0 :     for (s = type->str; *s; s++)
     537           0 :       if (*s == '|') last_name = s+1;
     538             :     return last_name;
     539             :   }
     540             :   else
     541           0 :     return type->name;
     542             : }
     543             : 
     544             : /*
     545             :    Set the clientdata field for a type
     546             : */
     547             : SWIGRUNTIME void
     548          36 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
     549          36 :   swig_cast_info *cast = ti->cast;
     550             :   /* if (ti->clientdata == clientdata) return; */
     551          36 :   ti->clientdata = clientdata;
     552             : 
     553         105 :   while (cast) {
     554          69 :     if (!cast->converter) {
     555          36 :       swig_type_info *tc = cast->type;
     556          36 :       if (!tc->clientdata) {
     557           0 :         SWIG_TypeClientData(tc, clientdata);
     558             :       }
     559             :     }
     560          69 :     cast = cast->next;
     561             :   }
     562          36 : }
     563             : SWIGRUNTIME void
     564             : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
     565          36 :   SWIG_TypeClientData(ti, clientdata);
     566          36 :   ti->owndata = 1;
     567             : }
     568             : 
     569             : /*
     570             :   Search for a swig_type_info structure only by mangled name
     571             :   Search is a O(log #types)
     572             : 
     573             :   We start searching at module start, and finish searching when start == end.
     574             :   Note: if start == end at the beginning of the function, we go all the way around
     575             :   the circular list.
     576             : */
     577             : SWIGRUNTIME swig_type_info *
     578           1 : SWIG_MangledTypeQueryModule(swig_module_info *start,
     579             :                             swig_module_info *end,
     580             :                             const char *name) {
     581           1 :   swig_module_info *iter = start;
     582             :   do {
     583           1 :     if (iter->size) {
     584           1 :       size_t l = 0;
     585           1 :       size_t r = iter->size - 1;
     586             :       do {
     587             :         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
     588           5 :         size_t i = (l + r) >> 1;
     589           5 :         const char *iname = iter->types[i]->name;
     590           5 :         if (iname) {
     591           5 :           int compare = strcmp(name, iname);
     592           5 :           if (compare == 0) {
     593             :             return iter->types[i];
     594           5 :           } else if (compare < 0) {
     595           0 :             if (i) {
     596           0 :               r = i - 1;
     597             :             } else {
     598             :               break;
     599             :             }
     600           5 :           } else if (compare > 0) {
     601           5 :             l = i + 1;
     602             :           }
     603             :         } else {
     604             :           break; /* should never happen */
     605             :         }
     606           5 :       } while (l <= r);
     607             :     }
     608           1 :     iter = iter->next;
     609           1 :   } while (iter != end);
     610             :   return 0;
     611             : }
     612             : 
     613             : /*
     614             :   Search for a swig_type_info structure for either a mangled name or a human readable name.
     615             :   It first searches the mangled names of the types, which is a O(log #types)
     616             :   If a type is not found it then searches the human readable names, which is O(#types).
     617             : 
     618             :   We start searching at module start, and finish searching when start == end.
     619             :   Note: if start == end at the beginning of the function, we go all the way around
     620             :   the circular list.
     621             : */
     622             : SWIGRUNTIME swig_type_info *
     623           1 : SWIG_TypeQueryModule(swig_module_info *start,
     624             :                      swig_module_info *end,
     625             :                      const char *name) {
     626             :   /* STEP 1: Search the name field using binary search */
     627           1 :   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
     628           1 :   if (ret) {
     629             :     return ret;
     630             :   } else {
     631             :     /* STEP 2: If the type hasn't been found, do a complete search
     632             :        of the str field (the human readable name) */
     633             :     swig_module_info *iter = start;
     634             :     do {
     635           1 :       size_t i = 0;
     636          23 :       for (; i < iter->size; ++i) {
     637          24 :         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
     638             :           return iter->types[i];
     639             :       }
     640           0 :       iter = iter->next;
     641           0 :     } while (iter != end);
     642             :   }
     643             : 
     644             :   /* neither found a match */
     645             :   return 0;
     646             : }
     647             : 
     648             : /*
     649             :    Pack binary data into a string
     650             : */
     651             : SWIGRUNTIME char *
     652             : SWIG_PackData(char *c, void *ptr, size_t sz) {
     653             :   static const char hex[17] = "0123456789abcdef";
     654           0 :   const unsigned char *u = (unsigned char *) ptr;
     655           0 :   const unsigned char *eu =  u + sz;
     656           0 :   for (; u != eu; ++u) {
     657           0 :     unsigned char uu = *u;
     658           0 :     *(c++) = hex[(uu & 0xf0) >> 4];
     659           0 :     *(c++) = hex[uu & 0xf];
     660             :   }
     661             :   return c;
     662             : }
     663             : 
     664             : /*
     665             :    Unpack binary data from a string
     666             : */
     667             : SWIGRUNTIME const char *
     668           0 : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
     669           0 :   unsigned char *u = (unsigned char *) ptr;
     670           0 :   const unsigned char *eu = u + sz;
     671           0 :   for (; u != eu; ++u) {
     672           0 :     char d = *(c++);
     673             :     unsigned char uu;
     674           0 :     if ((d >= '0') && (d <= '9'))
     675           0 :       uu = (unsigned char)((d - '0') << 4);
     676           0 :     else if ((d >= 'a') && (d <= 'f'))
     677           0 :       uu = (unsigned char)((d - ('a'-10)) << 4);
     678             :     else
     679             :       return (char *) 0;
     680           0 :     d = *(c++);
     681           0 :     if ((d >= '0') && (d <= '9'))
     682           0 :       uu |= (unsigned char)(d - '0');
     683           0 :     else if ((d >= 'a') && (d <= 'f'))
     684           0 :       uu |= (unsigned char)(d - ('a'-10));
     685             :     else
     686             :       return (char *) 0;
     687           0 :     *u = uu;
     688             :   }
     689             :   return c;
     690             : }
     691             : 
     692             : /*
     693             :    Pack 'void *' into a string buffer.
     694             : */
     695             : SWIGRUNTIME char *
     696           0 : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
     697           0 :   char *r = buff;
     698           0 :   if ((2*sizeof(void *) + 2) > bsz) return 0;
     699           0 :   *(r++) = '_';
     700           0 :   r = SWIG_PackData(r,&ptr,sizeof(void *));
     701           0 :   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
     702           0 :   strcpy(r,name);
     703           0 :   return buff;
     704             : }
     705             : 
     706             : SWIGRUNTIME const char *
     707           0 : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
     708           0 :   if (*c != '_') {
     709           0 :     if (strcmp(c,"NULL") == 0) {
     710           0 :       *ptr = (void *) 0;
     711           0 :       return name;
     712             :     } else {
     713             :       return 0;
     714             :     }
     715             :   }
     716           0 :   return SWIG_UnpackData(++c,ptr,sizeof(void *));
     717             : }
     718             : 
     719             : SWIGRUNTIME char *
     720           0 : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
     721           0 :   char *r = buff;
     722           0 :   size_t lname = (name ? strlen(name) : 0);
     723           0 :   if ((2*sz + 2 + lname) > bsz) return 0;
     724           0 :   *(r++) = '_';
     725           0 :   r = SWIG_PackData(r,ptr,sz);
     726           0 :   if (lname) {
     727           0 :     strncpy(r,name,lname+1);
     728             :   } else {
     729           0 :     *r = 0;
     730             :   }
     731             :   return buff;
     732             : }
     733             : 
     734             : SWIGRUNTIME const char *
     735             : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
     736             :   if (*c != '_') {
     737             :     if (strcmp(c,"NULL") == 0) {
     738             :       memset(ptr,0,sz);
     739             :       return name;
     740             :     } else {
     741             :       return 0;
     742             :     }
     743             :   }
     744             :   return SWIG_UnpackData(++c,ptr,sz);
     745             : }
     746             : 
     747             : #ifdef __cplusplus
     748             : }
     749             : #endif
     750             : 
     751             : /*  Errors in SWIG */
     752             : #define  SWIG_UnknownError         -1
     753             : #define  SWIG_IOError              -2
     754             : #define  SWIG_RuntimeError         -3
     755             : #define  SWIG_IndexError           -4
     756             : #define  SWIG_TypeError            -5
     757             : #define  SWIG_DivisionByZero       -6
     758             : #define  SWIG_OverflowError        -7
     759             : #define  SWIG_SyntaxError          -8
     760             : #define  SWIG_ValueError           -9
     761             : #define  SWIG_SystemError          -10
     762             : #define  SWIG_AttributeError       -11
     763             : #define  SWIG_MemoryError          -12
     764             : #define  SWIG_NullReferenceError   -13
     765             : 
     766             : 
     767             : 
     768             : /* Compatibility macros for Python 3 */
     769             : #if PY_VERSION_HEX >= 0x03000000
     770             : 
     771             : #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
     772             : #define PyInt_Check(x) PyLong_Check(x)
     773             : #define PyInt_AsLong(x) PyLong_AsLong(x)
     774             : #define PyInt_FromLong(x) PyLong_FromLong(x)
     775             : #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
     776             : #define PyString_Check(name) PyBytes_Check(name)
     777             : #define PyString_FromString(x) PyUnicode_FromString(x)
     778             : #define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
     779             : #define PyString_AsString(str) PyBytes_AsString(str)
     780             : #define PyString_Size(str) PyBytes_Size(str)    
     781             : #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
     782             : #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
     783             : #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
     784             : #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
     785             : 
     786             : #endif
     787             : 
     788             : #ifndef Py_TYPE
     789             : #  define Py_TYPE(op) ((op)->ob_type)
     790             : #endif
     791             : 
     792             : /* SWIG APIs for compatibility of both Python 2 & 3 */
     793             : 
     794             : #if PY_VERSION_HEX >= 0x03000000
     795             : #  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
     796             : #else
     797             : #  define SWIG_Python_str_FromFormat PyString_FromFormat
     798             : #endif
     799             : 
     800             : 
     801             : /* Warning: This function will allocate a new string in Python 3,
     802             :  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
     803             :  */
     804             : SWIGINTERN char*
     805             : SWIG_Python_str_AsChar(PyObject *str)
     806             : {
     807             : #if PY_VERSION_HEX >= 0x03000000
     808             :   char *cstr;
     809             :   char *newstr;
     810             :   Py_ssize_t len;
     811             :   str = PyUnicode_AsUTF8String(str);
     812             :   PyBytes_AsStringAndSize(str, &cstr, &len);
     813             :   newstr = (char *) malloc(len+1);
     814             :   memcpy(newstr, cstr, len+1);
     815             :   Py_XDECREF(str);
     816             :   return newstr;
     817             : #else
     818           0 :   return PyString_AsString(str);
     819             : #endif
     820             : }
     821             : 
     822             : #if PY_VERSION_HEX >= 0x03000000
     823             : #  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
     824             : #else
     825             : #  define SWIG_Python_str_DelForPy3(x) 
     826             : #endif
     827             : 
     828             : 
     829             : SWIGINTERN PyObject*
     830             : SWIG_Python_str_FromChar(const char *c)
     831             : {
     832             : #if PY_VERSION_HEX >= 0x03000000
     833             :   return PyUnicode_FromString(c); 
     834             : #else
     835           4 :   return PyString_FromString(c);
     836             : #endif
     837             : }
     838             : 
     839             : /* Add PyOS_snprintf for old Pythons */
     840             : #if PY_VERSION_HEX < 0x02020000
     841             : # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
     842             : #  define PyOS_snprintf _snprintf
     843             : # else
     844             : #  define PyOS_snprintf snprintf
     845             : # endif
     846             : #endif
     847             : 
     848             : /* A crude PyString_FromFormat implementation for old Pythons */
     849             : #if PY_VERSION_HEX < 0x02020000
     850             : 
     851             : #ifndef SWIG_PYBUFFER_SIZE
     852             : # define SWIG_PYBUFFER_SIZE 1024
     853             : #endif
     854             : 
     855             : static PyObject *
     856             : PyString_FromFormat(const char *fmt, ...) {
     857             :   va_list ap;
     858             :   char buf[SWIG_PYBUFFER_SIZE * 2];
     859             :   int res;
     860             :   va_start(ap, fmt);
     861             :   res = vsnprintf(buf, sizeof(buf), fmt, ap);
     862             :   va_end(ap);
     863             :   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
     864             : }
     865             : #endif
     866             : 
     867             : #ifndef PyObject_DEL
     868             : # define PyObject_DEL PyObject_Del
     869             : #endif
     870             : 
     871             : /* A crude PyExc_StopIteration exception for old Pythons */
     872             : #if PY_VERSION_HEX < 0x02020000
     873             : # ifndef PyExc_StopIteration
     874             : #  define PyExc_StopIteration PyExc_RuntimeError
     875             : # endif
     876             : # ifndef PyObject_GenericGetAttr
     877             : #  define PyObject_GenericGetAttr 0
     878             : # endif
     879             : #endif
     880             : 
     881             : /* Py_NotImplemented is defined in 2.1 and up. */
     882             : #if PY_VERSION_HEX < 0x02010000
     883             : # ifndef Py_NotImplemented
     884             : #  define Py_NotImplemented PyExc_RuntimeError
     885             : # endif
     886             : #endif
     887             : 
     888             : /* A crude PyString_AsStringAndSize implementation for old Pythons */
     889             : #if PY_VERSION_HEX < 0x02010000
     890             : # ifndef PyString_AsStringAndSize
     891             : #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
     892             : # endif
     893             : #endif
     894             : 
     895             : /* PySequence_Size for old Pythons */
     896             : #if PY_VERSION_HEX < 0x02000000
     897             : # ifndef PySequence_Size
     898             : #  define PySequence_Size PySequence_Length
     899             : # endif
     900             : #endif
     901             : 
     902             : /* PyBool_FromLong for old Pythons */
     903             : #if PY_VERSION_HEX < 0x02030000
     904             : static
     905             : PyObject *PyBool_FromLong(long ok)
     906             : {
     907             :   PyObject *result = ok ? Py_True : Py_False;
     908             :   Py_INCREF(result);
     909             :   return result;
     910             : }
     911             : #endif
     912             : 
     913             : /* Py_ssize_t for old Pythons */
     914             : /* This code is as recommended by: */
     915             : /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
     916             : #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
     917             : typedef int Py_ssize_t;
     918             : # define PY_SSIZE_T_MAX INT_MAX
     919             : # define PY_SSIZE_T_MIN INT_MIN
     920             : typedef inquiry lenfunc;
     921             : typedef intargfunc ssizeargfunc;
     922             : typedef intintargfunc ssizessizeargfunc;
     923             : typedef intobjargproc ssizeobjargproc;
     924             : typedef intintobjargproc ssizessizeobjargproc;
     925             : typedef getreadbufferproc readbufferproc;
     926             : typedef getwritebufferproc writebufferproc;
     927             : typedef getsegcountproc segcountproc;
     928             : typedef getcharbufferproc charbufferproc;
     929             : static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
     930             : {
     931             :   long result = 0;
     932             :   PyObject *i = PyNumber_Int(x);
     933             :   if (i) {
     934             :     result = PyInt_AsLong(i);
     935             :     Py_DECREF(i);
     936             :   }
     937             :   return result;
     938             : }
     939             : #endif
     940             : 
     941             : #if PY_VERSION_HEX < 0x02050000
     942             : #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
     943             : #endif
     944             : 
     945             : #if PY_VERSION_HEX < 0x02040000
     946             : #define Py_VISIT(op)                            \
     947             :   do {                                          \
     948             :     if (op) {                                   \
     949             :       int vret = visit((op), arg);              \
     950             :       if (vret)                                 \
     951             :         return vret;                            \
     952             :     }                                           \
     953             :   } while (0)
     954             : #endif
     955             : 
     956             : #if PY_VERSION_HEX < 0x02030000
     957             : typedef struct {
     958             :   PyTypeObject type;
     959             :   PyNumberMethods as_number;
     960             :   PyMappingMethods as_mapping;
     961             :   PySequenceMethods as_sequence;
     962             :   PyBufferProcs as_buffer;
     963             :   PyObject *name, *slots;
     964             : } PyHeapTypeObject;
     965             : #endif
     966             : 
     967             : #if PY_VERSION_HEX < 0x02030000
     968             : typedef destructor freefunc;
     969             : #endif
     970             : 
     971             : #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
     972             :      (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
     973             :      (PY_MAJOR_VERSION > 3))
     974             : # define SWIGPY_USE_CAPSULE
     975             : # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
     976             : #endif
     977             : 
     978             : #if PY_VERSION_HEX < 0x03020000
     979             : #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
     980             : #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
     981             : #endif
     982             : 
     983             : /* -----------------------------------------------------------------------------
     984             :  * error manipulation
     985             :  * ----------------------------------------------------------------------------- */
     986             : 
     987             : SWIGRUNTIME PyObject*
     988           0 : SWIG_Python_ErrorType(int code) {
     989           0 :   PyObject* type = 0;
     990           0 :   switch(code) {
     991             :   case SWIG_MemoryError:
     992           0 :     type = PyExc_MemoryError;
     993           0 :     break;
     994             :   case SWIG_IOError:
     995           0 :     type = PyExc_IOError;
     996           0 :     break;
     997             :   case SWIG_RuntimeError:
     998           0 :     type = PyExc_RuntimeError;
     999           0 :     break;
    1000             :   case SWIG_IndexError:
    1001           0 :     type = PyExc_IndexError;
    1002           0 :     break;
    1003             :   case SWIG_TypeError:
    1004           0 :     type = PyExc_TypeError;
    1005           0 :     break;
    1006             :   case SWIG_DivisionByZero:
    1007           0 :     type = PyExc_ZeroDivisionError;
    1008           0 :     break;
    1009             :   case SWIG_OverflowError:
    1010           0 :     type = PyExc_OverflowError;
    1011           0 :     break;
    1012             :   case SWIG_SyntaxError:
    1013           0 :     type = PyExc_SyntaxError;
    1014           0 :     break;
    1015             :   case SWIG_ValueError:
    1016           0 :     type = PyExc_ValueError;
    1017           0 :     break;
    1018             :   case SWIG_SystemError:
    1019           0 :     type = PyExc_SystemError;
    1020           0 :     break;
    1021             :   case SWIG_AttributeError:
    1022           0 :     type = PyExc_AttributeError;
    1023           0 :     break;
    1024             :   default:
    1025           0 :     type = PyExc_RuntimeError;
    1026             :   }
    1027           0 :   return type;
    1028             : }
    1029             : 
    1030             : 
    1031             : SWIGRUNTIME void
    1032             : SWIG_Python_AddErrorMsg(const char* mesg)
    1033             : {
    1034             :   PyObject *type = 0;
    1035             :   PyObject *value = 0;
    1036             :   PyObject *traceback = 0;
    1037             : 
    1038             :   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
    1039             :   if (value) {
    1040             :     char *tmp;
    1041             :     PyObject *old_str = PyObject_Str(value);
    1042             :     PyErr_Clear();
    1043             :     Py_XINCREF(type);
    1044             : 
    1045             :     PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    1046             :     SWIG_Python_str_DelForPy3(tmp);
    1047             :     Py_DECREF(old_str);
    1048             :     Py_DECREF(value);
    1049             :   } else {
    1050             :     PyErr_SetString(PyExc_RuntimeError, mesg);
    1051             :   }
    1052             : }
    1053             : 
    1054             : #if defined(SWIG_PYTHON_NO_THREADS)
    1055             : #  if defined(SWIG_PYTHON_THREADS)
    1056             : #    undef SWIG_PYTHON_THREADS
    1057             : #  endif
    1058             : #endif
    1059             : #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
    1060             : #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
    1061             : #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
    1062             : #      define SWIG_PYTHON_USE_GIL
    1063             : #    endif
    1064             : #  endif
    1065             : #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
    1066             : #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
    1067             : #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
    1068             : #    endif
    1069             : #    ifdef __cplusplus /* C++ code */
    1070             :        class SWIG_Python_Thread_Block {
    1071             :          bool status;
    1072             :          PyGILState_STATE state;
    1073             :        public:
    1074             :          void end() { if (status) { PyGILState_Release(state); status = false;} }
    1075             :          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
    1076             :          ~SWIG_Python_Thread_Block() { end(); }
    1077             :        };
    1078             :        class SWIG_Python_Thread_Allow {
    1079             :          bool status;
    1080             :          PyThreadState *save;
    1081             :        public:
    1082             :          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
    1083             :          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
    1084             :          ~SWIG_Python_Thread_Allow() { end(); }
    1085             :        };
    1086             : #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
    1087             : #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
    1088             : #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
    1089             : #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
    1090             : #    else /* C code */
    1091             : #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
    1092             : #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
    1093             : #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
    1094             : #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
    1095             : #    endif
    1096             : #  else /* Old thread way, not implemented, user must provide it */
    1097             : #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
    1098             : #      define SWIG_PYTHON_INITIALIZE_THREADS
    1099             : #    endif
    1100             : #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
    1101             : #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
    1102             : #    endif
    1103             : #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
    1104             : #      define SWIG_PYTHON_THREAD_END_BLOCK
    1105             : #    endif
    1106             : #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
    1107             : #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
    1108             : #    endif
    1109             : #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
    1110             : #      define SWIG_PYTHON_THREAD_END_ALLOW
    1111             : #    endif
    1112             : #  endif
    1113             : #else /* No thread support */
    1114             : #  define SWIG_PYTHON_INITIALIZE_THREADS
    1115             : #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
    1116             : #  define SWIG_PYTHON_THREAD_END_BLOCK
    1117             : #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
    1118             : #  define SWIG_PYTHON_THREAD_END_ALLOW
    1119             : #endif
    1120             : 
    1121             : /* -----------------------------------------------------------------------------
    1122             :  * Python API portion that goes into the runtime
    1123             :  * ----------------------------------------------------------------------------- */
    1124             : 
    1125             : #ifdef __cplusplus
    1126             : extern "C" {
    1127             : #endif
    1128             : 
    1129             : /* -----------------------------------------------------------------------------
    1130             :  * Constant declarations
    1131             :  * ----------------------------------------------------------------------------- */
    1132             : 
    1133             : /* Constant Types */
    1134             : #define SWIG_PY_POINTER 4
    1135             : #define SWIG_PY_BINARY  5
    1136             : 
    1137             : /* Constant information structure */
    1138             : typedef struct swig_const_info {
    1139             :   int type;
    1140             :   char *name;
    1141             :   long lvalue;
    1142             :   double dvalue;
    1143             :   void   *pvalue;
    1144             :   swig_type_info **ptype;
    1145             : } swig_const_info;
    1146             : 
    1147             : 
    1148             : /* -----------------------------------------------------------------------------
    1149             :  * Wrapper of PyInstanceMethod_New() used in Python 3
    1150             :  * It is exported to the generated module, used for -fastproxy
    1151             :  * ----------------------------------------------------------------------------- */
    1152             : #if PY_VERSION_HEX >= 0x03000000
    1153             : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
    1154             : {
    1155             :   return PyInstanceMethod_New(func);
    1156             : }
    1157             : #else
    1158           0 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
    1159             : {
    1160           0 :   return NULL;
    1161             : }
    1162             : #endif
    1163             : 
    1164             : #ifdef __cplusplus
    1165             : }
    1166             : #endif
    1167             : 
    1168             : 
    1169             : /* -----------------------------------------------------------------------------
    1170             :  * pyrun.swg
    1171             :  *
    1172             :  * This file contains the runtime support for Python modules
    1173             :  * and includes code for managing global variables and pointer
    1174             :  * type checking.
    1175             :  *
    1176             :  * ----------------------------------------------------------------------------- */
    1177             : 
    1178             : /* Common SWIG API */
    1179             : 
    1180             : /* for raw pointers */
    1181             : #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
    1182             : #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
    1183             : #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
    1184             : 
    1185             : #ifdef SWIGPYTHON_BUILTIN
    1186             : #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
    1187             : #else
    1188             : #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
    1189             : #endif
    1190             : 
    1191             : #define SWIG_InternalNewPointerObj(ptr, type, flags)    SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
    1192             : 
    1193             : #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
    1194             : #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
    1195             : #define swig_owntype                                    int
    1196             : 
    1197             : /* for raw packed data */
    1198             : #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
    1199             : #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
    1200             : 
    1201             : /* for class or struct pointers */
    1202             : #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
    1203             : #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
    1204             : 
    1205             : /* for C or C++ function pointers */
    1206             : #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
    1207             : #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
    1208             : 
    1209             : /* for C++ member pointers, ie, member methods */
    1210             : #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
    1211             : #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
    1212             : 
    1213             : 
    1214             : /* Runtime API */
    1215             : 
    1216             : #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
    1217             : #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
    1218             : #define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
    1219             : 
    1220             : #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
    1221             : #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg                            
    1222             : #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)                        
    1223             : #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
    1224             : #define SWIG_fail                                       goto fail                                          
    1225             : 
    1226             : 
    1227             : /* Runtime API implementation */
    1228             : 
    1229             : /* Error manipulation */
    1230             : 
    1231             : SWIGINTERN void 
    1232           6 : SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
    1233             :   SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
    1234           6 :   PyErr_SetObject(errtype, obj);
    1235           6 :   Py_DECREF(obj);
    1236             :   SWIG_PYTHON_THREAD_END_BLOCK;
    1237           6 : }
    1238             : 
    1239             : SWIGINTERN void 
    1240             : SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
    1241             :   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    1242           0 :   PyErr_SetString(errtype, msg);
    1243             :   SWIG_PYTHON_THREAD_END_BLOCK;
    1244             : }
    1245             : 
    1246             : #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
    1247             : 
    1248             : /* Set a constant value */
    1249             : 
    1250             : #if defined(SWIGPYTHON_BUILTIN)
    1251             : 
    1252             : SWIGINTERN void
    1253             : SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
    1254             :   PyObject *s = PyString_InternFromString(key);
    1255             :   PyList_Append(seq, s);
    1256             :   Py_DECREF(s);
    1257             : }
    1258             : 
    1259             : SWIGINTERN void
    1260             : SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
    1261             : #if PY_VERSION_HEX < 0x02030000
    1262             :   PyDict_SetItemString(d, (char *)name, obj);
    1263             : #else
    1264             :   PyDict_SetItemString(d, name, obj);
    1265             : #endif
    1266             :   Py_DECREF(obj);
    1267             :   if (public_interface)
    1268             :     SwigPyBuiltin_AddPublicSymbol(public_interface, name);
    1269             : }
    1270             : 
    1271             : #else
    1272             : 
    1273             : SWIGINTERN void
    1274         174 : SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
    1275             : #if PY_VERSION_HEX < 0x02030000
    1276             :   PyDict_SetItemString(d, (char *)name, obj);
    1277             : #else
    1278         174 :   PyDict_SetItemString(d, name, obj);
    1279             : #endif
    1280         174 :   Py_DECREF(obj);                            
    1281         174 : }
    1282             : 
    1283             : #endif
    1284             : 
    1285             : /* Append a value to the result obj */
    1286             : 
    1287             : SWIGINTERN PyObject*
    1288             : SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
    1289             : #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
    1290             :   if (!result) {
    1291             :     result = obj;
    1292             :   } else if (result == Py_None) {
    1293             :     Py_DECREF(result);
    1294             :     result = obj;
    1295             :   } else {
    1296             :     if (!PyList_Check(result)) {
    1297             :       PyObject *o2 = result;
    1298             :       result = PyList_New(1);
    1299             :       PyList_SetItem(result, 0, o2);
    1300             :     }
    1301             :     PyList_Append(result,obj);
    1302             :     Py_DECREF(obj);
    1303             :   }
    1304             :   return result;
    1305             : #else
    1306             :   PyObject*   o2;
    1307             :   PyObject*   o3;
    1308             :   if (!result) {
    1309             :     result = obj;
    1310             :   } else if (result == Py_None) {
    1311             :     Py_DECREF(result);
    1312             :     result = obj;
    1313             :   } else {
    1314             :     if (!PyTuple_Check(result)) {
    1315             :       o2 = result;
    1316             :       result = PyTuple_New(1);
    1317             :       PyTuple_SET_ITEM(result, 0, o2);
    1318             :     }
    1319             :     o3 = PyTuple_New(1);
    1320             :     PyTuple_SET_ITEM(o3, 0, obj);
    1321             :     o2 = result;
    1322             :     result = PySequence_Concat(o2, o3);
    1323             :     Py_DECREF(o2);
    1324             :     Py_DECREF(o3);
    1325             :   }
    1326             :   return result;
    1327             : #endif
    1328             : }
    1329             : 
    1330             : /* Unpack the argument tuple */
    1331             : 
    1332             : SWIGINTERN Py_ssize_t
    1333         475 : SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
    1334             : {
    1335         475 :   if (!args) {
    1336           0 :     if (!min && !max) {
    1337             :       return 1;
    1338             :     } else {
    1339           0 :       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
    1340           0 :                    name, (min == max ? "" : "at least "), (int)min);
    1341           0 :       return 0;
    1342             :     }
    1343             :   }  
    1344         475 :   if (!PyTuple_Check(args)) {
    1345           0 :     if (min <= 1 && max >= 1) {
    1346             :       Py_ssize_t i;
    1347           0 :       objs[0] = args;
    1348           0 :       for (i = 1; i < max; ++i) {
    1349           0 :         objs[i] = 0;
    1350             :       }
    1351             :       return 2;
    1352             :     }
    1353           0 :     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    1354           0 :     return 0;
    1355             :   } else {
    1356         475 :     Py_ssize_t l = PyTuple_GET_SIZE(args);
    1357         475 :     if (l < min) {
    1358           0 :       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
    1359           0 :                    name, (min == max ? "" : "at least "), (int)min, (int)l);
    1360           0 :       return 0;
    1361         475 :     } else if (l > max) {
    1362           0 :       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
    1363           0 :                    name, (min == max ? "" : "at most "), (int)max, (int)l);
    1364           0 :       return 0;
    1365             :     } else {
    1366             :       Py_ssize_t i;
    1367        2249 :       for (i = 0; i < l; ++i) {
    1368         887 :         objs[i] = PyTuple_GET_ITEM(args, i);
    1369             :       }
    1370         587 :       for (; l < max; ++l) {
    1371          56 :         objs[l] = 0;
    1372             :       }
    1373         475 :       return i + 1;
    1374             :     }    
    1375             :   }
    1376             : }
    1377             : 
    1378             : /* A functor is a function object with one single object argument */
    1379             : #if PY_VERSION_HEX >= 0x02020000
    1380             : #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
    1381             : #else
    1382             : #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
    1383             : #endif
    1384             : 
    1385             : /*
    1386             :   Helper for static pointer initialization for both C and C++ code, for example
    1387             :   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
    1388             : */
    1389             : #ifdef __cplusplus
    1390             : #define SWIG_STATIC_POINTER(var)  var
    1391             : #else
    1392             : #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
    1393             : #endif
    1394             : 
    1395             : /* -----------------------------------------------------------------------------
    1396             :  * Pointer declarations
    1397             :  * ----------------------------------------------------------------------------- */
    1398             : 
    1399             : /* Flags for new pointer objects */
    1400             : #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
    1401             : #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
    1402             : 
    1403             : #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
    1404             : 
    1405             : #define SWIG_BUILTIN_TP_INIT        (SWIG_POINTER_OWN << 2)
    1406             : #define SWIG_BUILTIN_INIT           (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
    1407             : 
    1408             : #ifdef __cplusplus
    1409             : extern "C" {
    1410             : #endif
    1411             : 
    1412             : /*  How to access Py_None */
    1413             : #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
    1414             : #  ifndef SWIG_PYTHON_NO_BUILD_NONE
    1415             : #    ifndef SWIG_PYTHON_BUILD_NONE
    1416             : #      define SWIG_PYTHON_BUILD_NONE
    1417             : #    endif
    1418             : #  endif
    1419             : #endif
    1420             : 
    1421             : #ifdef SWIG_PYTHON_BUILD_NONE
    1422             : #  ifdef Py_None
    1423             : #   undef Py_None
    1424             : #   define Py_None SWIG_Py_None()
    1425             : #  endif
    1426             : SWIGRUNTIMEINLINE PyObject * 
    1427             : _SWIG_Py_None(void)
    1428             : {
    1429             :   PyObject *none = Py_BuildValue((char*)"");
    1430             :   Py_DECREF(none);
    1431             :   return none;
    1432             : }
    1433             : SWIGRUNTIME PyObject * 
    1434             : SWIG_Py_None(void)
    1435             : {
    1436             :   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
    1437             :   return none;
    1438             : }
    1439             : #endif
    1440             : 
    1441             : /* The python void return value */
    1442             : 
    1443             : SWIGRUNTIMEINLINE PyObject * 
    1444             : SWIG_Py_Void(void)
    1445             : {
    1446         420 :   PyObject *none = Py_None;
    1447         420 :   Py_INCREF(none);
    1448             :   return none;
    1449             : }
    1450             : 
    1451             : /* SwigPyClientData */
    1452             : 
    1453             : typedef struct {
    1454             :   PyObject *klass;
    1455             :   PyObject *newraw;
    1456             :   PyObject *newargs;
    1457             :   PyObject *destroy;
    1458             :   int delargs;
    1459             :   int implicitconv;
    1460             :   PyTypeObject *pytype;
    1461             : } SwigPyClientData;
    1462             : 
    1463             : SWIGRUNTIMEINLINE int 
    1464             : SWIG_Python_CheckImplicit(swig_type_info *ty)
    1465             : {
    1466             :   SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
    1467             :   return data ? data->implicitconv : 0;
    1468             : }
    1469             : 
    1470             : SWIGRUNTIMEINLINE PyObject *
    1471             : SWIG_Python_ExceptionType(swig_type_info *desc) {
    1472           1 :   SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
    1473           1 :   PyObject *klass = data ? data->klass : 0;
    1474           1 :   return (klass ? klass : PyExc_RuntimeError);
    1475             : }
    1476             : 
    1477             : 
    1478             : SWIGRUNTIME SwigPyClientData * 
    1479          36 : SwigPyClientData_New(PyObject* obj)
    1480             : {
    1481          36 :   if (!obj) {
    1482             :     return 0;
    1483             :   } else {
    1484          36 :     SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    1485             :     /* the klass element */
    1486          36 :     data->klass = obj;
    1487          36 :     Py_INCREF(data->klass);
    1488             :     /* the newraw method and newargs arguments used to create a new raw instance */
    1489          36 :     if (PyClass_Check(obj)) {
    1490           0 :       data->newraw = 0;
    1491           0 :       data->newargs = obj;
    1492           0 :       Py_INCREF(obj);
    1493             :     } else {
    1494             : #if (PY_VERSION_HEX < 0x02020000)
    1495             :       data->newraw = 0;
    1496             : #else
    1497          36 :       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
    1498             : #endif
    1499          36 :       if (data->newraw) {
    1500          36 :         Py_INCREF(data->newraw);
    1501          36 :         data->newargs = PyTuple_New(1);
    1502          36 :         PyTuple_SetItem(data->newargs, 0, obj);
    1503             :       } else {
    1504           0 :         data->newargs = obj;
    1505             :       }
    1506          36 :       Py_INCREF(data->newargs);
    1507             :     }
    1508             :     /* the destroy method, aka as the C++ delete method */
    1509          36 :     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
    1510          36 :     if (PyErr_Occurred()) {
    1511           0 :       PyErr_Clear();
    1512           0 :       data->destroy = 0;
    1513             :     }
    1514          36 :     if (data->destroy) {
    1515             :       int flags;
    1516          36 :       Py_INCREF(data->destroy);
    1517          36 :       flags = PyCFunction_GET_FLAGS(data->destroy);
    1518             : #ifdef METH_O
    1519          36 :       data->delargs = !(flags & (METH_O));
    1520             : #else
    1521             :       data->delargs = 0;
    1522             : #endif
    1523             :     } else {
    1524           0 :       data->delargs = 0;
    1525             :     }
    1526          36 :     data->implicitconv = 0;
    1527          36 :     data->pytype = 0;
    1528          36 :     return data;
    1529             :   }
    1530             : }
    1531             : 
    1532             : SWIGRUNTIME void 
    1533          36 : SwigPyClientData_Del(SwigPyClientData *data) {
    1534          36 :   Py_XDECREF(data->newraw);
    1535          36 :   Py_XDECREF(data->newargs);
    1536          36 :   Py_XDECREF(data->destroy);
    1537          36 : }
    1538             : 
    1539             : /* =============== SwigPyObject =====================*/
    1540             : 
    1541             : typedef struct {
    1542             :   PyObject_HEAD
    1543             :   void *ptr;
    1544             :   swig_type_info *ty;
    1545             :   int own;
    1546             :   PyObject *next;
    1547             : #ifdef SWIGPYTHON_BUILTIN
    1548             :   PyObject *dict;
    1549             : #endif
    1550             : } SwigPyObject;
    1551             : 
    1552             : 
    1553             : #ifdef SWIGPYTHON_BUILTIN
    1554             : 
    1555             : SWIGRUNTIME PyObject *
    1556             : SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
    1557             : {
    1558             :   SwigPyObject *sobj = (SwigPyObject *)v;
    1559             : 
    1560             :   if (!sobj->dict)
    1561             :     sobj->dict = PyDict_New();
    1562             : 
    1563             :   Py_INCREF(sobj->dict);
    1564             :   return sobj->dict;
    1565             : }
    1566             : 
    1567             : #endif
    1568             : 
    1569             : SWIGRUNTIME PyObject *
    1570           0 : SwigPyObject_long(SwigPyObject *v)
    1571             : {
    1572           0 :   return PyLong_FromVoidPtr(v->ptr);
    1573             : }
    1574             : 
    1575             : SWIGRUNTIME PyObject *
    1576           0 : SwigPyObject_format(const char* fmt, SwigPyObject *v)
    1577             : {
    1578           0 :   PyObject *res = NULL;
    1579           0 :   PyObject *args = PyTuple_New(1);
    1580           0 :   if (args) {
    1581           0 :     if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
    1582           0 :       PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
    1583           0 :       if (ofmt) {
    1584             : #if PY_VERSION_HEX >= 0x03000000
    1585             :         res = PyUnicode_Format(ofmt,args);
    1586             : #else
    1587           0 :         res = PyString_Format(ofmt,args);
    1588             : #endif
    1589           0 :         Py_DECREF(ofmt);
    1590             :       }
    1591           0 :       Py_DECREF(args);
    1592             :     }
    1593             :   }
    1594           0 :   return res;
    1595             : }
    1596             : 
    1597             : SWIGRUNTIME PyObject *
    1598           0 : SwigPyObject_oct(SwigPyObject *v)
    1599             : {
    1600           0 :   return SwigPyObject_format("%o",v);
    1601             : }
    1602             : 
    1603             : SWIGRUNTIME PyObject *
    1604           0 : SwigPyObject_hex(SwigPyObject *v)
    1605             : {
    1606           0 :   return SwigPyObject_format("%x",v);
    1607             : }
    1608             : 
    1609             : SWIGRUNTIME PyObject *
    1610             : #ifdef METH_NOARGS
    1611           0 : SwigPyObject_repr(SwigPyObject *v)
    1612             : #else
    1613             : SwigPyObject_repr(SwigPyObject *v, PyObject *args)
    1614             : #endif
    1615             : {
    1616           0 :   const char *name = SWIG_TypePrettyName(v->ty);
    1617           0 :   PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
    1618           0 :   if (v->next) {
    1619             : # ifdef METH_NOARGS
    1620           0 :     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
    1621             : # else
    1622             :     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
    1623             : # endif
    1624             : # if PY_VERSION_HEX >= 0x03000000
    1625             :     PyObject *joined = PyUnicode_Concat(repr, nrep);
    1626             :     Py_DecRef(repr);
    1627             :     Py_DecRef(nrep);
    1628             :     repr = joined;
    1629             : # else
    1630           0 :     PyString_ConcatAndDel(&repr,nrep);
    1631             : # endif
    1632             :   }
    1633           0 :   return repr;  
    1634             : }
    1635             : 
    1636             : SWIGRUNTIME int
    1637           0 : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
    1638             : {
    1639           2 :   void *i = v->ptr;
    1640           2 :   void *j = w->ptr;
    1641           2 :   return (i < j) ? -1 : ((i > j) ? 1 : 0);
    1642             : }
    1643             : 
    1644             : /* Added for Python 3.x, would it also be useful for Python 2.x? */
    1645             : SWIGRUNTIME PyObject*
    1646           2 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
    1647             : {
    1648             :   PyObject* res;
    1649           2 :   if( op != Py_EQ && op != Py_NE ) {
    1650           0 :     Py_INCREF(Py_NotImplemented);
    1651           0 :     return Py_NotImplemented;
    1652             :   }
    1653           2 :   res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
    1654           2 :   return res;  
    1655             : }
    1656             : 
    1657             : 
    1658             : SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
    1659             : 
    1660             : #ifdef SWIGPYTHON_BUILTIN
    1661             : static swig_type_info *SwigPyObject_stype = 0;
    1662             : SWIGRUNTIME PyTypeObject*
    1663             : SwigPyObject_type(void) {
    1664             :     SwigPyClientData *cd;
    1665             :     assert(SwigPyObject_stype);
    1666             :     cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    1667             :     assert(cd);
    1668             :     assert(cd->pytype);
    1669             :     return cd->pytype;
    1670             : }
    1671             : #else
    1672             : SWIGRUNTIME PyTypeObject*
    1673        1781 : SwigPyObject_type(void) {
    1674        1781 :   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
    1675        1781 :   return type;
    1676             : }
    1677             : #endif
    1678             : 
    1679             : SWIGRUNTIMEINLINE int
    1680        1347 : SwigPyObject_Check(PyObject *op) {
    1681             : #ifdef SWIGPYTHON_BUILTIN
    1682             :   PyTypeObject *target_tp = SwigPyObject_type();
    1683             :   if (PyType_IsSubtype(op->ob_type, target_tp))
    1684             :     return 1;
    1685             :   return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
    1686             : #else
    1687        1347 :   return (Py_TYPE(op) == SwigPyObject_type())
    1688        1347 :     || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
    1689             : #endif
    1690             : }
    1691             : 
    1692             : SWIGRUNTIME PyObject *
    1693             : SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
    1694             : 
    1695             : SWIGRUNTIME void
    1696         214 : SwigPyObject_dealloc(PyObject *v)
    1697             : {
    1698         214 :   SwigPyObject *sobj = (SwigPyObject *) v;
    1699         214 :   PyObject *next = sobj->next;
    1700         214 :   if (sobj->own == SWIG_POINTER_OWN) {
    1701         198 :     swig_type_info *ty = sobj->ty;
    1702         198 :     SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    1703         198 :     PyObject *destroy = data ? data->destroy : 0;
    1704         198 :     if (destroy) {
    1705             :       /* destroy is always a VARARGS method */
    1706             :       PyObject *res;
    1707             : 
    1708             :       /* PyObject_CallFunction() has the potential to silently drop
    1709             :          the active active exception.  In cases of unnamed temporary
    1710             :          variable or where we just finished iterating over a generator
    1711             :          StopIteration will be active right now, and this needs to
    1712             :          remain true upon return from SwigPyObject_dealloc.  So save
    1713             :          and restore. */
    1714             :       
    1715         198 :       PyObject *val = NULL, *type = NULL, *tb = NULL;
    1716         198 :       PyErr_Fetch(&val, &type, &tb);
    1717             : 
    1718         198 :       if (data->delargs) {
    1719             :         /* we need to create a temporary object to carry the destroy operation */
    1720           0 :         PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
    1721           0 :         res = SWIG_Python_CallFunctor(destroy, tmp);
    1722           0 :         Py_DECREF(tmp);
    1723             :       } else {
    1724         198 :         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
    1725         198 :         PyObject *mself = PyCFunction_GET_SELF(destroy);
    1726         198 :         res = ((*meth)(mself, v));
    1727             :       }
    1728         198 :       if (!res)
    1729           0 :         PyErr_WriteUnraisable(destroy);
    1730             : 
    1731         198 :       PyErr_Restore(val, type, tb);
    1732             : 
    1733         198 :       Py_XDECREF(res);
    1734             :     } 
    1735             : #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    1736             :     else {
    1737           0 :       const char *name = SWIG_TypePrettyName(ty);
    1738           0 :       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    1739             :     }
    1740             : #endif
    1741             :   } 
    1742         214 :   Py_XDECREF(next);
    1743         214 :   PyObject_DEL(v);
    1744         214 : }
    1745             : 
    1746             : SWIGRUNTIME PyObject* 
    1747           0 : SwigPyObject_append(PyObject* v, PyObject* next)
    1748             : {
    1749           0 :   SwigPyObject *sobj = (SwigPyObject *) v;
    1750             : #ifndef METH_O
    1751             :   PyObject *tmp = 0;
    1752             :   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
    1753             :   next = tmp;
    1754             : #endif
    1755           0 :   if (!SwigPyObject_Check(next)) {
    1756           0 :     PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    1757           0 :     return NULL;
    1758             :   }
    1759           0 :   sobj->next = next;
    1760           0 :   Py_INCREF(next);
    1761           0 :   return SWIG_Py_Void();
    1762             : }
    1763             : 
    1764             : SWIGRUNTIME PyObject* 
    1765             : #ifdef METH_NOARGS
    1766           0 : SwigPyObject_next(PyObject* v)
    1767             : #else
    1768             : SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1769             : #endif
    1770             : {
    1771           0 :   SwigPyObject *sobj = (SwigPyObject *) v;
    1772           0 :   if (sobj->next) {    
    1773           0 :     Py_INCREF(sobj->next);
    1774           0 :     return sobj->next;
    1775             :   } else {
    1776           0 :     return SWIG_Py_Void();
    1777             :   }
    1778             : }
    1779             : 
    1780             : SWIGINTERN PyObject*
    1781             : #ifdef METH_NOARGS
    1782           0 : SwigPyObject_disown(PyObject *v)
    1783             : #else
    1784             : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1785             : #endif
    1786             : {
    1787           0 :   SwigPyObject *sobj = (SwigPyObject *)v;
    1788           0 :   sobj->own = 0;
    1789           0 :   return SWIG_Py_Void();
    1790             : }
    1791             : 
    1792             : SWIGINTERN PyObject*
    1793             : #ifdef METH_NOARGS
    1794           0 : SwigPyObject_acquire(PyObject *v)
    1795             : #else
    1796             : SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1797             : #endif
    1798             : {
    1799           0 :   SwigPyObject *sobj = (SwigPyObject *)v;
    1800           0 :   sobj->own = SWIG_POINTER_OWN;
    1801           0 :   return SWIG_Py_Void();
    1802             : }
    1803             : 
    1804             : SWIGINTERN PyObject*
    1805           0 : SwigPyObject_own(PyObject *v, PyObject *args)
    1806             : {
    1807           0 :   PyObject *val = 0;
    1808             : #if (PY_VERSION_HEX < 0x02020000)
    1809             :   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
    1810             : #elif (PY_VERSION_HEX < 0x02050000)
    1811             :   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
    1812             : #else
    1813           0 :   if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
    1814             : #endif
    1815             :     {
    1816             :       return NULL;
    1817             :     } 
    1818             :   else
    1819             :     {
    1820           0 :       SwigPyObject *sobj = (SwigPyObject *)v;
    1821           0 :       PyObject *obj = PyBool_FromLong(sobj->own);
    1822           0 :       if (val) {
    1823             : #ifdef METH_NOARGS
    1824           0 :         if (PyObject_IsTrue(val)) {
    1825             :           SwigPyObject_acquire(v);
    1826             :         } else {
    1827             :           SwigPyObject_disown(v);
    1828             :         }
    1829             : #else
    1830             :         if (PyObject_IsTrue(val)) {
    1831             :           SwigPyObject_acquire(v,args);
    1832             :         } else {
    1833             :           SwigPyObject_disown(v,args);
    1834             :         }
    1835             : #endif
    1836             :       } 
    1837             :       return obj;
    1838             :     }
    1839             : }
    1840             : 
    1841             : #ifdef METH_O
    1842             : static PyMethodDef
    1843             : swigobject_methods[] = {
    1844             :   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
    1845             :   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
    1846             :   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
    1847             :   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
    1848             :   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
    1849             :   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
    1850             :   {0, 0, 0, 0}  
    1851             : };
    1852             : #else
    1853             : static PyMethodDef
    1854             : swigobject_methods[] = {
    1855             :   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
    1856             :   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"acquires ownership of the pointer"},
    1857             :   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
    1858             :   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
    1859             :   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
    1860             :   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
    1861             :   {0, 0, 0, 0}  
    1862             : };
    1863             : #endif
    1864             : 
    1865             : #if PY_VERSION_HEX < 0x02020000
    1866             : SWIGINTERN PyObject *
    1867             : SwigPyObject_getattr(SwigPyObject *sobj,char *name)
    1868             : {
    1869             :   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
    1870             : }
    1871             : #endif
    1872             : 
    1873             : SWIGRUNTIME PyTypeObject*
    1874           3 : SwigPyObject_TypeOnce(void) {
    1875             :   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
    1876             : 
    1877             :   static PyNumberMethods SwigPyObject_as_number = {
    1878             :     (binaryfunc)0, /*nb_add*/
    1879             :     (binaryfunc)0, /*nb_subtract*/
    1880             :     (binaryfunc)0, /*nb_multiply*/
    1881             :     /* nb_divide removed in Python 3 */
    1882             : #if PY_VERSION_HEX < 0x03000000
    1883             :     (binaryfunc)0, /*nb_divide*/
    1884             : #endif
    1885             :     (binaryfunc)0, /*nb_remainder*/
    1886             :     (binaryfunc)0, /*nb_divmod*/
    1887             :     (ternaryfunc)0,/*nb_power*/
    1888             :     (unaryfunc)0,  /*nb_negative*/
    1889             :     (unaryfunc)0,  /*nb_positive*/
    1890             :     (unaryfunc)0,  /*nb_absolute*/
    1891             :     (inquiry)0,    /*nb_nonzero*/
    1892             :     0,             /*nb_invert*/
    1893             :     0,             /*nb_lshift*/
    1894             :     0,             /*nb_rshift*/
    1895             :     0,             /*nb_and*/
    1896             :     0,             /*nb_xor*/
    1897             :     0,             /*nb_or*/
    1898             : #if PY_VERSION_HEX < 0x03000000
    1899             :     0,   /*nb_coerce*/
    1900             : #endif
    1901             :     (unaryfunc)SwigPyObject_long, /*nb_int*/
    1902             : #if PY_VERSION_HEX < 0x03000000
    1903             :     (unaryfunc)SwigPyObject_long, /*nb_long*/
    1904             : #else
    1905             :     0, /*nb_reserved*/
    1906             : #endif
    1907             :     (unaryfunc)0,                 /*nb_float*/
    1908             : #if PY_VERSION_HEX < 0x03000000
    1909             :     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    1910             :     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
    1911             : #endif
    1912             : #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    1913             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
    1914             : #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    1915             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
    1916             : #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
    1917             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
    1918             : #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
    1919             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
    1920             : #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
    1921             :     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
    1922             : #endif
    1923             :   };
    1924             : 
    1925             :   static PyTypeObject swigpyobject_type;
    1926             :   static int type_init = 0;
    1927           3 :   if (!type_init) {
    1928             :     const PyTypeObject tmp = {
    1929             :       /* PyObject header changed in Python 3 */
    1930             : #if PY_VERSION_HEX >= 0x03000000
    1931             :       PyVarObject_HEAD_INIT(NULL, 0)
    1932             : #else
    1933             :       PyObject_HEAD_INIT(NULL)
    1934             :       0,                                    /* ob_size */
    1935             : #endif
    1936             :       (char *)"SwigPyObject",               /* tp_name */
    1937             :       sizeof(SwigPyObject),                 /* tp_basicsize */
    1938             :       0,                                    /* tp_itemsize */
    1939             :       (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
    1940             :       0,                                    /* tp_print */
    1941             : #if PY_VERSION_HEX < 0x02020000
    1942             :       (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
    1943             : #else
    1944             :       (getattrfunc)0,                       /* tp_getattr */
    1945             : #endif
    1946             :       (setattrfunc)0,                       /* tp_setattr */
    1947             : #if PY_VERSION_HEX >= 0x03000000
    1948             :     0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
    1949             : #else
    1950             :       (cmpfunc)SwigPyObject_compare,        /* tp_compare */
    1951             : #endif
    1952             :       (reprfunc)SwigPyObject_repr,          /* tp_repr */
    1953             :       &SwigPyObject_as_number,              /* tp_as_number */
    1954             :       0,                                    /* tp_as_sequence */
    1955             :       0,                                    /* tp_as_mapping */
    1956             :       (hashfunc)0,                          /* tp_hash */
    1957             :       (ternaryfunc)0,                       /* tp_call */
    1958             :       0,                                    /* tp_str */
    1959             :       PyObject_GenericGetAttr,              /* tp_getattro */
    1960             :       0,                                    /* tp_setattro */
    1961             :       0,                                    /* tp_as_buffer */
    1962             :       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
    1963             :       swigobject_doc,                       /* tp_doc */
    1964             :       0,                                    /* tp_traverse */
    1965             :       0,                                    /* tp_clear */
    1966             :       (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
    1967             :       0,                                    /* tp_weaklistoffset */
    1968             : #if PY_VERSION_HEX >= 0x02020000
    1969             :       0,                                    /* tp_iter */
    1970             :       0,                                    /* tp_iternext */
    1971             :       swigobject_methods,                   /* tp_methods */
    1972             :       0,                                    /* tp_members */
    1973             :       0,                                    /* tp_getset */
    1974             :       0,                                    /* tp_base */
    1975             :       0,                                    /* tp_dict */
    1976             :       0,                                    /* tp_descr_get */
    1977             :       0,                                    /* tp_descr_set */
    1978             :       0,                                    /* tp_dictoffset */
    1979             :       0,                                    /* tp_init */
    1980             :       0,                                    /* tp_alloc */
    1981             :       0,                                    /* tp_new */
    1982             :       0,                                    /* tp_free */
    1983             :       0,                                    /* tp_is_gc */
    1984             :       0,                                    /* tp_bases */
    1985             :       0,                                    /* tp_mro */
    1986             :       0,                                    /* tp_cache */
    1987             :       0,                                    /* tp_subclasses */
    1988             :       0,                                    /* tp_weaklist */
    1989             : #endif
    1990             : #if PY_VERSION_HEX >= 0x02030000
    1991             :       0,                                    /* tp_del */
    1992             : #endif
    1993             : #if PY_VERSION_HEX >= 0x02060000
    1994             :       0,                                    /* tp_version_tag */
    1995             : #endif
    1996             : #if PY_VERSION_HEX >= 0x03040000
    1997             :       0,                                    /* tp_finalize */
    1998             : #endif
    1999             : #ifdef COUNT_ALLOCS
    2000             :       0,                                    /* tp_allocs */
    2001             :       0,                                    /* tp_frees */
    2002             :       0,                                    /* tp_maxalloc */
    2003             : #if PY_VERSION_HEX >= 0x02050000
    2004             :       0,                                    /* tp_prev */
    2005             : #endif
    2006             :       0                                     /* tp_next */
    2007             : #endif
    2008           3 :     };
    2009           3 :     swigpyobject_type = tmp;
    2010           3 :     type_init = 1;
    2011             : #if PY_VERSION_HEX < 0x02020000
    2012             :     swigpyobject_type.ob_type = &PyType_Type;
    2013             : #else
    2014           3 :     if (PyType_Ready(&swigpyobject_type) < 0)
    2015           0 :       return NULL;
    2016             : #endif
    2017             :   }
    2018             :   return &swigpyobject_type;
    2019             : }
    2020             : 
    2021             : SWIGRUNTIME PyObject *
    2022         217 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
    2023             : {
    2024         217 :   SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
    2025         217 :   if (sobj) {
    2026         217 :     sobj->ptr  = ptr;
    2027         217 :     sobj->ty   = ty;
    2028         217 :     sobj->own  = own;
    2029         217 :     sobj->next = 0;
    2030             :   }
    2031         217 :   return (PyObject *)sobj;
    2032             : }
    2033             : 
    2034             : /* -----------------------------------------------------------------------------
    2035             :  * Implements a simple Swig Packed type, and use it instead of string
    2036             :  * ----------------------------------------------------------------------------- */
    2037             : 
    2038             : typedef struct {
    2039             :   PyObject_HEAD
    2040             :   void *pack;
    2041             :   swig_type_info *ty;
    2042             :   size_t size;
    2043             : } SwigPyPacked;
    2044             : 
    2045             : SWIGRUNTIME int
    2046           0 : SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
    2047             : {
    2048             :   char result[SWIG_BUFFER_SIZE];
    2049           0 :   fputs("<Swig Packed ", fp); 
    2050           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    2051           0 :     fputs("at ", fp); 
    2052           0 :     fputs(result, fp); 
    2053             :   }
    2054           0 :   fputs(v->ty->name,fp); 
    2055           0 :   fputs(">", fp);
    2056           0 :   return 0; 
    2057             : }
    2058             :   
    2059             : SWIGRUNTIME PyObject *
    2060           0 : SwigPyPacked_repr(SwigPyPacked *v)
    2061             : {
    2062             :   char result[SWIG_BUFFER_SIZE];
    2063           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    2064           0 :     return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
    2065             :   } else {
    2066           0 :     return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
    2067             :   }  
    2068             : }
    2069             : 
    2070             : SWIGRUNTIME PyObject *
    2071           0 : SwigPyPacked_str(SwigPyPacked *v)
    2072             : {
    2073             :   char result[SWIG_BUFFER_SIZE];
    2074           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    2075           0 :     return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
    2076             :   } else {
    2077           0 :     return SWIG_Python_str_FromChar(v->ty->name);
    2078             :   }  
    2079             : }
    2080             : 
    2081             : SWIGRUNTIME int
    2082           0 : SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
    2083             : {
    2084           0 :   size_t i = v->size;
    2085           0 :   size_t j = w->size;
    2086           0 :   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
    2087           0 :   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
    2088             : }
    2089             : 
    2090             : SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
    2091             : 
    2092             : SWIGRUNTIME PyTypeObject*
    2093           0 : SwigPyPacked_type(void) {
    2094           0 :   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
    2095           0 :   return type;
    2096             : }
    2097             : 
    2098             : SWIGRUNTIMEINLINE int
    2099           0 : SwigPyPacked_Check(PyObject *op) {
    2100           0 :   return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
    2101           0 :     || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
    2102             : }
    2103             : 
    2104             : SWIGRUNTIME void
    2105           0 : SwigPyPacked_dealloc(PyObject *v)
    2106             : {
    2107           0 :   if (SwigPyPacked_Check(v)) {
    2108           0 :     SwigPyPacked *sobj = (SwigPyPacked *) v;
    2109           0 :     free(sobj->pack);
    2110             :   }
    2111           0 :   PyObject_DEL(v);
    2112           0 : }
    2113             : 
    2114             : SWIGRUNTIME PyTypeObject*
    2115           0 : SwigPyPacked_TypeOnce(void) {
    2116             :   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
    2117             :   static PyTypeObject swigpypacked_type;
    2118             :   static int type_init = 0;
    2119           0 :   if (!type_init) {
    2120             :     const PyTypeObject tmp = {
    2121             :       /* PyObject header changed in Python 3 */
    2122             : #if PY_VERSION_HEX>=0x03000000
    2123             :       PyVarObject_HEAD_INIT(NULL, 0)
    2124             : #else
    2125             :       PyObject_HEAD_INIT(NULL)
    2126             :       0,                                    /* ob_size */
    2127             : #endif
    2128             :       (char *)"SwigPyPacked",               /* tp_name */
    2129             :       sizeof(SwigPyPacked),                 /* tp_basicsize */
    2130             :       0,                                    /* tp_itemsize */
    2131             :       (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
    2132             :       (printfunc)SwigPyPacked_print,        /* tp_print */
    2133             :       (getattrfunc)0,                       /* tp_getattr */
    2134             :       (setattrfunc)0,                       /* tp_setattr */
    2135             : #if PY_VERSION_HEX>=0x03000000
    2136             :       0, /* tp_reserved in 3.0.1 */
    2137             : #else
    2138             :       (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
    2139             : #endif
    2140             :       (reprfunc)SwigPyPacked_repr,          /* tp_repr */
    2141             :       0,                                    /* tp_as_number */
    2142             :       0,                                    /* tp_as_sequence */
    2143             :       0,                                    /* tp_as_mapping */
    2144             :       (hashfunc)0,                          /* tp_hash */
    2145             :       (ternaryfunc)0,                       /* tp_call */
    2146             :       (reprfunc)SwigPyPacked_str,           /* tp_str */
    2147             :       PyObject_GenericGetAttr,              /* tp_getattro */
    2148             :       0,                                    /* tp_setattro */
    2149             :       0,                                    /* tp_as_buffer */
    2150             :       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
    2151             :       swigpacked_doc,                       /* tp_doc */
    2152             :       0,                                    /* tp_traverse */
    2153             :       0,                                    /* tp_clear */
    2154             :       0,                                    /* tp_richcompare */
    2155             :       0,                                    /* tp_weaklistoffset */
    2156             : #if PY_VERSION_HEX >= 0x02020000
    2157             :       0,                                    /* tp_iter */
    2158             :       0,                                    /* tp_iternext */
    2159             :       0,                                    /* tp_methods */
    2160             :       0,                                    /* tp_members */
    2161             :       0,                                    /* tp_getset */
    2162             :       0,                                    /* tp_base */
    2163             :       0,                                    /* tp_dict */
    2164             :       0,                                    /* tp_descr_get */
    2165             :       0,                                    /* tp_descr_set */
    2166             :       0,                                    /* tp_dictoffset */
    2167             :       0,                                    /* tp_init */
    2168             :       0,                                    /* tp_alloc */
    2169             :       0,                                    /* tp_new */
    2170             :       0,                                    /* tp_free */
    2171             :       0,                                    /* tp_is_gc */
    2172             :       0,                                    /* tp_bases */
    2173             :       0,                                    /* tp_mro */
    2174             :       0,                                    /* tp_cache */
    2175             :       0,                                    /* tp_subclasses */
    2176             :       0,                                    /* tp_weaklist */
    2177             : #endif
    2178             : #if PY_VERSION_HEX >= 0x02030000
    2179             :       0,                                    /* tp_del */
    2180             : #endif
    2181             : #if PY_VERSION_HEX >= 0x02060000
    2182             :       0,                                    /* tp_version_tag */
    2183             : #endif
    2184             : #if PY_VERSION_HEX >= 0x03040000
    2185             :       0,                                    /* tp_finalize */
    2186             : #endif
    2187             : #ifdef COUNT_ALLOCS
    2188             :       0,                                    /* tp_allocs */
    2189             :       0,                                    /* tp_frees */
    2190             :       0,                                    /* tp_maxalloc */
    2191             : #if PY_VERSION_HEX >= 0x02050000
    2192             :       0,                                    /* tp_prev */
    2193             : #endif
    2194             :       0                                     /* tp_next */
    2195             : #endif
    2196           0 :     };
    2197           0 :     swigpypacked_type = tmp;
    2198           0 :     type_init = 1;
    2199             : #if PY_VERSION_HEX < 0x02020000
    2200             :     swigpypacked_type.ob_type = &PyType_Type;
    2201             : #else
    2202           0 :     if (PyType_Ready(&swigpypacked_type) < 0)
    2203           0 :       return NULL;
    2204             : #endif
    2205             :   }
    2206             :   return &swigpypacked_type;
    2207             : }
    2208             : 
    2209             : SWIGRUNTIME PyObject *
    2210           0 : SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
    2211             : {
    2212           0 :   SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
    2213           0 :   if (sobj) {
    2214           0 :     void *pack = malloc(size);
    2215           0 :     if (pack) {
    2216           0 :       memcpy(pack, ptr, size);
    2217           0 :       sobj->pack = pack;
    2218           0 :       sobj->ty   = ty;
    2219           0 :       sobj->size = size;
    2220             :     } else {
    2221           0 :       PyObject_DEL((PyObject *) sobj);
    2222           0 :       sobj = 0;
    2223             :     }
    2224             :   }
    2225           0 :   return (PyObject *) sobj;
    2226             : }
    2227             : 
    2228             : SWIGRUNTIME swig_type_info *
    2229             : SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
    2230             : {
    2231             :   if (SwigPyPacked_Check(obj)) {
    2232             :     SwigPyPacked *sobj = (SwigPyPacked *)obj;
    2233             :     if (sobj->size != size) return 0;
    2234             :     memcpy(ptr, sobj->pack, size);
    2235             :     return sobj->ty;
    2236             :   } else {
    2237             :     return 0;
    2238             :   }
    2239             : }
    2240             : 
    2241             : /* -----------------------------------------------------------------------------
    2242             :  * pointers/data manipulation
    2243             :  * ----------------------------------------------------------------------------- */
    2244             : 
    2245             : SWIGRUNTIMEINLINE PyObject *
    2246             : _SWIG_This(void)
    2247             : {
    2248           3 :     return SWIG_Python_str_FromChar("this");
    2249             : }
    2250             : 
    2251             : static PyObject *swig_this = NULL;
    2252             : 
    2253             : SWIGRUNTIME PyObject *
    2254             : SWIG_This(void)
    2255             : {
    2256         746 :   if (swig_this == NULL)
    2257           3 :     swig_this = _SWIG_This();
    2258         746 :   return swig_this;
    2259             : }
    2260             : 
    2261             : /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
    2262             : 
    2263             : /* TODO: I don't know how to implement the fast getset in Python 3 right now */
    2264             : #if PY_VERSION_HEX>=0x03000000
    2265             : #define SWIG_PYTHON_SLOW_GETSET_THIS 
    2266             : #endif
    2267             : 
    2268             : SWIGRUNTIME SwigPyObject *
    2269         873 : SWIG_Python_GetSwigThis(PyObject *pyobj) 
    2270             : {
    2271             :   PyObject *obj;
    2272             : 
    2273         873 :   if (SwigPyObject_Check(pyobj))
    2274             :     return (SwigPyObject *) pyobj;
    2275             : 
    2276             : #ifdef SWIGPYTHON_BUILTIN
    2277             :   (void)obj;
    2278             : # ifdef PyWeakref_CheckProxy
    2279             :   if (PyWeakref_CheckProxy(pyobj)) {
    2280             :     pyobj = PyWeakref_GET_OBJECT(pyobj);
    2281             :     if (pyobj && SwigPyObject_Check(pyobj))
    2282             :       return (SwigPyObject*) pyobj;
    2283             :   }
    2284             : # endif
    2285             :   return NULL;
    2286             : #else
    2287             : 
    2288         671 :   obj = 0;
    2289             : 
    2290             : #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
    2291         671 :   if (PyInstance_Check(pyobj)) {
    2292           0 :     obj = _PyInstance_Lookup(pyobj, SWIG_This());      
    2293             :   } else {
    2294         671 :     PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    2295         671 :     if (dictptr != NULL) {
    2296         615 :       PyObject *dict = *dictptr;
    2297        1089 :       obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    2298             :     } else {
    2299             : #ifdef PyWeakref_CheckProxy
    2300          56 :       if (PyWeakref_CheckProxy(pyobj)) {
    2301           0 :         PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
    2302           0 :         return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
    2303             :       }
    2304             : #endif
    2305          56 :       obj = PyObject_GetAttr(pyobj,SWIG_This());
    2306          56 :       if (obj) {
    2307           0 :         Py_DECREF(obj);
    2308             :       } else {
    2309          56 :         if (PyErr_Occurred()) PyErr_Clear();
    2310             :         return 0;
    2311             :       }
    2312             :     }
    2313             :   }
    2314             : #else
    2315             :   obj = PyObject_GetAttr(pyobj,SWIG_This());
    2316             :   if (obj) {
    2317             :     Py_DECREF(obj);
    2318             :   } else {
    2319             :     if (PyErr_Occurred()) PyErr_Clear();
    2320             :     return 0;
    2321             :   }
    2322             : #endif
    2323         615 :   if (obj && !SwigPyObject_Check(obj)) {
    2324             :     /* a PyObject is called 'this', try to get the 'real this'
    2325             :        SwigPyObject from it */ 
    2326             :     return SWIG_Python_GetSwigThis(obj);
    2327             :   }
    2328             :   return (SwigPyObject *)obj;
    2329             : #endif
    2330             : }
    2331             : 
    2332             : /* Acquire a pointer value */
    2333             : 
    2334             : SWIGRUNTIME int
    2335             : SWIG_Python_AcquirePtr(PyObject *obj, int own) {
    2336             :   if (own == SWIG_POINTER_OWN) {
    2337             :     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    2338             :     if (sobj) {
    2339             :       int oldown = sobj->own;
    2340             :       sobj->own = own;
    2341             :       return oldown;
    2342             :     }
    2343             :   }
    2344             :   return 0;
    2345             : }
    2346             : 
    2347             : /* Convert a pointer value */
    2348             : 
    2349             : SWIGRUNTIME int
    2350         732 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
    2351             :   int res;
    2352             :   SwigPyObject *sobj;
    2353         732 :   int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
    2354             : 
    2355         732 :   if (!obj)
    2356             :     return SWIG_ERROR;
    2357         732 :   if (obj == Py_None && !implicit_conv) {
    2358           0 :     if (ptr)
    2359           0 :       *ptr = 0;
    2360             :     return SWIG_OK;
    2361             :   }
    2362             : 
    2363         732 :   res = SWIG_ERROR;
    2364             : 
    2365         732 :   sobj = SWIG_Python_GetSwigThis(obj);
    2366         732 :   if (own)
    2367           0 :     *own = 0;
    2368         735 :   while (sobj) {
    2369         676 :     void *vptr = sobj->ptr;
    2370         676 :     if (ty) {
    2371         676 :       swig_type_info *to = sobj->ty;
    2372         676 :       if (to == ty) {
    2373             :         /* no type cast needed */
    2374         673 :         if (ptr) *ptr = vptr;
    2375             :         break;
    2376             :       } else {
    2377           3 :         swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
    2378           3 :         if (!tc) {
    2379           3 :           sobj = (SwigPyObject *)sobj->next;
    2380             :         } else {
    2381           0 :           if (ptr) {
    2382           0 :             int newmemory = 0;
    2383           0 :             *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
    2384           0 :             if (newmemory == SWIG_CAST_NEW_MEMORY) {
    2385             :               assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
    2386           0 :               if (own)
    2387           0 :                 *own = *own | SWIG_CAST_NEW_MEMORY;
    2388             :             }
    2389             :           }
    2390             :           break;
    2391             :         }
    2392             :       }
    2393             :     } else {
    2394           0 :       if (ptr) *ptr = vptr;
    2395             :       break;
    2396             :     }
    2397             :   }
    2398         732 :   if (sobj) {
    2399         673 :     if (own)
    2400           0 :       *own = *own | sobj->own;
    2401         673 :     if (flags & SWIG_POINTER_DISOWN) {
    2402         198 :       sobj->own = 0;
    2403             :     }
    2404             :     res = SWIG_OK;
    2405             :   } else {
    2406          59 :     if (implicit_conv) {
    2407           0 :       SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    2408           0 :       if (data && !data->implicitconv) {
    2409           0 :         PyObject *klass = data->klass;
    2410           0 :         if (klass) {
    2411             :           PyObject *impconv;
    2412           0 :           data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
    2413           0 :           impconv = SWIG_Python_CallFunctor(klass, obj);
    2414           0 :           data->implicitconv = 0;
    2415           0 :           if (PyErr_Occurred()) {
    2416           0 :             PyErr_Clear();
    2417           0 :             impconv = 0;
    2418             :           }
    2419           0 :           if (impconv) {
    2420           0 :             SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
    2421           0 :             if (iobj) {
    2422             :               void *vptr;
    2423           0 :               res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
    2424           0 :               if (SWIG_IsOK(res)) {
    2425           0 :                 if (ptr) {
    2426           0 :                   *ptr = vptr;
    2427             :                   /* transfer the ownership to 'ptr' */
    2428           0 :                   iobj->own = 0;
    2429           0 :                   res = SWIG_AddCast(res);
    2430           0 :                   res = SWIG_AddNewMask(res);
    2431             :                 } else {
    2432             :                   res = SWIG_AddCast(res);                  
    2433             :                 }
    2434             :               }
    2435             :             }
    2436           0 :             Py_DECREF(impconv);
    2437             :           }
    2438             :         }
    2439             :       }
    2440             :     }
    2441          59 :     if (!SWIG_IsOK(res) && obj == Py_None) {
    2442           0 :       if (ptr)
    2443           0 :         *ptr = 0;
    2444           0 :       if (PyErr_Occurred())
    2445           0 :         PyErr_Clear();
    2446             :       res = SWIG_OK;
    2447             :     }
    2448             :   }
    2449             :   return res;
    2450             : }
    2451             : 
    2452             : /* Convert a function ptr value */
    2453             : 
    2454             : SWIGRUNTIME int
    2455           0 : SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
    2456           0 :   if (!PyCFunction_Check(obj)) {
    2457           0 :     return SWIG_ConvertPtr(obj, ptr, ty, 0);
    2458             :   } else {
    2459           0 :     void *vptr = 0;
    2460             :     
    2461             :     /* here we get the method pointer for callbacks */
    2462           0 :     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
    2463           0 :     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    2464           0 :     if (desc)
    2465           0 :       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
    2466           0 :     if (!desc) 
    2467             :       return SWIG_ERROR;
    2468           0 :     if (ty) {
    2469           0 :       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
    2470           0 :       if (tc) {
    2471           0 :         int newmemory = 0;
    2472           0 :         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
    2473             :         assert(!newmemory); /* newmemory handling not yet implemented */
    2474             :       } else {
    2475             :         return SWIG_ERROR;
    2476             :       }
    2477             :     } else {
    2478           0 :       *ptr = vptr;
    2479             :     }
    2480             :     return SWIG_OK;
    2481             :   }
    2482             : }
    2483             : 
    2484             : /* Convert a packed value value */
    2485             : 
    2486             : SWIGRUNTIME int
    2487             : SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
    2488             :   swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
    2489             :   if (!to) return SWIG_ERROR;
    2490             :   if (ty) {
    2491             :     if (to != ty) {
    2492             :       /* check type cast? */
    2493             :       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
    2494             :       if (!tc) return SWIG_ERROR;
    2495             :     }
    2496             :   }
    2497             :   return SWIG_OK;
    2498             : }  
    2499             : 
    2500             : /* -----------------------------------------------------------------------------
    2501             :  * Create a new pointer object
    2502             :  * ----------------------------------------------------------------------------- */
    2503             : 
    2504             : /*
    2505             :   Create a new instance object, without calling __init__, and set the
    2506             :   'this' attribute.
    2507             : */
    2508             : 
    2509             : SWIGRUNTIME PyObject* 
    2510          70 : SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
    2511             : {
    2512             : #if (PY_VERSION_HEX >= 0x02020000)
    2513          70 :   PyObject *inst = 0;
    2514          70 :   PyObject *newraw = data->newraw;
    2515          70 :   if (newraw) {
    2516          70 :     inst = PyObject_Call(newraw, data->newargs, NULL);
    2517          70 :     if (inst) {
    2518             : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
    2519          70 :       PyObject **dictptr = _PyObject_GetDictPtr(inst);
    2520          70 :       if (dictptr != NULL) {
    2521          70 :         PyObject *dict = *dictptr;
    2522          70 :         if (dict == NULL) {
    2523          70 :           dict = PyDict_New();
    2524          70 :           *dictptr = dict;
    2525          70 :           PyDict_SetItem(dict, SWIG_This(), swig_this);
    2526             :         }
    2527             :       }
    2528             : #else
    2529             :       PyObject *key = SWIG_This();
    2530             :       PyObject_SetAttr(inst, key, swig_this);
    2531             : #endif
    2532             :     }
    2533             :   } else {
    2534             : #if PY_VERSION_HEX >= 0x03000000
    2535             :     inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
    2536             :     if (inst) {
    2537             :       PyObject_SetAttr(inst, SWIG_This(), swig_this);
    2538             :       Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
    2539             :     }
    2540             : #else
    2541           0 :     PyObject *dict = PyDict_New();
    2542           0 :     if (dict) {
    2543           0 :       PyDict_SetItem(dict, SWIG_This(), swig_this);
    2544           0 :       inst = PyInstance_NewRaw(data->newargs, dict);
    2545           0 :       Py_DECREF(dict);
    2546             :     }
    2547             : #endif
    2548             :   }
    2549          70 :   return inst;
    2550             : #else
    2551             : #if (PY_VERSION_HEX >= 0x02010000)
    2552             :   PyObject *inst = 0;
    2553             :   PyObject *dict = PyDict_New();
    2554             :   if (dict) {
    2555             :     PyDict_SetItem(dict, SWIG_This(), swig_this);
    2556             :     inst = PyInstance_NewRaw(data->newargs, dict);
    2557             :     Py_DECREF(dict);
    2558             :   }
    2559             :   return (PyObject *) inst;
    2560             : #else
    2561             :   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
    2562             :   if (inst == NULL) {
    2563             :     return NULL;
    2564             :   }
    2565             :   inst->in_class = (PyClassObject *)data->newargs;
    2566             :   Py_INCREF(inst->in_class);
    2567             :   inst->in_dict = PyDict_New();
    2568             :   if (inst->in_dict == NULL) {
    2569             :     Py_DECREF(inst);
    2570             :     return NULL;
    2571             :   }
    2572             : #ifdef Py_TPFLAGS_HAVE_WEAKREFS
    2573             :   inst->in_weakreflist = NULL;
    2574             : #endif
    2575             : #ifdef Py_TPFLAGS_GC
    2576             :   PyObject_GC_Init(inst);
    2577             : #endif
    2578             :   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
    2579             :   return (PyObject *) inst;
    2580             : #endif
    2581             : #endif
    2582             : }
    2583             : 
    2584             : SWIGRUNTIME void
    2585         141 : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
    2586             : {
    2587             :  PyObject *dict;
    2588             : #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
    2589         141 :  PyObject **dictptr = _PyObject_GetDictPtr(inst);
    2590         141 :  if (dictptr != NULL) {
    2591         141 :    dict = *dictptr;
    2592         141 :    if (dict == NULL) {
    2593         141 :      dict = PyDict_New();
    2594         141 :      *dictptr = dict;
    2595             :    }
    2596         141 :    PyDict_SetItem(dict, SWIG_This(), swig_this);
    2597         141 :    return;
    2598             :  }
    2599             : #endif
    2600           0 :  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
    2601           0 :  PyDict_SetItem(dict, SWIG_This(), swig_this);
    2602           0 :  Py_DECREF(dict);
    2603             : } 
    2604             : 
    2605             : 
    2606             : SWIGINTERN PyObject *
    2607         141 : SWIG_Python_InitShadowInstance(PyObject *args) {
    2608             :   PyObject *obj[2];
    2609         141 :   if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    2610             :     return NULL;
    2611             :   } else {
    2612         141 :     SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    2613         141 :     if (sthis) {
    2614           0 :       SwigPyObject_append((PyObject*) sthis, obj[1]);
    2615             :     } else {
    2616         141 :       SWIG_Python_SetSwigThis(obj[0], obj[1]);
    2617             :     }
    2618         141 :     return SWIG_Py_Void();
    2619             :   }
    2620             : }
    2621             : 
    2622             : /* Create a new pointer object */
    2623             : 
    2624             : SWIGRUNTIME PyObject *
    2625         217 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
    2626             :   SwigPyClientData *clientdata;
    2627             :   PyObject * robj;
    2628             :   int own;
    2629             : 
    2630         217 :   if (!ptr)
    2631           0 :     return SWIG_Py_Void();
    2632             : 
    2633         217 :   clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
    2634         217 :   own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
    2635         217 :   if (clientdata && clientdata->pytype) {
    2636             :     SwigPyObject *newobj;
    2637           0 :     if (flags & SWIG_BUILTIN_TP_INIT) {
    2638           0 :       newobj = (SwigPyObject*) self;
    2639           0 :       if (newobj->ptr) {
    2640           0 :         PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
    2641           0 :         while (newobj->next)
    2642             :           newobj = (SwigPyObject *) newobj->next;
    2643           0 :         newobj->next = next_self;
    2644           0 :         newobj = (SwigPyObject *)next_self;
    2645             : #ifdef SWIGPYTHON_BUILTIN
    2646             :         newobj->dict = 0;
    2647             : #endif
    2648             :       }
    2649             :     } else {
    2650           0 :       newobj = PyObject_New(SwigPyObject, clientdata->pytype);
    2651             : #ifdef SWIGPYTHON_BUILTIN
    2652             :       newobj->dict = 0;
    2653             : #endif
    2654             :     }
    2655           0 :     if (newobj) {
    2656           0 :       newobj->ptr = ptr;
    2657           0 :       newobj->ty = type;
    2658           0 :       newobj->own = own;
    2659           0 :       newobj->next = 0;
    2660           0 :       return (PyObject*) newobj;
    2661             :     }
    2662           0 :     return SWIG_Py_Void();
    2663             :   }
    2664             : 
    2665             :   assert(!(flags & SWIG_BUILTIN_TP_INIT));
    2666             : 
    2667         217 :   robj = SwigPyObject_New(ptr, type, own);
    2668         217 :   if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    2669          70 :     PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    2670          70 :     Py_DECREF(robj);
    2671             :     robj = inst;
    2672             :   }
    2673             :   return robj;
    2674             : }
    2675             : 
    2676             : /* Create a new packed object */
    2677             : 
    2678             : SWIGRUNTIMEINLINE PyObject *
    2679             : SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
    2680           0 :   return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
    2681             : }
    2682             : 
    2683             : /* -----------------------------------------------------------------------------*
    2684             :  *  Get type list 
    2685             :  * -----------------------------------------------------------------------------*/
    2686             : 
    2687             : #ifdef SWIG_LINK_RUNTIME
    2688             : void *SWIG_ReturnGlobalTypeList(void *);
    2689             : #endif
    2690             : 
    2691             : SWIGRUNTIME swig_module_info *
    2692           4 : SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
    2693             :   static void *type_pointer = (void *)0;
    2694             :   /* first check if module already created */
    2695           4 :   if (!type_pointer) {
    2696             : #ifdef SWIG_LINK_RUNTIME
    2697             :     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
    2698             : #else
    2699             : # ifdef SWIGPY_USE_CAPSULE
    2700           4 :     type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
    2701             : # else
    2702             :     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
    2703             :                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
    2704             : # endif
    2705           4 :     if (PyErr_Occurred()) {
    2706           3 :       PyErr_Clear();
    2707           3 :       type_pointer = (void *)0;
    2708             :     }
    2709             : #endif
    2710             :   }
    2711           4 :   return (swig_module_info *) type_pointer;
    2712             : }
    2713             : 
    2714             : #if PY_MAJOR_VERSION < 2
    2715             : /* PyModule_AddObject function was introduced in Python 2.0.  The following function
    2716             :    is copied out of Python/modsupport.c in python version 2.3.4 */
    2717             : SWIGINTERN int
    2718             : PyModule_AddObject(PyObject *m, char *name, PyObject *o)
    2719             : {
    2720             :   PyObject *dict;
    2721             :   if (!PyModule_Check(m)) {
    2722             :     PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
    2723             :     return SWIG_ERROR;
    2724             :   }
    2725             :   if (!o) {
    2726             :     PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
    2727             :     return SWIG_ERROR;
    2728             :   }
    2729             :   
    2730             :   dict = PyModule_GetDict(m);
    2731             :   if (dict == NULL) {
    2732             :     /* Internal error -- modules must have a dict! */
    2733             :     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
    2734             :                  PyModule_GetName(m));
    2735             :     return SWIG_ERROR;
    2736             :   }
    2737             :   if (PyDict_SetItemString(dict, name, o))
    2738             :     return SWIG_ERROR;
    2739             :   Py_DECREF(o);
    2740             :   return SWIG_OK;
    2741             : }
    2742             : #endif
    2743             : 
    2744             : SWIGRUNTIME void
    2745             : #ifdef SWIGPY_USE_CAPSULE
    2746           3 : SWIG_Python_DestroyModule(PyObject *obj)
    2747             : #else
    2748             : SWIG_Python_DestroyModule(void *vptr)
    2749             : #endif
    2750             : {
    2751             : #ifdef SWIGPY_USE_CAPSULE
    2752           3 :   swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
    2753             : #else
    2754             :   swig_module_info *swig_module = (swig_module_info *) vptr;
    2755             : #endif
    2756           3 :   swig_type_info **types = swig_module->types;
    2757             :   size_t i;
    2758          96 :   for (i =0; i < swig_module->size; ++i) {
    2759          93 :     swig_type_info *ty = types[i];
    2760          93 :     if (ty->owndata) {
    2761          36 :       SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
    2762          36 :       if (data) SwigPyClientData_Del(data);
    2763             :     }
    2764             :   }
    2765           5 :   Py_DECREF(SWIG_This());
    2766           3 :   swig_this = NULL;
    2767           3 : }
    2768             : 
    2769             : SWIGRUNTIME void
    2770           3 : SWIG_Python_SetModule(swig_module_info *swig_module) {
    2771             : #if PY_VERSION_HEX >= 0x03000000
    2772             :  /* Add a dummy module object into sys.modules */
    2773             :   PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
    2774             : #else
    2775             :   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
    2776           3 :   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
    2777             : #endif
    2778             : #ifdef SWIGPY_USE_CAPSULE
    2779           3 :   PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
    2780           3 :   if (pointer && module) {
    2781           3 :     PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
    2782             :   } else {
    2783           0 :     Py_XDECREF(pointer);
    2784             :   }
    2785             : #else
    2786             :   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
    2787             :   if (pointer && module) {
    2788             :     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
    2789             :   } else {
    2790             :     Py_XDECREF(pointer);
    2791             :   }
    2792             : #endif
    2793           3 : }
    2794             : 
    2795             : /* The python cached type query */
    2796             : SWIGRUNTIME PyObject *
    2797           1 : SWIG_Python_TypeCache(void) {
    2798           1 :   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
    2799           1 :   return cache;
    2800             : }
    2801             : 
    2802             : SWIGRUNTIME swig_type_info *
    2803           1 : SWIG_Python_TypeQuery(const char *type)
    2804             : {
    2805           1 :   PyObject *cache = SWIG_Python_TypeCache();
    2806           1 :   PyObject *key = SWIG_Python_str_FromChar(type); 
    2807           1 :   PyObject *obj = PyDict_GetItem(cache, key);
    2808             :   swig_type_info *descriptor;
    2809           1 :   if (obj) {
    2810             : #ifdef SWIGPY_USE_CAPSULE
    2811           0 :     descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
    2812             : #else
    2813             :     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
    2814             : #endif
    2815             :   } else {
    2816           1 :     swig_module_info *swig_module = SWIG_GetModule(0);
    2817           1 :     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    2818           1 :     if (descriptor) {
    2819             : #ifdef SWIGPY_USE_CAPSULE
    2820           1 :       obj = PyCapsule_New((void*) descriptor, NULL, NULL);
    2821             : #else
    2822             :       obj = PyCObject_FromVoidPtr(descriptor, NULL);
    2823             : #endif
    2824           1 :       PyDict_SetItem(cache, key, obj);
    2825           1 :       Py_DECREF(obj);
    2826             :     }
    2827             :   }
    2828           1 :   Py_DECREF(key);
    2829           1 :   return descriptor;
    2830             : }
    2831             : 
    2832             : /* 
    2833             :    For backward compatibility only
    2834             : */
    2835             : #define SWIG_POINTER_EXCEPTION  0
    2836             : #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
    2837             : #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
    2838             : 
    2839             : SWIGRUNTIME int
    2840             : SWIG_Python_AddErrMesg(const char* mesg, int infront)
    2841             : {  
    2842             :   if (PyErr_Occurred()) {
    2843             :     PyObject *type = 0;
    2844             :     PyObject *value = 0;
    2845             :     PyObject *traceback = 0;
    2846             :     PyErr_Fetch(&type, &value, &traceback);
    2847             :     if (value) {
    2848             :       char *tmp;
    2849             :       PyObject *old_str = PyObject_Str(value);
    2850             :       Py_XINCREF(type);
    2851             :       PyErr_Clear();
    2852             :       if (infront) {
    2853             :         PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
    2854             :       } else {
    2855             :         PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    2856             :       }
    2857             :       SWIG_Python_str_DelForPy3(tmp);
    2858             :       Py_DECREF(old_str);
    2859             :     }
    2860             :     return 1;
    2861             :   } else {
    2862             :     return 0;
    2863             :   }
    2864             : }
    2865             :   
    2866             : SWIGRUNTIME int
    2867             : SWIG_Python_ArgFail(int argnum)
    2868             : {
    2869             :   if (PyErr_Occurred()) {
    2870             :     /* add information about failing argument */
    2871             :     char mesg[256];
    2872             :     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    2873             :     return SWIG_Python_AddErrMesg(mesg, 1);
    2874             :   } else {
    2875             :     return 0;
    2876             :   }
    2877             : }
    2878             : 
    2879             : SWIGRUNTIMEINLINE const char *
    2880             : SwigPyObject_GetDesc(PyObject *self)
    2881             : {
    2882             :   SwigPyObject *v = (SwigPyObject *)self;
    2883             :   swig_type_info *ty = v ? v->ty : 0;
    2884             :   return ty ? ty->str : "";
    2885             : }
    2886             : 
    2887             : SWIGRUNTIME void
    2888             : SWIG_Python_TypeError(const char *type, PyObject *obj)
    2889             : {
    2890             :   if (type) {
    2891             : #if defined(SWIG_COBJECT_TYPES)
    2892             :     if (obj && SwigPyObject_Check(obj)) {
    2893             :       const char *otype = (const char *) SwigPyObject_GetDesc(obj);
    2894             :       if (otype) {
    2895             :         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
    2896             :                      type, otype);
    2897             :         return;
    2898             :       }
    2899             :     } else 
    2900             : #endif      
    2901             :     {
    2902             :       const char *otype = (obj ? obj->ob_type->tp_name : 0); 
    2903             :       if (otype) {
    2904             :         PyObject *str = PyObject_Str(obj);
    2905             :         const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
    2906             :         if (cstr) {
    2907             :           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
    2908             :                        type, otype, cstr);
    2909             :           SWIG_Python_str_DelForPy3(cstr);
    2910             :         } else {
    2911             :           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
    2912             :                        type, otype);
    2913             :         }
    2914             :         Py_XDECREF(str);
    2915             :         return;
    2916             :       }
    2917             :     }   
    2918             :     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
    2919             :   } else {
    2920             :     PyErr_Format(PyExc_TypeError, "unexpected type is received");
    2921             :   }
    2922             : }
    2923             : 
    2924             : 
    2925             : /* Convert a pointer value, signal an exception on a type mismatch */
    2926             : SWIGRUNTIME void *
    2927             : SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
    2928             :   void *result;
    2929             :   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    2930             :     PyErr_Clear();
    2931             : #if SWIG_POINTER_EXCEPTION
    2932             :     if (flags) {
    2933             :       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
    2934             :       SWIG_Python_ArgFail(argnum);
    2935             :     }
    2936             : #endif
    2937             :   }
    2938             :   return result;
    2939             : }
    2940             : 
    2941             : #ifdef SWIGPYTHON_BUILTIN
    2942             : SWIGRUNTIME int
    2943             : SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
    2944             :   PyTypeObject *tp = obj->ob_type;
    2945             :   PyObject *descr;
    2946             :   PyObject *encoded_name;
    2947             :   descrsetfunc f;
    2948             :   int res = -1;
    2949             : 
    2950             : # ifdef Py_USING_UNICODE
    2951             :   if (PyString_Check(name)) {
    2952             :     name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    2953             :     if (!name)
    2954             :       return -1;
    2955             :   } else if (!PyUnicode_Check(name))
    2956             : # else
    2957             :   if (!PyString_Check(name))
    2958             : # endif
    2959             :   {
    2960             :     PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    2961             :     return -1;
    2962             :   } else {
    2963             :     Py_INCREF(name);
    2964             :   }
    2965             : 
    2966             :   if (!tp->tp_dict) {
    2967             :     if (PyType_Ready(tp) < 0)
    2968             :       goto done;
    2969             :   }
    2970             : 
    2971             :   descr = _PyType_Lookup(tp, name);
    2972             :   f = NULL;
    2973             :   if (descr != NULL)
    2974             :     f = descr->ob_type->tp_descr_set;
    2975             :   if (!f) {
    2976             :     if (PyString_Check(name)) {
    2977             :       encoded_name = name;
    2978             :       Py_INCREF(name);
    2979             :     } else {
    2980             :       encoded_name = PyUnicode_AsUTF8String(name);
    2981             :     }
    2982             :     PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    2983             :     Py_DECREF(encoded_name);
    2984             :   } else {
    2985             :     res = f(descr, obj, value);
    2986             :   }
    2987             :   
    2988             :   done:
    2989             :   Py_DECREF(name);
    2990             :   return res;
    2991             : }
    2992             : #endif
    2993             : 
    2994             : 
    2995             : #ifdef __cplusplus
    2996             : }
    2997             : #endif
    2998             : 
    2999             : 
    3000             : 
    3001             : #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
    3002             : 
    3003             : #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
    3004             : 
    3005             : 
    3006             : 
    3007             :   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 
    3008             : 
    3009             : 
    3010             : /* -------- TYPES TABLE (BEGIN) -------- */
    3011             : 
    3012             : #define SWIGTYPE_p_Key swig_types[0]
    3013             : #define SWIGTYPE_p__Key swig_types[1]
    3014             : #define SWIGTYPE_p__KeySet swig_types[2]
    3015             : #define SWIGTYPE_p_char swig_types[3]
    3016             : #define SWIGTYPE_p_f___void swig_types[4]
    3017             : #define SWIGTYPE_p_f_p__KeySet_p__Key_p__Key_option_t__p__Key swig_types[5]
    3018             : #define SWIGTYPE_p_int swig_types[6]
    3019             : #define SWIGTYPE_p_kdb__ContractException swig_types[7]
    3020             : #define SWIGTYPE_p_kdb__Exception swig_types[8]
    3021             : #define SWIGTYPE_p_kdb__KDB swig_types[9]
    3022             : #define SWIGTYPE_p_kdb__KDBException swig_types[10]
    3023             : #define SWIGTYPE_p_kdb__Key swig_types[11]
    3024             : #define SWIGTYPE_p_kdb__KeyException swig_types[12]
    3025             : #define SWIGTYPE_p_kdb__KeyInvalidName swig_types[13]
    3026             : #define SWIGTYPE_p_kdb__KeyNotFoundException swig_types[14]
    3027             : #define SWIGTYPE_p_kdb__KeySet swig_types[15]
    3028             : #define SWIGTYPE_p_kdb__KeyTypeConversion swig_types[16]
    3029             : #define SWIGTYPE_p_kdb__KeyTypeMismatch swig_types[17]
    3030             : #define SWIGTYPE_p_long_long swig_types[18]
    3031             : #define SWIGTYPE_p_option_t swig_types[19]
    3032             : #define SWIGTYPE_p_p_PyObject swig_types[20]
    3033             : #define SWIGTYPE_p_short swig_types[21]
    3034             : #define SWIGTYPE_p_signed_char swig_types[22]
    3035             : #define SWIGTYPE_p_std__exception swig_types[23]
    3036             : #define SWIGTYPE_p_std__invalid_argument swig_types[24]
    3037             : #define SWIGTYPE_p_swig__SwigPyIterator swig_types[25]
    3038             : #define SWIGTYPE_p_unsigned_char swig_types[26]
    3039             : #define SWIGTYPE_p_unsigned_int swig_types[27]
    3040             : #define SWIGTYPE_p_unsigned_long_long swig_types[28]
    3041             : #define SWIGTYPE_p_unsigned_short swig_types[29]
    3042             : #define SWIGTYPE_p_void swig_types[30]
    3043             : static swig_type_info *swig_types[32];
    3044             : static swig_module_info swig_module = {swig_types, 31, 0, 0, 0, 0};
    3045             : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
    3046             : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
    3047             : 
    3048             : /* -------- TYPES TABLE (END) -------- */
    3049             : 
    3050             : #if (PY_VERSION_HEX <= 0x02000000)
    3051             : # if !defined(SWIG_PYTHON_CLASSIC)
    3052             : #  error "This python version requires swig to be run with the '-classic' option"
    3053             : # endif
    3054             : #endif
    3055             : #if (PY_VERSION_HEX <= 0x02020000)
    3056             : # error "This python version requires swig to be run with the '-nomodern' option"
    3057             : #endif
    3058             : #if (PY_VERSION_HEX <= 0x02020000)
    3059             : # error "This python version requires swig to be run with the '-nomodernargs' option"
    3060             : #endif
    3061             : #ifndef METH_O
    3062             : # error "This python version requires swig to be run with the '-nofastunpack' option"
    3063             : #endif
    3064             : #ifdef SWIG_TypeQuery
    3065             : # undef SWIG_TypeQuery
    3066             : #endif
    3067             : #define SWIG_TypeQuery SWIG_Python_TypeQuery
    3068             : 
    3069             : /*-----------------------------------------------
    3070             :               @(target):= _kdb.so
    3071             :   ------------------------------------------------*/
    3072             : #if PY_VERSION_HEX >= 0x03000000
    3073             : #  define SWIG_init    PyInit__kdb
    3074             : 
    3075             : #else
    3076             : #  define SWIG_init    init_kdb
    3077             : 
    3078             : #endif
    3079             : #define SWIG_name    "_kdb"
    3080             : 
    3081             : #define SWIGVERSION 0x030010 
    3082             : #define SWIG_VERSION SWIGVERSION
    3083             : 
    3084             : 
    3085             : #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
    3086             : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
    3087             : 
    3088             : 
    3089             : #include <stdexcept>
    3090             : 
    3091             : 
    3092             : namespace swig {
    3093             :   class SwigPtr_PyObject {
    3094             :   protected:
    3095             :     PyObject *_obj;
    3096             : 
    3097             :   public:
    3098             :     SwigPtr_PyObject() :_obj(0)
    3099             :     {
    3100             :     }
    3101             : 
    3102           0 :     SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    3103             :     {
    3104             :       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3105           0 :       Py_XINCREF(_obj);      
    3106             :       SWIG_PYTHON_THREAD_END_BLOCK;
    3107             :     }
    3108             :     
    3109           7 :     SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    3110             :     {
    3111             :       if (initial_ref) {
    3112             :         SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3113           7 :         Py_XINCREF(_obj);
    3114             :         SWIG_PYTHON_THREAD_END_BLOCK;
    3115             :       }
    3116             :     }
    3117             :     
    3118             :     SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    3119             :     {
    3120             :       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3121             :       Py_XINCREF(item._obj);
    3122             :       Py_XDECREF(_obj);
    3123             :       _obj = item._obj;
    3124             :       SWIG_PYTHON_THREAD_END_BLOCK;
    3125             :       return *this;      
    3126             :     }
    3127             :     
    3128             :     ~SwigPtr_PyObject() 
    3129             :     {
    3130             :       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3131           0 :       Py_XDECREF(_obj);
    3132             :       SWIG_PYTHON_THREAD_END_BLOCK;
    3133             :     }
    3134             :     
    3135             :     operator PyObject *() const
    3136             :     {
    3137             :       return _obj;
    3138             :     }
    3139             : 
    3140             :     PyObject *operator->() const
    3141             :     {
    3142             :       return _obj;
    3143             :     }
    3144             :   };
    3145             : }
    3146             : 
    3147             : 
    3148             : namespace swig {
    3149             :   struct SwigVar_PyObject : SwigPtr_PyObject {
    3150             :     SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    3151             :     
    3152             :     SwigVar_PyObject & operator = (PyObject* obj)
    3153             :     {
    3154             :       Py_XDECREF(_obj);
    3155             :       _obj = obj;
    3156             :       return *this;      
    3157             :     }
    3158             :   };
    3159             : }
    3160             : 
    3161             : 
    3162             : #include <stdexcept>
    3163             : 
    3164             : 
    3165             : #if defined(__GNUC__)
    3166             : #  if __GNUC__ == 2 && __GNUC_MINOR <= 96
    3167             : #     define SWIG_STD_NOMODERN_STL
    3168             : #  endif
    3169             : #endif
    3170             : 
    3171             : 
    3172             : #include <string>
    3173             : 
    3174             : 
    3175             : #include <stddef.h>
    3176             : 
    3177             : 
    3178             : #include <iostream>
    3179             : 
    3180             : #if PY_VERSION_HEX >= 0x03020000
    3181             : # define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
    3182             : #else
    3183             : # define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
    3184             : #endif
    3185             : 
    3186             : 
    3187             : namespace swig {
    3188             :   struct stop_iteration {
    3189             :   };
    3190             : 
    3191           0 :   struct SwigPyIterator {
    3192             :   private:
    3193             :     SwigPtr_PyObject _seq;
    3194             : 
    3195             :   protected:
    3196          14 :     SwigPyIterator(PyObject *seq) : _seq(seq)
    3197             :     {
    3198             :     }
    3199             :       
    3200             :   public:
    3201           0 :     virtual ~SwigPyIterator() {}
    3202             : 
    3203             :     // Access iterator method, required by Python
    3204             :     virtual PyObject *value() const = 0;
    3205             : 
    3206             :     // Forward iterator method, required by Python
    3207             :     virtual SwigPyIterator *incr(size_t n = 1) = 0;
    3208             :     
    3209             :     // Backward iterator method, very common in C++, but not required in Python
    3210           0 :     virtual SwigPyIterator *decr(size_t /*n*/ = 1)
    3211             :     {
    3212           0 :       throw stop_iteration();
    3213             :     }
    3214             : 
    3215             :     // Random access iterator methods, but not required in Python
    3216           0 :     virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
    3217             :     {
    3218           0 :       throw std::invalid_argument("operation not supported");
    3219             :     }
    3220             : 
    3221           0 :     virtual bool equal (const SwigPyIterator &/*x*/) const
    3222             :     {
    3223           0 :       throw std::invalid_argument("operation not supported");
    3224             :     }
    3225             :     
    3226             :     // C++ common/needed methods
    3227             :     virtual SwigPyIterator *copy() const = 0;
    3228             : 
    3229             :     PyObject *next()     
    3230             :     {
    3231             :       SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
    3232          19 :       PyObject *obj = value();
    3233          14 :       incr();       
    3234             :       SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
    3235             :       return obj;     
    3236             :     }
    3237             : 
    3238             :     /* Make an alias for Python 3.x */
    3239             :     PyObject *__next__()
    3240             :     {
    3241             :       return next();
    3242             :     }
    3243             : 
    3244             :     PyObject *previous()
    3245             :     {
    3246             :       SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
    3247           0 :       decr();
    3248           0 :       PyObject *obj = value();
    3249             :       SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
    3250             :       return obj;
    3251             :     }
    3252             : 
    3253             :     SwigPyIterator *advance(ptrdiff_t n)
    3254             :     {
    3255           0 :       return  (n > 0) ?  incr(n) : decr(-n);
    3256             :     }
    3257             :       
    3258             :     bool operator == (const SwigPyIterator& x)  const
    3259             :     {
    3260           0 :       return equal(x);
    3261             :     }
    3262             :       
    3263             :     bool operator != (const SwigPyIterator& x) const
    3264             :     {
    3265           0 :       return ! operator==(x);
    3266             :     }
    3267             :       
    3268             :     SwigPyIterator& operator += (ptrdiff_t n)
    3269             :     {
    3270           0 :       return *advance(n);
    3271             :     }
    3272             : 
    3273             :     SwigPyIterator& operator -= (ptrdiff_t n)
    3274             :     {
    3275           0 :       return *advance(-n);
    3276             :     }
    3277             :       
    3278           0 :     SwigPyIterator* operator + (ptrdiff_t n) const
    3279             :     {
    3280           0 :       return copy()->advance(n);
    3281             :     }
    3282             : 
    3283           0 :     SwigPyIterator* operator - (ptrdiff_t n) const
    3284             :     {
    3285           0 :       return copy()->advance(-n);
    3286             :     }
    3287             :       
    3288             :     ptrdiff_t operator - (const SwigPyIterator& x) const
    3289             :     {
    3290           0 :       return x.distance(*this);
    3291             :     }
    3292             :       
    3293             :     static swig_type_info* descriptor() {
    3294             :       static int init = 0;
    3295             :       static swig_type_info* desc = 0;
    3296             :       if (!init) {
    3297             :         desc = SWIG_TypeQuery("swig::SwigPyIterator *");
    3298             :         init = 1;
    3299             :       } 
    3300             :       return desc;
    3301             :     }    
    3302             :   };
    3303             : 
    3304             : #if defined(SWIGPYTHON_BUILTIN)
    3305             :   inline PyObject* make_output_iterator_builtin (PyObject *pyself)
    3306             :   {
    3307             :     Py_INCREF(pyself);
    3308             :     return pyself;
    3309             :   }
    3310             : #endif
    3311             : }
    3312             : 
    3313             : 
    3314             : SWIGINTERN int
    3315             : SWIG_AsVal_double (PyObject *obj, double *val)
    3316             : {
    3317             :   int res = SWIG_TypeError;
    3318             :   if (PyFloat_Check(obj)) {
    3319             :     if (val) *val = PyFloat_AsDouble(obj);
    3320             :     return SWIG_OK;
    3321             : #if PY_VERSION_HEX < 0x03000000
    3322             :   } else if (PyInt_Check(obj)) {
    3323             :     if (val) *val = PyInt_AsLong(obj);
    3324             :     return SWIG_OK;
    3325             : #endif
    3326             :   } else if (PyLong_Check(obj)) {
    3327             :     double v = PyLong_AsDouble(obj);
    3328             :     if (!PyErr_Occurred()) {
    3329             :       if (val) *val = v;
    3330             :       return SWIG_OK;
    3331             :     } else {
    3332             :       PyErr_Clear();
    3333             :     }
    3334             :   }
    3335             : #ifdef SWIG_PYTHON_CAST_MODE
    3336             :   {
    3337             :     int dispatch = 0;
    3338             :     double d = PyFloat_AsDouble(obj);
    3339             :     if (!PyErr_Occurred()) {
    3340             :       if (val) *val = d;
    3341             :       return SWIG_AddCast(SWIG_OK);
    3342             :     } else {
    3343             :       PyErr_Clear();
    3344             :     }
    3345             :     if (!dispatch) {
    3346             :       long v = PyLong_AsLong(obj);
    3347             :       if (!PyErr_Occurred()) {
    3348             :         if (val) *val = v;
    3349             :         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
    3350             :       } else {
    3351             :         PyErr_Clear();
    3352             :       }
    3353             :     }
    3354             :   }
    3355             : #endif
    3356             :   return res;
    3357             : }
    3358             : 
    3359             : 
    3360             : #include <float.h>
    3361             : 
    3362             : 
    3363             : #include <math.h>
    3364             : 
    3365             : 
    3366             : SWIGINTERNINLINE int
    3367             : SWIG_CanCastAsInteger(double *d, double min, double max) {
    3368             :   double x = *d;
    3369             :   if ((min <= x && x <= max)) {
    3370             :    double fx = floor(x);
    3371             :    double cx = ceil(x);
    3372             :    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
    3373             :    if ((errno == EDOM) || (errno == ERANGE)) {
    3374             :      errno = 0;
    3375             :    } else {
    3376             :      double summ, reps, diff;
    3377             :      if (rd < x) {
    3378             :        diff = x - rd;
    3379             :      } else if (rd > x) {
    3380             :        diff = rd - x;
    3381             :      } else {
    3382             :        return 1;
    3383             :      }
    3384             :      summ = rd + x;
    3385             :      reps = diff/summ;
    3386             :      if (reps < 8*DBL_EPSILON) {
    3387             :        *d = rd;
    3388             :        return 1;
    3389             :      }
    3390             :    }
    3391             :   }
    3392             :   return 0;
    3393             : }
    3394             : 
    3395             : 
    3396             : SWIGINTERN int
    3397          15 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
    3398             : {
    3399             : #if PY_VERSION_HEX < 0x03000000
    3400          15 :   if (PyInt_Check(obj)) {
    3401          15 :     long v = PyInt_AsLong(obj);
    3402          15 :     if (v >= 0) {
    3403          15 :       if (val) *val = v;
    3404             :       return SWIG_OK;
    3405             :     } else {
    3406             :       return SWIG_OverflowError;
    3407             :     }
    3408             :   } else
    3409             : #endif
    3410           0 :   if (PyLong_Check(obj)) {
    3411           0 :     unsigned long v = PyLong_AsUnsignedLong(obj);
    3412           0 :     if (!PyErr_Occurred()) {
    3413           0 :       if (val) *val = v;
    3414             :       return SWIG_OK;
    3415             :     } else {
    3416           0 :       PyErr_Clear();
    3417           0 :       return SWIG_OverflowError;
    3418             :     }
    3419             :   }
    3420             : #ifdef SWIG_PYTHON_CAST_MODE
    3421             :   {
    3422             :     int dispatch = 0;
    3423             :     unsigned long v = PyLong_AsUnsignedLong(obj);
    3424             :     if (!PyErr_Occurred()) {
    3425             :       if (val) *val = v;
    3426             :       return SWIG_AddCast(SWIG_OK);
    3427             :     } else {
    3428             :       PyErr_Clear();
    3429             :     }
    3430             :     if (!dispatch) {
    3431             :       double d;
    3432             :       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
    3433             :       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
    3434             :         if (val) *val = (unsigned long)(d);
    3435             :         return res;
    3436             :       }
    3437             :     }
    3438             :   }
    3439             : #endif
    3440             :   return SWIG_TypeError;
    3441             : }
    3442             : 
    3443             : 
    3444             : #include <limits.h>
    3445             : #if !defined(SWIG_NO_LLONG_MAX)
    3446             : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
    3447             : #   define LLONG_MAX __LONG_LONG_MAX__
    3448             : #   define LLONG_MIN (-LLONG_MAX - 1LL)
    3449             : #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
    3450             : # endif
    3451             : #endif
    3452             : 
    3453             : 
    3454             : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
    3455             : #  define SWIG_LONG_LONG_AVAILABLE
    3456             : #endif
    3457             : 
    3458             : 
    3459             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3460             : SWIGINTERN int
    3461             : SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
    3462             : {
    3463             :   int res = SWIG_TypeError;
    3464             :   if (PyLong_Check(obj)) {
    3465             :     unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    3466             :     if (!PyErr_Occurred()) {
    3467             :       if (val) *val = v;
    3468             :       return SWIG_OK;
    3469             :     } else {
    3470             :       PyErr_Clear();
    3471             :       res = SWIG_OverflowError;
    3472             :     }
    3473             :   } else {
    3474             :     unsigned long v;
    3475             :     res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    3476             :     if (SWIG_IsOK(res)) {
    3477             :       if (val) *val = v;
    3478             :       return res;
    3479             :     }
    3480             :   }
    3481             : #ifdef SWIG_PYTHON_CAST_MODE
    3482             :   {
    3483             :     const double mant_max = 1LL << DBL_MANT_DIG;
    3484             :     double d;
    3485             :     res = SWIG_AsVal_double (obj,&d);
    3486             :     if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
    3487             :       if (val) *val = (unsigned long long)(d);
    3488             :       return SWIG_AddCast(res);
    3489             :     }
    3490             :     res = SWIG_TypeError;
    3491             :   }
    3492             : #endif
    3493             :   return res;
    3494             : }
    3495             : #endif
    3496             : 
    3497             : 
    3498             : SWIGINTERNINLINE int
    3499             : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
    3500             : {
    3501          15 :   int res = SWIG_TypeError;
    3502             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3503             :   if (sizeof(size_t) <= sizeof(unsigned long)) {
    3504             : #endif
    3505             :     unsigned long v;
    3506          15 :     res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    3507          15 :     if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
    3508             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3509             :   } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    3510             :     unsigned long long v;
    3511             :     res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    3512             :     if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
    3513             :   }
    3514             : #endif
    3515             :   return res;
    3516             : }
    3517             : 
    3518             : 
    3519             :   #define SWIG_From_long   PyInt_FromLong 
    3520             : 
    3521             : 
    3522             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3523             : SWIGINTERNINLINE PyObject* 
    3524             : SWIG_From_long_SS_long  (long long value)
    3525             : {
    3526             :   return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    3527             :     PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
    3528             : }
    3529             : #endif
    3530             : 
    3531             : 
    3532             : SWIGINTERNINLINE PyObject *
    3533             : SWIG_From_ptrdiff_t  (ptrdiff_t value)
    3534             : {    
    3535             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3536             :   if (sizeof(ptrdiff_t) <= sizeof(long)) {
    3537             : #endif
    3538           0 :     return SWIG_From_long  (static_cast< long >(value));
    3539             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3540             :   } else {
    3541             :     /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
    3542             :     return SWIG_From_long_SS_long  (static_cast< long long >(value));
    3543             :   }
    3544             : #endif
    3545             : }
    3546             : 
    3547             : 
    3548             : SWIGINTERNINLINE PyObject*
    3549             :   SWIG_From_bool  (bool value)
    3550             : {
    3551         122 :   return PyBool_FromLong(value ? 1 : 0);
    3552             : }
    3553             : 
    3554             : 
    3555             : SWIGINTERN int
    3556         140 : SWIG_AsVal_long (PyObject *obj, long* val)
    3557             : {
    3558             : #if PY_VERSION_HEX < 0x03000000
    3559         140 :   if (PyInt_Check(obj)) {
    3560         134 :     if (val) *val = PyInt_AsLong(obj);
    3561             :     return SWIG_OK;
    3562             :   } else
    3563             : #endif
    3564           6 :   if (PyLong_Check(obj)) {
    3565           0 :     long v = PyLong_AsLong(obj);
    3566           0 :     if (!PyErr_Occurred()) {
    3567           0 :       if (val) *val = v;
    3568             :       return SWIG_OK;
    3569             :     } else {
    3570           0 :       PyErr_Clear();
    3571           0 :       return SWIG_OverflowError;
    3572             :     }
    3573             :   }
    3574             : #ifdef SWIG_PYTHON_CAST_MODE
    3575             :   {
    3576             :     int dispatch = 0;
    3577             :     long v = PyInt_AsLong(obj);
    3578             :     if (!PyErr_Occurred()) {
    3579             :       if (val) *val = v;
    3580             :       return SWIG_AddCast(SWIG_OK);
    3581             :     } else {
    3582             :       PyErr_Clear();
    3583             :     }
    3584             :     if (!dispatch) {
    3585             :       double d;
    3586             :       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
    3587             :       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
    3588             :         if (val) *val = (long)(d);
    3589             :         return res;
    3590             :       }
    3591             :     }
    3592             :   }
    3593             : #endif
    3594             :   return SWIG_TypeError;
    3595             : }
    3596             : 
    3597             : 
    3598             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3599             : SWIGINTERN int
    3600             : SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
    3601             : {
    3602             :   int res = SWIG_TypeError;
    3603             :   if (PyLong_Check(obj)) {
    3604             :     long long v = PyLong_AsLongLong(obj);
    3605             :     if (!PyErr_Occurred()) {
    3606             :       if (val) *val = v;
    3607             :       return SWIG_OK;
    3608             :     } else {
    3609             :       PyErr_Clear();
    3610             :       res = SWIG_OverflowError;
    3611             :     }
    3612             :   } else {
    3613             :     long v;
    3614             :     res = SWIG_AsVal_long (obj,&v);
    3615             :     if (SWIG_IsOK(res)) {
    3616             :       if (val) *val = v;
    3617             :       return res;
    3618             :     }
    3619             :   }
    3620             : #ifdef SWIG_PYTHON_CAST_MODE
    3621             :   {
    3622             :     const double mant_max = 1LL << DBL_MANT_DIG;
    3623             :     const double mant_min = -mant_max;
    3624             :     double d;
    3625             :     res = SWIG_AsVal_double (obj,&d);
    3626             :     if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
    3627             :       if (val) *val = (long long)(d);
    3628             :       return SWIG_AddCast(res);
    3629             :     }
    3630             :     res = SWIG_TypeError;
    3631             :   }
    3632             : #endif
    3633             :   return res;
    3634             : }
    3635             : #endif
    3636             : 
    3637             : 
    3638             : SWIGINTERNINLINE int
    3639             : SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
    3640             : {
    3641           0 :   int res = SWIG_TypeError;
    3642             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3643             :   if (sizeof(ptrdiff_t) <= sizeof(long)) {
    3644             : #endif
    3645             :     long v;
    3646           0 :     res = SWIG_AsVal_long (obj, val ? &v : 0);
    3647           0 :     if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
    3648             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3649             :   } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
    3650             :     long long v;
    3651             :     res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
    3652             :     if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
    3653             :   }
    3654             : #endif
    3655             :   return res;
    3656             : }
    3657             : 
    3658             : 
    3659             : #include <algorithm>
    3660             : 
    3661             : 
    3662             : #include <vector>
    3663             : 
    3664             : 
    3665             : #include <utility>
    3666             : 
    3667             : 
    3668             : #include <map>
    3669             : 
    3670             : 
    3671             : #include <algorithm>
    3672             : 
    3673             : 
    3674             : #include <stdint.h>               // Use the C99 official header
    3675             : 
    3676             : 
    3677             :   extern "C" {
    3678             :     #include "kdbconfig.h"
    3679             :     #include "kdb.h"
    3680             :   }
    3681             : 
    3682             :   #include "keyexcept.hpp"
    3683             :   #include "kdbexcept.hpp"
    3684             :   #include "key.hpp"
    3685             :   #include "keyset.hpp"
    3686             :   #include "kdb.hpp"
    3687             :   using namespace kdb;
    3688             : 
    3689             : 
    3690             : SWIGINTERN swig_type_info*
    3691             : SWIG_pchar_descriptor(void)
    3692             : {
    3693             :   static int init = 0;
    3694             :   static swig_type_info* info = 0;
    3695           0 :   if (!init) {
    3696           0 :     info = SWIG_TypeQuery("_p_char");
    3697           0 :     init = 1;
    3698             :   }
    3699           0 :   return info;
    3700             : }
    3701             : 
    3702             : 
    3703             : SWIGINTERNINLINE PyObject *
    3704          41 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
    3705             : {
    3706          41 :   if (carray) {
    3707          41 :     if (size > INT_MAX) {
    3708           0 :       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    3709           0 :       return pchar_descriptor ? 
    3710             :         SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    3711             :     } else {
    3712             : #if PY_VERSION_HEX >= 0x03000000
    3713             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3714             :       return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
    3715             : #else
    3716             : #if PY_VERSION_HEX >= 0x03010000
    3717             :       return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
    3718             : #else
    3719             :       return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
    3720             : #endif
    3721             : #endif
    3722             : #else
    3723          41 :       return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
    3724             : #endif
    3725             :     }
    3726             :   } else {
    3727           0 :     return SWIG_Py_Void();
    3728             :   }
    3729             : }
    3730             : 
    3731             : 
    3732             : SWIGINTERNINLINE PyObject * 
    3733           0 : SWIG_FromCharPtr(const char *cptr)
    3734             : { 
    3735          15 :   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
    3736             : }
    3737             : 
    3738             : 
    3739             : SWIGINTERNINLINE PyObject *
    3740             : SWIG_From_short  (short value)
    3741             : {    
    3742           9 :   return SWIG_From_long  (value);
    3743             : }
    3744             : 
    3745             : 
    3746             : SWIGINTERNINLINE PyObject*
    3747             :   SWIG_From_int  (int value)
    3748             : {
    3749         150 :   return PyInt_FromLong((long) value);
    3750             : }
    3751             : 
    3752             : 
    3753             :   #define KEY_EXCEPTIONS \
    3754             :     KDB_CATCH_EX(kdb, KeyTypeMismatch) \
    3755             :     KDB_CATCH_EX(kdb, KeyInvalidName) \
    3756             :     KDB_CATCH_EX(kdb, KeyTypeConversion) \
    3757             :     KDB_CATCH_EX(kdb, KeyException) \
    3758             :     KDB_CATCH_EX(kdb, Exception)
    3759             : 
    3760             :   #define KDB_EXCEPTIONS \
    3761             :     KDB_CATCH_EX(kdb, KDBException) \
    3762             :     KDB_CATCH_EX(kdb, Exception)
    3763             : 
    3764             : 
    3765             :   #define KDB_CATCH_EX(namespace, exception) \
    3766             :     catch(const namespace::exception &e) \
    3767             :     { \
    3768             :       SWIG_Python_Raise(SWIG_NewPointerObj(new namespace::exception(e), \
    3769             :         SWIGTYPE_p_##namespace##__##exception, SWIG_POINTER_OWN), \
    3770             :         #exception, SWIGTYPE_p_##namespace##__##exception); \
    3771             :       SWIG_fail; \
    3772             :     }
    3773             : 
    3774             : 
    3775             : SWIGINTERN int
    3776         176 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
    3777             : {
    3778             : #if PY_VERSION_HEX>=0x03000000
    3779             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3780             :   if (PyBytes_Check(obj))
    3781             : #else
    3782             :   if (PyUnicode_Check(obj))
    3783             : #endif
    3784             : #else  
    3785         176 :   if (PyString_Check(obj))
    3786             : #endif
    3787             :   {
    3788             :     char *cstr; Py_ssize_t len;
    3789             : #if PY_VERSION_HEX>=0x03000000
    3790             : #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3791             :     if (!alloc && cptr) {
    3792             :         /* We can't allow converting without allocation, since the internal
    3793             :            representation of string in Python 3 is UCS-2/UCS-4 but we require
    3794             :            a UTF-8 representation.
    3795             :            TODO(bhy) More detailed explanation */
    3796             :         return SWIG_RuntimeError;
    3797             :     }
    3798             :     obj = PyUnicode_AsUTF8String(obj);
    3799             :     if(alloc) *alloc = SWIG_NEWOBJ;
    3800             : #endif
    3801             :     PyBytes_AsStringAndSize(obj, &cstr, &len);
    3802             : #else
    3803         176 :     PyString_AsStringAndSize(obj, &cstr, &len);
    3804             : #endif
    3805         176 :     if (cptr) {
    3806         176 :       if (alloc) {
    3807             :         /* 
    3808             :            In python the user should not be able to modify the inner
    3809             :            string representation. To warranty that, if you define
    3810             :            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
    3811             :            buffer is always returned.
    3812             : 
    3813             :            The default behavior is just to return the pointer value,
    3814             :            so, be careful.
    3815             :         */ 
    3816             : #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
    3817             :         if (*alloc != SWIG_OLDOBJ) 
    3818             : #else
    3819         176 :         if (*alloc == SWIG_NEWOBJ) 
    3820             : #endif
    3821             :         {
    3822           0 :           *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
    3823           0 :           *alloc = SWIG_NEWOBJ;
    3824             :         } else {
    3825         176 :           *cptr = cstr;
    3826         176 :           *alloc = SWIG_OLDOBJ;
    3827             :         }
    3828             :       } else {
    3829             : #if PY_VERSION_HEX>=0x03000000
    3830             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3831             :         *cptr = PyBytes_AsString(obj);
    3832             : #else
    3833             :         assert(0); /* Should never reach here with Unicode strings in Python 3 */
    3834             : #endif
    3835             : #else
    3836           0 :         *cptr = SWIG_Python_str_AsChar(obj);
    3837             : #endif
    3838             :       }
    3839             :     }
    3840         176 :     if (psize) *psize = len + 1;
    3841             : #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3842             :     Py_XDECREF(obj);
    3843             : #endif
    3844             :     return SWIG_OK;
    3845             :   } else {
    3846             : #if defined(SWIG_PYTHON_2_UNICODE)
    3847             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3848             : #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
    3849             : #endif
    3850             : #if PY_VERSION_HEX<0x03000000
    3851             :     if (PyUnicode_Check(obj)) {
    3852             :       char *cstr; Py_ssize_t len;
    3853             :       if (!alloc && cptr) {
    3854             :         return SWIG_RuntimeError;
    3855             :       }
    3856             :       obj = PyUnicode_AsUTF8String(obj);
    3857             :       if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
    3858             :         if (cptr) {
    3859             :           if (alloc) *alloc = SWIG_NEWOBJ;
    3860             :           *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
    3861             :         }
    3862             :         if (psize) *psize = len + 1;
    3863             : 
    3864             :         Py_XDECREF(obj);
    3865             :         return SWIG_OK;
    3866             :       } else {
    3867             :         Py_XDECREF(obj);
    3868             :       }
    3869             :     }
    3870             : #endif
    3871             : #endif
    3872             : 
    3873           0 :     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    3874           0 :     if (pchar_descriptor) {
    3875           0 :       void* vptr = 0;
    3876           0 :       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
    3877           0 :         if (cptr) *cptr = (char *) vptr;
    3878           0 :         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
    3879           0 :         if (alloc) *alloc = SWIG_OLDOBJ;
    3880           0 :         return SWIG_OK;
    3881             :       }
    3882             :     }
    3883             :   }
    3884             :   return SWIG_TypeError;
    3885             : }
    3886             : 
    3887             : 
    3888             : SWIGINTERN int
    3889          70 : SWIG_AsPtr_std_string (PyObject * obj, std::string **val) 
    3890             : {
    3891          70 :   char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
    3892          70 :   if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
    3893          70 :     if (buf) {
    3894         280 :       if (val) *val = new std::string(buf, size - 1);
    3895          70 :       if (alloc == SWIG_NEWOBJ) delete[] buf;
    3896             :       return SWIG_NEWOBJ;
    3897             :     } else {
    3898           0 :       if (val) *val = 0;
    3899             :       return SWIG_OLDOBJ;
    3900             :     }
    3901             :   } else {
    3902             :     static int init = 0;
    3903             :     static swig_type_info* descriptor = 0;
    3904           0 :     if (!init) {
    3905           0 :       descriptor = SWIG_TypeQuery("std::string" " *");
    3906           0 :       init = 1;
    3907             :     }
    3908           0 :     if (descriptor) {
    3909             :       std::string *vptr;
    3910           0 :       int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
    3911           0 :       if (SWIG_IsOK(res) && val) *val = vptr;
    3912             :       return res;
    3913             :     }
    3914             :   }
    3915             :   return SWIG_ERROR;
    3916             : }
    3917             : 
    3918             : 
    3919             : SWIGINTERN int
    3920             : SWIG_AsVal_bool (PyObject *obj, bool *val)
    3921             : {
    3922             :   int r;
    3923           0 :   if (!PyBool_Check(obj))
    3924             :     return SWIG_ERROR;
    3925           0 :   r = PyObject_IsTrue(obj);
    3926           0 :   if (r == -1)
    3927             :     return SWIG_ERROR;
    3928           0 :   if (val) *val = r ? true : false;
    3929             :   return SWIG_OK;
    3930             : }
    3931             : 
    3932             : 
    3933             : namespace swig {
    3934             :   template <class Type>
    3935             :   struct noconst_traits {
    3936             :     typedef Type noconst_type;
    3937             :   };
    3938             : 
    3939             :   template <class Type>
    3940             :   struct noconst_traits<const Type> {
    3941             :     typedef Type noconst_type;
    3942             :   };
    3943             : 
    3944             :   /*
    3945             :     type categories
    3946             :   */
    3947             :   struct pointer_category { };
    3948             :   struct value_category { };
    3949             : 
    3950             :   /*
    3951             :     General traits that provides type_name and type_info
    3952             :   */
    3953             :   template <class Type> struct traits { };
    3954             : 
    3955             :   template <class Type>
    3956             :   inline const char* type_name() {
    3957             :     return traits<typename noconst_traits<Type >::noconst_type >::type_name();
    3958             :   }
    3959             : 
    3960             :   template <class Type>
    3961             :   struct traits_info {
    3962             :     static swig_type_info *type_query(std::string name) {
    3963           1 :       name += " *";
    3964           1 :       return SWIG_TypeQuery(name.c_str());
    3965             :     }
    3966           8 :     static swig_type_info *type_info() {
    3967          12 :       static swig_type_info *info = type_query(type_name<Type>());
    3968           8 :       return info;
    3969             :     }
    3970             :   };
    3971             : 
    3972             :   template <class Type>
    3973             :   inline swig_type_info *type_info() {
    3974           8 :     return traits_info<Type>::type_info();
    3975             :   }
    3976             : 
    3977             :   /*
    3978             :     Partial specialization for pointers
    3979             :   */
    3980             :   template <class Type> struct traits <Type *> {
    3981             :     typedef pointer_category category;
    3982             :     static std::string make_ptr_name(const char* name) {
    3983             :       std::string ptrname = name;
    3984             :       ptrname += " *";
    3985             :       return ptrname;
    3986             :     }
    3987             :     static const char* type_name() {
    3988             :       static std::string name = make_ptr_name(swig::type_name<Type>());
    3989             :       return name.c_str();
    3990             :     }
    3991             :   };
    3992             : 
    3993             :   template <class Type, class Category>
    3994             :   struct traits_as { };
    3995             : 
    3996             :   template <class Type, class Category>
    3997             :   struct traits_check { };
    3998             : 
    3999             : }
    4000             : 
    4001             : 
    4002             : namespace swig {  
    4003             :   /*
    4004             :     Traits that provides the from method
    4005             :   */
    4006             :   template <class Type> struct traits_from_ptr {
    4007             :     static PyObject *from(Type *val, int owner = 0) {
    4008           8 :       return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
    4009             :     }
    4010             :   };
    4011             : 
    4012             :   template <class Type> struct traits_from {
    4013           8 :     static PyObject *from(const Type& val) {
    4014          24 :       return traits_from_ptr<Type>::from(new Type(val), 1);
    4015             :     }
    4016             :   };
    4017             : 
    4018             :   template <class Type> struct traits_from<Type *> {
    4019             :     static PyObject *from(Type* val) {
    4020             :       return traits_from_ptr<Type>::from(val, 0);
    4021             :     }
    4022             :   };
    4023             : 
    4024             :   template <class Type> struct traits_from<const Type *> {
    4025             :     static PyObject *from(const Type* val) {
    4026             :       return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
    4027             :     }
    4028             :   };
    4029             : 
    4030             : 
    4031             :   template <class Type>
    4032             :   inline PyObject *from(const Type& val) {
    4033          16 :     return traits_from<Type>::from(val);
    4034             :   }
    4035             : 
    4036             :   template <class Type>
    4037             :   inline PyObject *from_ptr(Type* val, int owner) {
    4038             :     return traits_from_ptr<Type>::from(val, owner);
    4039             :   }
    4040             : 
    4041             :   /*
    4042             :     Traits that provides the asval/as/check method
    4043             :   */
    4044             :   template <class Type>
    4045             :   struct traits_asptr {   
    4046             :     static int asptr(PyObject *obj, Type **val) {
    4047             :       Type *p;
    4048             :       int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
    4049             :       if (SWIG_IsOK(res)) {
    4050             :         if (val) *val = p;
    4051             :       }
    4052             :       return res;
    4053             :     }
    4054             :   }; 
    4055             : 
    4056             :   template <class Type>
    4057             :   inline int asptr(PyObject *obj, Type **vptr) {
    4058             :     return traits_asptr<Type>::asptr(obj, vptr);
    4059             :   }
    4060             : 
    4061             :   template <class Type> 
    4062             :   struct traits_asval {
    4063             :     static int asval(PyObject *obj, Type *val) {
    4064             :       if (val) {
    4065             :         Type *p = 0;
    4066             :         int res = traits_asptr<Type>::asptr(obj, &p);
    4067             :         if (!SWIG_IsOK(res)) return res;        
    4068             :         if (p) {
    4069             :           typedef typename noconst_traits<Type>::noconst_type noconst_type;
    4070             :           *(const_cast<noconst_type*>(val)) = *p;
    4071             :           if (SWIG_IsNewObj(res)){
    4072             :             delete p;
    4073             :             res = SWIG_DelNewMask(res);
    4074             :           }
    4075             :           return res;
    4076             :         } else {
    4077             :           return SWIG_ERROR;
    4078             :         }
    4079             :       } else {
    4080             :         return traits_asptr<Type>::asptr(obj, (Type **)(0));
    4081             :       }
    4082             :     }
    4083             :   };
    4084             : 
    4085             :   template <class Type> struct traits_asval<Type*> {
    4086             :     static int asval(PyObject *obj, Type **val) {
    4087             :       if (val) {
    4088             :         typedef typename noconst_traits<Type>::noconst_type noconst_type;
    4089             :         noconst_type *p = 0;
    4090             :         int res = traits_asptr<noconst_type>::asptr(obj,  &p);
    4091             :         if (SWIG_IsOK(res)) {
    4092             :           *(const_cast<noconst_type**>(val)) = p;
    4093             :         }
    4094             :         return res;
    4095             :       } else {
    4096             :         return traits_asptr<Type>::asptr(obj, (Type **)(0));
    4097             :       }
    4098             :     }
    4099             :   };
    4100             :   
    4101             :   template <class Type>
    4102             :   inline int asval(PyObject *obj, Type *val) {
    4103             :     return traits_asval<Type>::asval(obj, val);
    4104             :   }
    4105             : 
    4106             :   template <class Type> 
    4107             :   struct traits_as<Type, value_category> {
    4108             :     static Type as(PyObject *obj, bool throw_error) {
    4109             :       Type v;
    4110             :       int res = asval(obj, &v);
    4111             :       if (!obj || !SWIG_IsOK(res)) {
    4112             :         if (!PyErr_Occurred()) {
    4113             :           ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
    4114             :         }
    4115             :         if (throw_error) throw std::invalid_argument("bad type");
    4116             :       }
    4117             :       return v;
    4118             :     }
    4119             :   };
    4120             : 
    4121             :   template <class Type> 
    4122             :   struct traits_as<Type, pointer_category> {
    4123             :     static Type as(PyObject *obj, bool throw_error) {
    4124             :       Type *v = 0;      
    4125             :       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
    4126             :       if (SWIG_IsOK(res) && v) {
    4127             :         if (SWIG_IsNewObj(res)) {
    4128             :           Type r(*v);
    4129             :           delete v;
    4130             :           return r;
    4131             :         } else {
    4132             :           return *v;
    4133             :         }
    4134             :       } else {
    4135             :         // Uninitialized return value, no Type() constructor required.
    4136             :         static Type *v_def = (Type*) malloc(sizeof(Type));
    4137             :         if (!PyErr_Occurred()) {
    4138             :           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
    4139             :         }
    4140             :         if (throw_error) throw std::invalid_argument("bad type");
    4141             :         memset(v_def,0,sizeof(Type));
    4142             :         return *v_def;
    4143             :       }
    4144             :     }
    4145             :   };
    4146             : 
    4147             :   template <class Type> 
    4148             :   struct traits_as<Type*, pointer_category> {
    4149             :     static Type* as(PyObject *obj, bool throw_error) {
    4150             :       Type *v = 0;      
    4151             :       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
    4152             :       if (SWIG_IsOK(res)) {
    4153             :         return v;
    4154             :       } else {
    4155             :         if (!PyErr_Occurred()) {
    4156             :           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
    4157             :         }
    4158             :         if (throw_error) throw std::invalid_argument("bad type");
    4159             :         return 0;
    4160             :       }
    4161             :     }
    4162             :   };
    4163             :     
    4164             :   template <class Type>
    4165             :   inline Type as(PyObject *obj, bool te = false) {
    4166             :     return traits_as<Type, typename traits<Type>::category>::as(obj, te);
    4167             :   }
    4168             : 
    4169             :   template <class Type> 
    4170             :   struct traits_check<Type, value_category> {
    4171             :     static bool check(PyObject *obj) {
    4172             :       int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
    4173             :       return SWIG_IsOK(res) ? true : false;
    4174             :     }
    4175             :   };
    4176             : 
    4177             :   template <class Type> 
    4178             :   struct traits_check<Type, pointer_category> {
    4179             :     static bool check(PyObject *obj) {
    4180             :       int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
    4181             :       return SWIG_IsOK(res) ? true : false;
    4182             :     }
    4183             :   };
    4184             : 
    4185             :   template <class Type>
    4186             :   inline bool check(PyObject *obj) {
    4187             :     return traits_check<Type, typename traits<Type>::category>::check(obj);
    4188             :   }
    4189             : }
    4190             : 
    4191             : 
    4192             : #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
    4193             : #  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
    4194             : #    define SWIG_STD_NOITERATOR_TRAITS_STL
    4195             : #  endif
    4196             : #endif
    4197             : 
    4198             : #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
    4199             : #include <iterator>
    4200             : #else
    4201             : namespace std {
    4202             :   template <class Iterator>
    4203             :   struct iterator_traits {
    4204             :     typedef ptrdiff_t difference_type;
    4205             :     typedef typename Iterator::value_type value_type;
    4206             :   };
    4207             : 
    4208             :   template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
    4209             :   struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
    4210             :     typedef Distance difference_type;
    4211             :     typedef T value_type;
    4212             :   };
    4213             : 
    4214             :   template <class T>
    4215             :   struct iterator_traits<T*> {
    4216             :     typedef T value_type;
    4217             :     typedef ptrdiff_t difference_type;
    4218             :   };
    4219             : 
    4220             :   template<typename _InputIterator>
    4221             :   inline typename iterator_traits<_InputIterator>::difference_type
    4222             :   distance(_InputIterator __first, _InputIterator __last)
    4223             :   {
    4224             :     typename iterator_traits<_InputIterator>::difference_type __n = 0;
    4225             :     while (__first != __last) {
    4226             :       ++__first; ++__n;
    4227             :     }
    4228             :     return __n;
    4229             :   }
    4230             : }
    4231             : #endif
    4232             : 
    4233             : 
    4234             : namespace swig {
    4235             :   template<typename OutIterator>
    4236           0 :   class SwigPyIterator_T :  public SwigPyIterator
    4237             :   {
    4238             :   public:
    4239             :     typedef OutIterator out_iterator;
    4240             :     typedef typename std::iterator_traits<out_iterator>::value_type value_type;    
    4241             :     typedef SwigPyIterator_T<out_iterator> self_type;
    4242             : 
    4243           7 :     SwigPyIterator_T(out_iterator curr, PyObject *seq)
    4244          14 :       : SwigPyIterator(seq), current(curr)
    4245             :     {
    4246             :     }
    4247             : 
    4248             :     const out_iterator& get_current() const
    4249             :     {
    4250             :       return current;
    4251             :     }
    4252             : 
    4253             :     
    4254           0 :     bool equal (const SwigPyIterator &iter) const
    4255             :     {
    4256           0 :       const self_type *iters = dynamic_cast<const self_type *>(&iter);
    4257           0 :       if (iters) {
    4258           0 :         return (current == iters->get_current());
    4259             :       } else {
    4260           0 :         throw std::invalid_argument("bad iterator type");
    4261             :       }
    4262             :     }
    4263             :     
    4264           0 :     ptrdiff_t distance(const SwigPyIterator &iter) const
    4265             :     {
    4266           0 :       const self_type *iters = dynamic_cast<const self_type *>(&iter);
    4267           0 :       if (iters) {
    4268           0 :         return std::distance(current, iters->get_current());
    4269             :       } else {
    4270           0 :         throw std::invalid_argument("bad iterator type");
    4271             :       }
    4272             :     }    
    4273             :     
    4274             :   protected:
    4275             :     out_iterator current;
    4276             :   };
    4277             :   
    4278             :   template <class ValueType>
    4279             :   struct from_oper 
    4280             :   {
    4281             :     typedef const ValueType& argument_type;
    4282             :     typedef PyObject *result_type;
    4283             :     result_type operator()(argument_type v) const
    4284             :     {
    4285          16 :       return swig::from(v);
    4286             :     }
    4287             :   };
    4288             : 
    4289             :   template<typename OutIterator, 
    4290             :            typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
    4291             :            typename FromOper = from_oper<ValueType> >
    4292             :   class SwigPyIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
    4293             :   {
    4294             :   public:
    4295             :     FromOper from;
    4296             :     typedef OutIterator out_iterator;
    4297             :     typedef ValueType value_type;
    4298             :     typedef SwigPyIterator_T<out_iterator>  base;
    4299             :     typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
    4300             :     
    4301             :     SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
    4302             :       : SwigPyIterator_T<OutIterator>(curr, seq)
    4303             :     {
    4304             :     }
    4305             :     
    4306             :     PyObject *value() const {
    4307             :       return from(static_cast<const value_type&>(*(base::current)));
    4308             :     }
    4309             :     
    4310             :     SwigPyIterator *copy() const
    4311             :     {
    4312             :       return new self_type(*this);
    4313             :     }
    4314             : 
    4315             :     SwigPyIterator *incr(size_t n = 1)
    4316             :     {
    4317             :       while (n--) {
    4318             :         ++base::current;
    4319             :       }
    4320             :       return this;
    4321             :     }
    4322             : 
    4323             :     SwigPyIterator *decr(size_t n = 1)
    4324             :     {
    4325             :       while (n--) {
    4326             :         --base::current;
    4327             :       }
    4328             :       return this;
    4329             :     }
    4330             :   };
    4331             : 
    4332             :   template<typename OutIterator, 
    4333             :            typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
    4334             :            typename FromOper = from_oper<ValueType> >
    4335           0 :   class SwigPyIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
    4336             :   {
    4337             :   public:
    4338             :     FromOper from;
    4339             :     typedef OutIterator out_iterator;
    4340             :     typedef ValueType value_type;
    4341             :     typedef SwigPyIterator_T<out_iterator>  base;    
    4342             :     typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    4343             :     
    4344           7 :     SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
    4345          14 :       : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
    4346             :     {
    4347             :     }
    4348             :     
    4349          21 :     PyObject *value() const {
    4350          42 :       if (base::current == end) {
    4351           5 :         throw stop_iteration();
    4352             :       } else {
    4353          64 :         return from(static_cast<const value_type&>(*(base::current)));
    4354             :       }
    4355             :     }
    4356             :     
    4357           0 :     SwigPyIterator *copy() const
    4358             :     {
    4359           0 :       return new self_type(*this);
    4360             :     }
    4361             : 
    4362          14 :     SwigPyIterator *incr(size_t n = 1)
    4363             :     {
    4364          28 :       while (n--) {
    4365          28 :         if (base::current == end) {
    4366           0 :           throw stop_iteration();
    4367             :         } else {
    4368          14 :           ++base::current;
    4369             :         }
    4370             :       }
    4371          14 :       return this;
    4372             :     }
    4373             : 
    4374           0 :     SwigPyIterator *decr(size_t n = 1)
    4375             :     {
    4376           0 :       while (n--) {
    4377           0 :         if (base::current == begin) {
    4378           0 :           throw stop_iteration();
    4379             :         } else {
    4380           0 :           --base::current;
    4381             :         }
    4382             :       }
    4383           0 :       return this;
    4384             :     }
    4385             : 
    4386             :   private:
    4387             :     out_iterator begin;
    4388             :     out_iterator end;
    4389             :   };
    4390             : 
    4391             :   template<typename OutIter>
    4392             :   inline SwigPyIterator*
    4393           7 :   make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
    4394             :   {
    4395          14 :     return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
    4396             :   }
    4397             : 
    4398             :   template<typename OutIter>
    4399             :   inline SwigPyIterator*
    4400             :   make_output_iterator(const OutIter& current, PyObject *seq = 0)
    4401             :   {
    4402             :     return new SwigPyIteratorOpen_T<OutIter>(current, seq);
    4403             :   }
    4404             : 
    4405             : }
    4406             : 
    4407             : 
    4408             : SWIGINTERN int
    4409             : SWIG_AsVal_std_string (PyObject * obj, std::string *val)
    4410             : {
    4411             :   std::string* v = (std::string *) 0;
    4412             :   int res = SWIG_AsPtr_std_string (obj, &v);
    4413             :   if (!SWIG_IsOK(res)) return res;
    4414             :   if (v) {
    4415             :     if (val) *val = *v;
    4416             :     if (SWIG_IsNewObj(res)) {
    4417             :       delete v;
    4418             :       res = SWIG_DelNewMask(res);
    4419             :     }
    4420             :     return res;
    4421             :   }
    4422             :   return SWIG_ERROR;
    4423             : }
    4424             : 
    4425             : 
    4426             : SWIGINTERNINLINE PyObject *
    4427             : SWIG_From_std_string  (const std::string& s)
    4428             : {
    4429          52 :   return SWIG_FromCharPtrAndSize(s.data(), s.size());
    4430             : }
    4431             : 
    4432             : 
    4433             : namespace swig {
    4434             :   template <> struct traits< std::string > {
    4435             :     typedef value_category category;
    4436             :     static const char* type_name() { return"std::string"; }
    4437             :   };
    4438             :   template <>  struct traits_asval< std::string > {
    4439             :     typedef std::string value_type;
    4440             :     static int asval(PyObject *obj, value_type *val) {
    4441             :       return SWIG_AsVal_std_string (obj, val);
    4442             :     }
    4443             :   };
    4444             :   template <>  struct traits_from< std::string > {
    4445             :     typedef std::string value_type;
    4446             :     static PyObject *from(const value_type& val) {
    4447           8 :       return SWIG_From_std_string  (val);
    4448             :     }
    4449             :   };
    4450             : }
    4451             : 
    4452             : 
    4453             : 
    4454             : 
    4455             : 
    4456             : SWIGINTERN int
    4457             : SWIG_AsVal_int (PyObject * obj, int *val)
    4458             : {
    4459             :   long v;
    4460         106 :   int res = SWIG_AsVal_long (obj, &v);
    4461         106 :   if (SWIG_IsOK(res)) {
    4462         106 :     if ((v < INT_MIN || v > INT_MAX)) {
    4463             :       return SWIG_OverflowError;
    4464             :     } else {
    4465         106 :       if (val) *val = static_cast< int >(v);
    4466             :     }
    4467             :   }  
    4468             :   return res;
    4469             : }
    4470             : 
    4471         106 : SWIGINTERN kdb::Key *new_kdb_Key__SWIG_3(char const *name,int flags=0){
    4472             :     return new kdb::Key(name,
    4473             :       KEY_FLAGS, flags,
    4474         106 :       KEY_END);
    4475             :   }
    4476             : SWIGINTERN int kdb_Key___cmp__(kdb::Key *self,kdb::Key const *o){
    4477           0 :     return ckdb::keyCmp(self->getKey(), o->getKey());
    4478             :   }
    4479           1 : SWIGINTERN kdb::Key *kdb_Key___copy__(kdb::Key *self){
    4480           2 :     return new kdb::Key(self->dup());
    4481             :   }
    4482           2 : SWIGINTERN swig::SwigPyIterator *kdb_Key___iter__(kdb::Key *self,PyObject **PYTHON_SELF){
    4483           8 :     return swig::make_output_iterator(self->begin(), self->begin(),
    4484           6 :       self->end(), *PYTHON_SELF);
    4485             :   }
    4486           2 : SWIGINTERN swig::SwigPyIterator *kdb_Key___reversed__(kdb::Key *self,PyObject **PYTHON_SELF){
    4487           8 :     return swig::make_output_iterator(self->rbegin(), self->rbegin(),
    4488           6 :       self->rend(), *PYTHON_SELF);
    4489             :   }
    4490             : 
    4491             :   namespace swig {
    4492             :     template <>  struct traits< kdb::Key > {
    4493             :       typedef pointer_category category;
    4494             :       static const char* type_name() { return"kdb::Key"; }
    4495             :     };
    4496             :   }
    4497             : 
    4498          15 : SWIGINTERN kdb::KeySet *new_kdb_KeySet__SWIG_3(size_t alloc){
    4499          15 :    return new kdb::KeySet(alloc, KS_END);
    4500             :   }
    4501           1 : SWIGINTERN kdb::KeySet *kdb_KeySet___copy__(kdb::KeySet *self){
    4502           2 :     return new kdb::KeySet(*self);
    4503             :   }
    4504           1 : SWIGINTERN kdb::KeySet *kdb_KeySet___deepcopy__(kdb::KeySet *self,PyObject *memo){
    4505             :     (void) PyDict_Check(memo);
    4506           1 :     ssize_t size = self->size();
    4507           1 :     kdb::KeySet *ks = new kdb::KeySet(size, KS_END);
    4508           9 :     for (cursor_t cursor = 0; cursor < size; ++cursor)
    4509          24 :       ks->append(self->at(cursor)->dup());
    4510           1 :     return ks;
    4511             :   }
    4512           2 : SWIGINTERN swig::SwigPyIterator *kdb_KeySet___iter__(kdb::KeySet *self,PyObject **PYTHON_SELF){
    4513           8 :     return swig::make_output_iterator(self->begin(), self->begin(),
    4514           6 :       self->end(), *PYTHON_SELF);
    4515             :   }
    4516           1 : SWIGINTERN swig::SwigPyIterator *kdb_KeySet___reversed__(kdb::KeySet *self,PyObject **PYTHON_SELF){
    4517           4 :     return swig::make_output_iterator(self->rbegin(), self->rbegin(),
    4518           3 :       self->rend(), *PYTHON_SELF);
    4519             :   }
    4520             : #ifdef __cplusplus
    4521             : extern "C" {
    4522             : #endif
    4523           0 : SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4524           0 :   PyObject *resultobj = 0;
    4525           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4526           0 :   void *argp1 = 0 ;
    4527           0 :   int res1 = 0 ;
    4528             :   PyObject *swig_obj[1] ;
    4529             :   
    4530           0 :   if (!args) SWIG_fail;
    4531           0 :   swig_obj[0] = args;
    4532           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
    4533           0 :   if (!SWIG_IsOK(res1)) {
    4534           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
    4535             :   }
    4536           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4537           0 :   delete arg1;
    4538           0 :   resultobj = SWIG_Py_Void();
    4539           0 :   return resultobj;
    4540             : fail:
    4541             :   return NULL;
    4542             : }
    4543             : 
    4544             : 
    4545           2 : SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4546           2 :   PyObject *resultobj = 0;
    4547           2 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4548           2 :   void *argp1 = 0 ;
    4549           2 :   int res1 = 0 ;
    4550             :   PyObject *swig_obj[1] ;
    4551           2 :   PyObject *result = 0 ;
    4552             :   
    4553           2 :   if (!args) SWIG_fail;
    4554           2 :   swig_obj[0] = args;
    4555           2 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4556           2 :   if (!SWIG_IsOK(res1)) {
    4557           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
    4558             :   }
    4559           2 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4560             :   try {
    4561           2 :     result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
    4562             :   }
    4563           0 :   catch(swig::stop_iteration &_e) {
    4564             :     {
    4565             :       (void)_e;
    4566           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    4567             :       SWIG_fail;
    4568             :     }
    4569             :   }
    4570             :   
    4571             :   resultobj = result;
    4572             :   return resultobj;
    4573             : fail:
    4574             :   return NULL;
    4575             : }
    4576             : 
    4577             : 
    4578           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    4579           0 :   PyObject *resultobj = 0;
    4580           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4581             :   size_t arg2 ;
    4582           0 :   void *argp1 = 0 ;
    4583           0 :   int res1 = 0 ;
    4584             :   size_t val2 ;
    4585           0 :   int ecode2 = 0 ;
    4586           0 :   swig::SwigPyIterator *result = 0 ;
    4587             :   
    4588           0 :   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
    4589           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4590           0 :   if (!SWIG_IsOK(res1)) {
    4591           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
    4592             :   }
    4593           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4594           0 :   ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
    4595           0 :   if (!SWIG_IsOK(ecode2)) {
    4596           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
    4597             :   } 
    4598           0 :   arg2 = static_cast< size_t >(val2);
    4599             :   try {
    4600           0 :     result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
    4601             :   }
    4602           0 :   catch(swig::stop_iteration &_e) {
    4603             :     {
    4604             :       (void)_e;
    4605           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    4606             :       SWIG_fail;
    4607             :     }
    4608             :   }
    4609             :   
    4610           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4611             :   return resultobj;
    4612             : fail:
    4613             :   return NULL;
    4614             : }
    4615             : 
    4616             : 
    4617           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    4618           0 :   PyObject *resultobj = 0;
    4619           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4620           0 :   void *argp1 = 0 ;
    4621           0 :   int res1 = 0 ;
    4622           0 :   swig::SwigPyIterator *result = 0 ;
    4623             :   
    4624           0 :   if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
    4625           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4626           0 :   if (!SWIG_IsOK(res1)) {
    4627           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
    4628             :   }
    4629           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4630             :   try {
    4631           0 :     result = (swig::SwigPyIterator *)(arg1)->incr();
    4632             :   }
    4633           0 :   catch(swig::stop_iteration &_e) {
    4634             :     {
    4635             :       (void)_e;
    4636           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    4637             :       SWIG_fail;
    4638             :     }
    4639             :   }
    4640             :   
    4641           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4642             :   return resultobj;
    4643             : fail:
    4644             :   return NULL;
    4645             : }
    4646             : 
    4647             : 
    4648           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
    4649             :   Py_ssize_t argc;
    4650             :   PyObject *argv[3] = {
    4651             :     0
    4652           0 :   };
    4653             :   
    4654           0 :   if (!(argc = SWIG_Python_UnpackTuple(args,"SwigPyIterator_incr",0,2,argv))) SWIG_fail;
    4655           0 :   --argc;
    4656           0 :   if (argc == 1) {
    4657           0 :     return _wrap_SwigPyIterator_incr__SWIG_1(self, argc, argv);
    4658             :   }
    4659           0 :   if (argc == 2) {
    4660           0 :     return _wrap_SwigPyIterator_incr__SWIG_0(self, argc, argv);
    4661             :   }
    4662             :   
    4663             : fail:
    4664             :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
    4665             :     "  Possible C/C++ prototypes are:\n"
    4666             :     "    swig::SwigPyIterator::incr(size_t)\n"
    4667           0 :     "    swig::SwigPyIterator::incr()\n");
    4668             :   return 0;
    4669             : }
    4670             : 
    4671             : 
    4672           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    4673           0 :   PyObject *resultobj = 0;
    4674           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4675             :   size_t arg2 ;
    4676           0 :   void *argp1 = 0 ;
    4677           0 :   int res1 = 0 ;
    4678             :   size_t val2 ;
    4679           0 :   int ecode2 = 0 ;
    4680           0 :   swig::SwigPyIterator *result = 0 ;
    4681             :   
    4682           0 :   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
    4683           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4684           0 :   if (!SWIG_IsOK(res1)) {
    4685           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
    4686             :   }
    4687           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4688           0 :   ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
    4689           0 :   if (!SWIG_IsOK(ecode2)) {
    4690           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
    4691             :   } 
    4692           0 :   arg2 = static_cast< size_t >(val2);
    4693             :   try {
    4694           0 :     result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
    4695             :   }
    4696           0 :   catch(swig::stop_iteration &_e) {
    4697             :     {
    4698             :       (void)_e;
    4699           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    4700             :       SWIG_fail;
    4701             :     }
    4702             :   }
    4703             :   
    4704           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4705             :   return resultobj;
    4706             : fail:
    4707             :   return NULL;
    4708             : }
    4709             : 
    4710             : 
    4711           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    4712           0 :   PyObject *resultobj = 0;
    4713           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4714           0 :   void *argp1 = 0 ;
    4715           0 :   int res1 = 0 ;
    4716           0 :   swig::SwigPyIterator *result = 0 ;
    4717             :   
    4718           0 :   if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
    4719           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4720           0 :   if (!SWIG_IsOK(res1)) {
    4721           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
    4722             :   }
    4723           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4724             :   try {
    4725           0 :     result = (swig::SwigPyIterator *)(arg1)->decr();
    4726             :   }
    4727           0 :   catch(swig::stop_iteration &_e) {
    4728             :     {
    4729             :       (void)_e;
    4730           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    4731             :       SWIG_fail;
    4732             :     }
    4733             :   }
    4734             :   
    4735           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4736             :   return resultobj;
    4737             : fail:
    4738             :   return NULL;
    4739             : }
    4740             : 
    4741             : 
    4742           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
    4743             :   Py_ssize_t argc;
    4744             :   PyObject *argv[3] = {
    4745             :     0
    4746           0 :   };
    4747             :   
    4748           0 :   if (!(argc = SWIG_Python_UnpackTuple(args,"SwigPyIterator_decr",0,2,argv))) SWIG_fail;
    4749           0 :   --argc;
    4750           0 :   if (argc == 1) {
    4751           0 :     return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
    4752             :   }
    4753           0 :   if (argc == 2) {
    4754           0 :     return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
    4755             :   }
    4756             :   
    4757             : fail:
    4758             :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
    4759             :     "  Possible C/C++ prototypes are:\n"
    4760             :     "    swig::SwigPyIterator::decr(size_t)\n"
    4761           0 :     "    swig::SwigPyIterator::decr()\n");
    4762             :   return 0;
    4763             : }
    4764             : 
    4765             : 
    4766           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4767           0 :   PyObject *resultobj = 0;
    4768           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4769           0 :   swig::SwigPyIterator *arg2 = 0 ;
    4770           0 :   void *argp1 = 0 ;
    4771           0 :   int res1 = 0 ;
    4772           0 :   void *argp2 = 0 ;
    4773           0 :   int res2 = 0 ;
    4774             :   PyObject *swig_obj[2] ;
    4775             :   ptrdiff_t result;
    4776             :   
    4777           0 :   if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator_distance",2,2,swig_obj)) SWIG_fail;
    4778           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4779           0 :   if (!SWIG_IsOK(res1)) {
    4780           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
    4781             :   }
    4782           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4783           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
    4784           0 :   if (!SWIG_IsOK(res2)) {
    4785           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
    4786             :   }
    4787           0 :   if (!argp2) {
    4788           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
    4789             :   }
    4790           0 :   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
    4791             :   try {
    4792           0 :     result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
    4793             :   }
    4794           0 :   catch(std::invalid_argument &_e) {
    4795           0 :     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;
    4796             :   }
    4797             :   
    4798             :   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
    4799             :   return resultobj;
    4800             : fail:
    4801             :   return NULL;
    4802             : }
    4803             : 
    4804             : 
    4805           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4806           0 :   PyObject *resultobj = 0;
    4807           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4808           0 :   swig::SwigPyIterator *arg2 = 0 ;
    4809           0 :   void *argp1 = 0 ;
    4810           0 :   int res1 = 0 ;
    4811           0 :   void *argp2 = 0 ;
    4812           0 :   int res2 = 0 ;
    4813             :   PyObject *swig_obj[2] ;
    4814             :   bool result;
    4815             :   
    4816           0 :   if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator_equal",2,2,swig_obj)) SWIG_fail;
    4817           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4818           0 :   if (!SWIG_IsOK(res1)) {
    4819           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
    4820             :   }
    4821           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4822           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
    4823           0 :   if (!SWIG_IsOK(res2)) {
    4824           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
    4825             :   }
    4826           0 :   if (!argp2) {
    4827           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
    4828             :   }
    4829           0 :   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
    4830             :   try {
    4831           0 :     result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
    4832             :   }
    4833           0 :   catch(std::invalid_argument &_e) {
    4834           0 :     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;
    4835             :   }
    4836             :   
    4837             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    4838             :   return resultobj;
    4839             : fail:
    4840             :   return NULL;
    4841             : }
    4842             : 
    4843             : 
    4844           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4845           0 :   PyObject *resultobj = 0;
    4846           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4847           0 :   void *argp1 = 0 ;
    4848           0 :   int res1 = 0 ;
    4849             :   PyObject *swig_obj[1] ;
    4850           0 :   swig::SwigPyIterator *result = 0 ;
    4851             :   
    4852           0 :   if (!args) SWIG_fail;
    4853           0 :   swig_obj[0] = args;
    4854           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4855           0 :   if (!SWIG_IsOK(res1)) {
    4856           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
    4857             :   }
    4858           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4859           0 :   result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
    4860           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
    4861             :   return resultobj;
    4862             : fail:
    4863             :   return NULL;
    4864             : }
    4865             : 
    4866             : 
    4867          19 : SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4868          19 :   PyObject *resultobj = 0;
    4869          19 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4870          19 :   void *argp1 = 0 ;
    4871          19 :   int res1 = 0 ;
    4872             :   PyObject *swig_obj[1] ;
    4873          19 :   PyObject *result = 0 ;
    4874             :   
    4875          19 :   if (!args) SWIG_fail;
    4876          19 :   swig_obj[0] = args;
    4877          19 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4878          19 :   if (!SWIG_IsOK(res1)) {
    4879           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
    4880             :   }
    4881          19 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4882             :   try {
    4883             :     result = (PyObject *)(arg1)->next();
    4884             :   }
    4885          10 :   catch(swig::stop_iteration &_e) {
    4886             :     {
    4887             :       (void)_e;
    4888           5 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    4889             :       SWIG_fail;
    4890             :     }
    4891             :   }
    4892             :   
    4893             :   resultobj = result;
    4894             :   return resultobj;
    4895             : fail:
    4896             :   return NULL;
    4897             : }
    4898             : 
    4899             : 
    4900           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4901           0 :   PyObject *resultobj = 0;
    4902           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4903           0 :   void *argp1 = 0 ;
    4904           0 :   int res1 = 0 ;
    4905             :   PyObject *swig_obj[1] ;
    4906           0 :   PyObject *result = 0 ;
    4907             :   
    4908           0 :   if (!args) SWIG_fail;
    4909           0 :   swig_obj[0] = args;
    4910           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4911           0 :   if (!SWIG_IsOK(res1)) {
    4912           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
    4913             :   }
    4914           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4915             :   try {
    4916             :     result = (PyObject *)(arg1)->__next__();
    4917             :   }
    4918           0 :   catch(swig::stop_iteration &_e) {
    4919             :     {
    4920             :       (void)_e;
    4921           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    4922             :       SWIG_fail;
    4923             :     }
    4924             :   }
    4925             :   
    4926             :   resultobj = result;
    4927             :   return resultobj;
    4928             : fail:
    4929             :   return NULL;
    4930             : }
    4931             : 
    4932             : 
    4933           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4934           0 :   PyObject *resultobj = 0;
    4935           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4936           0 :   void *argp1 = 0 ;
    4937           0 :   int res1 = 0 ;
    4938             :   PyObject *swig_obj[1] ;
    4939           0 :   PyObject *result = 0 ;
    4940             :   
    4941           0 :   if (!args) SWIG_fail;
    4942           0 :   swig_obj[0] = args;
    4943           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4944           0 :   if (!SWIG_IsOK(res1)) {
    4945           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
    4946             :   }
    4947           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4948             :   try {
    4949             :     result = (PyObject *)(arg1)->previous();
    4950             :   }
    4951           0 :   catch(swig::stop_iteration &_e) {
    4952             :     {
    4953             :       (void)_e;
    4954           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    4955             :       SWIG_fail;
    4956             :     }
    4957             :   }
    4958             :   
    4959             :   resultobj = result;
    4960             :   return resultobj;
    4961             : fail:
    4962             :   return NULL;
    4963             : }
    4964             : 
    4965             : 
    4966           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4967           0 :   PyObject *resultobj = 0;
    4968           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    4969             :   ptrdiff_t arg2 ;
    4970           0 :   void *argp1 = 0 ;
    4971           0 :   int res1 = 0 ;
    4972             :   ptrdiff_t val2 ;
    4973           0 :   int ecode2 = 0 ;
    4974             :   PyObject *swig_obj[2] ;
    4975           0 :   swig::SwigPyIterator *result = 0 ;
    4976             :   
    4977           0 :   if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator_advance",2,2,swig_obj)) SWIG_fail;
    4978           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    4979           0 :   if (!SWIG_IsOK(res1)) {
    4980           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
    4981             :   }
    4982           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    4983           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
    4984           0 :   if (!SWIG_IsOK(ecode2)) {
    4985           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
    4986             :   } 
    4987           0 :   arg2 = static_cast< ptrdiff_t >(val2);
    4988             :   try {
    4989           0 :     result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
    4990             :   }
    4991           0 :   catch(swig::stop_iteration &_e) {
    4992             :     {
    4993             :       (void)_e;
    4994           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    4995             :       SWIG_fail;
    4996             :     }
    4997             :   }
    4998             :   
    4999           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    5000             :   return resultobj;
    5001             : fail:
    5002             :   return NULL;
    5003             : }
    5004             : 
    5005             : 
    5006           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5007           0 :   PyObject *resultobj = 0;
    5008           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    5009           0 :   swig::SwigPyIterator *arg2 = 0 ;
    5010           0 :   void *argp1 = 0 ;
    5011           0 :   int res1 = 0 ;
    5012           0 :   void *argp2 = 0 ;
    5013           0 :   int res2 = 0 ;
    5014             :   PyObject *swig_obj[2] ;
    5015             :   bool result;
    5016             :   
    5017           0 :   if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator___eq__",2,2,swig_obj)) SWIG_fail;
    5018           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    5019           0 :   if (!SWIG_IsOK(res1)) {
    5020           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
    5021             :   }
    5022           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    5023           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
    5024           0 :   if (!SWIG_IsOK(res2)) {
    5025           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
    5026             :   }
    5027           0 :   if (!argp2) {
    5028           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
    5029             :   }
    5030           0 :   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
    5031           0 :   result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
    5032             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    5033             :   return resultobj;
    5034             : fail:
    5035             :   return NULL;
    5036             : }
    5037             : 
    5038             : 
    5039           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5040           0 :   PyObject *resultobj = 0;
    5041           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    5042           0 :   swig::SwigPyIterator *arg2 = 0 ;
    5043           0 :   void *argp1 = 0 ;
    5044           0 :   int res1 = 0 ;
    5045           0 :   void *argp2 = 0 ;
    5046           0 :   int res2 = 0 ;
    5047             :   PyObject *swig_obj[2] ;
    5048             :   bool result;
    5049             :   
    5050           0 :   if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator___ne__",2,2,swig_obj)) SWIG_fail;
    5051           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    5052           0 :   if (!SWIG_IsOK(res1)) {
    5053           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
    5054             :   }
    5055           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    5056           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
    5057           0 :   if (!SWIG_IsOK(res2)) {
    5058           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
    5059             :   }
    5060           0 :   if (!argp2) {
    5061           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
    5062             :   }
    5063           0 :   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
    5064           0 :   result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
    5065             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    5066             :   return resultobj;
    5067             : fail:
    5068             :   return NULL;
    5069             : }
    5070             : 
    5071             : 
    5072           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5073           0 :   PyObject *resultobj = 0;
    5074           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    5075             :   ptrdiff_t arg2 ;
    5076           0 :   void *argp1 = 0 ;
    5077           0 :   int res1 = 0 ;
    5078             :   ptrdiff_t val2 ;
    5079           0 :   int ecode2 = 0 ;
    5080             :   PyObject *swig_obj[2] ;
    5081           0 :   swig::SwigPyIterator *result = 0 ;
    5082             :   
    5083           0 :   if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator___iadd__",2,2,swig_obj)) SWIG_fail;
    5084           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
    5085           0 :   if (!SWIG_IsOK(res1)) {
    5086           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
    5087             :   }
    5088           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    5089           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
    5090           0 :   if (!SWIG_IsOK(ecode2)) {
    5091           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
    5092             :   } 
    5093           0 :   arg2 = static_cast< ptrdiff_t >(val2);
    5094             :   try {
    5095           0 :     result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
    5096             :   }
    5097           0 :   catch(swig::stop_iteration &_e) {
    5098             :     {
    5099             :       (void)_e;
    5100           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    5101             :       SWIG_fail;
    5102             :     }
    5103             :   }
    5104             :   
    5105           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
    5106             :   return resultobj;
    5107             : fail:
    5108             :   return NULL;
    5109             : }
    5110             : 
    5111             : 
    5112           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5113           0 :   PyObject *resultobj = 0;
    5114           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    5115             :   ptrdiff_t arg2 ;
    5116           0 :   void *argp1 = 0 ;
    5117           0 :   int res1 = 0 ;
    5118             :   ptrdiff_t val2 ;
    5119           0 :   int ecode2 = 0 ;
    5120             :   PyObject *swig_obj[2] ;
    5121           0 :   swig::SwigPyIterator *result = 0 ;
    5122             :   
    5123           0 :   if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator___isub__",2,2,swig_obj)) SWIG_fail;
    5124           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
    5125           0 :   if (!SWIG_IsOK(res1)) {
    5126           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
    5127             :   }
    5128           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    5129           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
    5130           0 :   if (!SWIG_IsOK(ecode2)) {
    5131           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
    5132             :   } 
    5133           0 :   arg2 = static_cast< ptrdiff_t >(val2);
    5134             :   try {
    5135           0 :     result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
    5136             :   }
    5137           0 :   catch(swig::stop_iteration &_e) {
    5138             :     {
    5139             :       (void)_e;
    5140           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    5141             :       SWIG_fail;
    5142             :     }
    5143             :   }
    5144             :   
    5145           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
    5146             :   return resultobj;
    5147             : fail:
    5148             :   return NULL;
    5149             : }
    5150             : 
    5151             : 
    5152           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5153           0 :   PyObject *resultobj = 0;
    5154           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    5155             :   ptrdiff_t arg2 ;
    5156           0 :   void *argp1 = 0 ;
    5157           0 :   int res1 = 0 ;
    5158             :   ptrdiff_t val2 ;
    5159           0 :   int ecode2 = 0 ;
    5160             :   PyObject *swig_obj[2] ;
    5161           0 :   swig::SwigPyIterator *result = 0 ;
    5162             :   
    5163           0 :   if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator___add__",2,2,swig_obj)) SWIG_fail;
    5164           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    5165           0 :   if (!SWIG_IsOK(res1)) {
    5166           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
    5167             :   }
    5168           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    5169           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
    5170           0 :   if (!SWIG_IsOK(ecode2)) {
    5171           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
    5172             :   } 
    5173           0 :   arg2 = static_cast< ptrdiff_t >(val2);
    5174             :   try {
    5175           0 :     result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
    5176             :   }
    5177           0 :   catch(swig::stop_iteration &_e) {
    5178             :     {
    5179             :       (void)_e;
    5180           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    5181             :       SWIG_fail;
    5182             :     }
    5183             :   }
    5184             :   
    5185           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
    5186             :   return resultobj;
    5187             : fail:
    5188             :   return NULL;
    5189             : }
    5190             : 
    5191             : 
    5192           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    5193           0 :   PyObject *resultobj = 0;
    5194           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    5195             :   ptrdiff_t arg2 ;
    5196           0 :   void *argp1 = 0 ;
    5197           0 :   int res1 = 0 ;
    5198             :   ptrdiff_t val2 ;
    5199           0 :   int ecode2 = 0 ;
    5200           0 :   swig::SwigPyIterator *result = 0 ;
    5201             :   
    5202           0 :   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
    5203           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    5204           0 :   if (!SWIG_IsOK(res1)) {
    5205           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
    5206             :   }
    5207           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    5208           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
    5209           0 :   if (!SWIG_IsOK(ecode2)) {
    5210           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
    5211             :   } 
    5212           0 :   arg2 = static_cast< ptrdiff_t >(val2);
    5213             :   try {
    5214           0 :     result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
    5215             :   }
    5216           0 :   catch(swig::stop_iteration &_e) {
    5217             :     {
    5218             :       (void)_e;
    5219           0 :       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    5220             :       SWIG_fail;
    5221             :     }
    5222             :   }
    5223             :   
    5224           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
    5225             :   return resultobj;
    5226             : fail:
    5227             :   return NULL;
    5228             : }
    5229             : 
    5230             : 
    5231           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    5232           0 :   PyObject *resultobj = 0;
    5233           0 :   swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
    5234           0 :   swig::SwigPyIterator *arg2 = 0 ;
    5235           0 :   void *argp1 = 0 ;
    5236           0 :   int res1 = 0 ;
    5237           0 :   void *argp2 = 0 ;
    5238           0 :   int res2 = 0 ;
    5239             :   ptrdiff_t result;
    5240             :   
    5241           0 :   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
    5242           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    5243           0 :   if (!SWIG_IsOK(res1)) {
    5244           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
    5245             :   }
    5246           0 :   arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
    5247           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
    5248           0 :   if (!SWIG_IsOK(res2)) {
    5249           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
    5250             :   }
    5251           0 :   if (!argp2) {
    5252           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
    5253             :   }
    5254           0 :   arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
    5255           0 :   result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
    5256             :   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
    5257             :   return resultobj;
    5258             : fail:
    5259             :   return NULL;
    5260             : }
    5261             : 
    5262             : 
    5263           0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
    5264             :   Py_ssize_t argc;
    5265             :   PyObject *argv[3] = {
    5266             :     0
    5267           0 :   };
    5268             :   
    5269           0 :   if (!(argc = SWIG_Python_UnpackTuple(args,"SwigPyIterator___sub__",0,2,argv))) SWIG_fail;
    5270           0 :   --argc;
    5271           0 :   if (argc == 2) {
    5272           0 :     int _v = 0;
    5273             :     {
    5274           0 :       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
    5275           0 :       _v = SWIG_CheckState(res);
    5276             :     }
    5277           0 :     if (!_v) goto check_1;
    5278           0 :     return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
    5279             :   }
    5280             : check_1:
    5281             :   
    5282           0 :   if (argc == 2) {
    5283           0 :     return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
    5284             :   }
    5285             :   
    5286             : fail:
    5287           0 :   Py_INCREF(Py_NotImplemented);
    5288           0 :   return Py_NotImplemented;
    5289             : }
    5290             : 
    5291             : 
    5292           3 : SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5293             :   PyObject *obj;
    5294           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    5295           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
    5296           3 :   return SWIG_Py_Void();
    5297             : }
    5298             : 
    5299           0 : SWIGINTERN PyObject *_wrap_Exception_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5300           0 :   PyObject *resultobj = 0;
    5301           0 :   kdb::Exception *arg1 = (kdb::Exception *) 0 ;
    5302           0 :   void *argp1 = 0 ;
    5303           0 :   int res1 = 0 ;
    5304             :   PyObject *swig_obj[1] ;
    5305           0 :   char *result = 0 ;
    5306             :   
    5307           0 :   if (!args) SWIG_fail;
    5308           0 :   swig_obj[0] = args;
    5309           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Exception, 0 |  0 );
    5310           0 :   if (!SWIG_IsOK(res1)) {
    5311           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exception_what" "', argument " "1"" of type '" "kdb::Exception const *""'"); 
    5312             :   }
    5313           0 :   arg1 = reinterpret_cast< kdb::Exception * >(argp1);
    5314           0 :   result = (char *)((kdb::Exception const *)arg1)->what();
    5315           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
    5316             :   return resultobj;
    5317             : fail:
    5318             :   return NULL;
    5319             : }
    5320             : 
    5321             : 
    5322           0 : SWIGINTERN PyObject *_wrap_new_Exception(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5323           0 :   PyObject *resultobj = 0;
    5324           0 :   kdb::Exception *result = 0 ;
    5325             :   
    5326           0 :   if (!SWIG_Python_UnpackTuple(args,"new_Exception",0,0,0)) SWIG_fail;
    5327           0 :   result = (kdb::Exception *)new kdb::Exception();
    5328           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Exception, SWIG_POINTER_NEW |  0 );
    5329           0 :   return resultobj;
    5330             : fail:
    5331             :   return NULL;
    5332             : }
    5333             : 
    5334             : 
    5335           0 : SWIGINTERN PyObject *_wrap_delete_Exception(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5336           0 :   PyObject *resultobj = 0;
    5337           0 :   kdb::Exception *arg1 = (kdb::Exception *) 0 ;
    5338           0 :   void *argp1 = 0 ;
    5339           0 :   int res1 = 0 ;
    5340             :   PyObject *swig_obj[1] ;
    5341             :   
    5342           0 :   if (!args) SWIG_fail;
    5343           0 :   swig_obj[0] = args;
    5344           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Exception, SWIG_POINTER_DISOWN |  0 );
    5345           0 :   if (!SWIG_IsOK(res1)) {
    5346           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Exception" "', argument " "1"" of type '" "kdb::Exception *""'"); 
    5347             :   }
    5348           0 :   arg1 = reinterpret_cast< kdb::Exception * >(argp1);
    5349           0 :   delete arg1;
    5350           0 :   resultobj = SWIG_Py_Void();
    5351           0 :   return resultobj;
    5352             : fail:
    5353             :   return NULL;
    5354             : }
    5355             : 
    5356             : 
    5357           3 : SWIGINTERN PyObject *Exception_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5358             :   PyObject *obj;
    5359           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    5360           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_kdb__Exception, SWIG_NewClientData(obj));
    5361           3 :   return SWIG_Py_Void();
    5362             : }
    5363             : 
    5364           0 : SWIGINTERN PyObject *Exception_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5365           0 :   return SWIG_Python_InitShadowInstance(args);
    5366             : }
    5367             : 
    5368           0 : SWIGINTERN PyObject *_wrap_new_KeyException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5369           0 :   PyObject *resultobj = 0;
    5370           0 :   kdb::KeyException *result = 0 ;
    5371             :   
    5372           0 :   if (!SWIG_Python_UnpackTuple(args,"new_KeyException",0,0,0)) SWIG_fail;
    5373           0 :   result = (kdb::KeyException *)new kdb::KeyException();
    5374           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeyException, SWIG_POINTER_NEW |  0 );
    5375           0 :   return resultobj;
    5376             : fail:
    5377             :   return NULL;
    5378             : }
    5379             : 
    5380             : 
    5381           0 : SWIGINTERN PyObject *_wrap_delete_KeyException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5382           0 :   PyObject *resultobj = 0;
    5383           0 :   kdb::KeyException *arg1 = (kdb::KeyException *) 0 ;
    5384           0 :   void *argp1 = 0 ;
    5385           0 :   int res1 = 0 ;
    5386             :   PyObject *swig_obj[1] ;
    5387             :   
    5388           0 :   if (!args) SWIG_fail;
    5389           0 :   swig_obj[0] = args;
    5390           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeyException, SWIG_POINTER_DISOWN |  0 );
    5391           0 :   if (!SWIG_IsOK(res1)) {
    5392           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeyException" "', argument " "1"" of type '" "kdb::KeyException *""'"); 
    5393             :   }
    5394           0 :   arg1 = reinterpret_cast< kdb::KeyException * >(argp1);
    5395           0 :   delete arg1;
    5396           0 :   resultobj = SWIG_Py_Void();
    5397           0 :   return resultobj;
    5398             : fail:
    5399             :   return NULL;
    5400             : }
    5401             : 
    5402             : 
    5403           3 : SWIGINTERN PyObject *KeyException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5404             :   PyObject *obj;
    5405           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    5406           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeyException, SWIG_NewClientData(obj));
    5407           3 :   return SWIG_Py_Void();
    5408             : }
    5409             : 
    5410           0 : SWIGINTERN PyObject *KeyException_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5411           0 :   return SWIG_Python_InitShadowInstance(args);
    5412             : }
    5413             : 
    5414           0 : SWIGINTERN PyObject *_wrap_new_KeyNotFoundException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5415           0 :   PyObject *resultobj = 0;
    5416           0 :   std::string arg1 ;
    5417             :   PyObject *swig_obj[1] ;
    5418           0 :   kdb::KeyNotFoundException *result = 0 ;
    5419             :   
    5420           0 :   if (!args) SWIG_fail;
    5421           0 :   swig_obj[0] = args;
    5422             :   {
    5423           0 :     std::string *ptr = (std::string *)0;
    5424           0 :     int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    5425           0 :     if (!SWIG_IsOK(res) || !ptr) {
    5426           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_KeyNotFoundException" "', argument " "1"" of type '" "std::string""'"); 
    5427             :     }
    5428           0 :     arg1 = *ptr;
    5429           0 :     if (SWIG_IsNewObj(res)) delete ptr;
    5430             :   }
    5431           0 :   result = (kdb::KeyNotFoundException *)new kdb::KeyNotFoundException(arg1);
    5432           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeyNotFoundException, SWIG_POINTER_NEW |  0 );
    5433             :   return resultobj;
    5434             : fail:
    5435             :   return NULL;
    5436             : }
    5437             : 
    5438             : 
    5439           0 : SWIGINTERN PyObject *_wrap_delete_KeyNotFoundException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5440           0 :   PyObject *resultobj = 0;
    5441           0 :   kdb::KeyNotFoundException *arg1 = (kdb::KeyNotFoundException *) 0 ;
    5442           0 :   void *argp1 = 0 ;
    5443           0 :   int res1 = 0 ;
    5444             :   PyObject *swig_obj[1] ;
    5445             :   
    5446           0 :   if (!args) SWIG_fail;
    5447           0 :   swig_obj[0] = args;
    5448           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeyNotFoundException, SWIG_POINTER_DISOWN |  0 );
    5449           0 :   if (!SWIG_IsOK(res1)) {
    5450           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeyNotFoundException" "', argument " "1"" of type '" "kdb::KeyNotFoundException *""'"); 
    5451             :   }
    5452           0 :   arg1 = reinterpret_cast< kdb::KeyNotFoundException * >(argp1);
    5453           0 :   delete arg1;
    5454           0 :   resultobj = SWIG_Py_Void();
    5455           0 :   return resultobj;
    5456             : fail:
    5457             :   return NULL;
    5458             : }
    5459             : 
    5460             : 
    5461           3 : SWIGINTERN PyObject *KeyNotFoundException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5462             :   PyObject *obj;
    5463           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    5464           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeyNotFoundException, SWIG_NewClientData(obj));
    5465           3 :   return SWIG_Py_Void();
    5466             : }
    5467             : 
    5468           0 : SWIGINTERN PyObject *KeyNotFoundException_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5469           0 :   return SWIG_Python_InitShadowInstance(args);
    5470             : }
    5471             : 
    5472           0 : SWIGINTERN PyObject *_wrap_new_KeyTypeMismatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5473           0 :   PyObject *resultobj = 0;
    5474           0 :   kdb::KeyTypeMismatch *result = 0 ;
    5475             :   
    5476           0 :   if (!SWIG_Python_UnpackTuple(args,"new_KeyTypeMismatch",0,0,0)) SWIG_fail;
    5477           0 :   result = (kdb::KeyTypeMismatch *)new kdb::KeyTypeMismatch();
    5478           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeyTypeMismatch, SWIG_POINTER_NEW |  0 );
    5479           0 :   return resultobj;
    5480             : fail:
    5481             :   return NULL;
    5482             : }
    5483             : 
    5484             : 
    5485           0 : SWIGINTERN PyObject *_wrap_delete_KeyTypeMismatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5486           0 :   PyObject *resultobj = 0;
    5487           0 :   kdb::KeyTypeMismatch *arg1 = (kdb::KeyTypeMismatch *) 0 ;
    5488           0 :   void *argp1 = 0 ;
    5489           0 :   int res1 = 0 ;
    5490             :   PyObject *swig_obj[1] ;
    5491             :   
    5492           0 :   if (!args) SWIG_fail;
    5493           0 :   swig_obj[0] = args;
    5494           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeyTypeMismatch, SWIG_POINTER_DISOWN |  0 );
    5495           0 :   if (!SWIG_IsOK(res1)) {
    5496           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeyTypeMismatch" "', argument " "1"" of type '" "kdb::KeyTypeMismatch *""'"); 
    5497             :   }
    5498           0 :   arg1 = reinterpret_cast< kdb::KeyTypeMismatch * >(argp1);
    5499           0 :   delete arg1;
    5500           0 :   resultobj = SWIG_Py_Void();
    5501           0 :   return resultobj;
    5502             : fail:
    5503             :   return NULL;
    5504             : }
    5505             : 
    5506             : 
    5507           3 : SWIGINTERN PyObject *KeyTypeMismatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5508             :   PyObject *obj;
    5509           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    5510           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeyTypeMismatch, SWIG_NewClientData(obj));
    5511           3 :   return SWIG_Py_Void();
    5512             : }
    5513             : 
    5514           0 : SWIGINTERN PyObject *KeyTypeMismatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5515           0 :   return SWIG_Python_InitShadowInstance(args);
    5516             : }
    5517             : 
    5518           0 : SWIGINTERN PyObject *_wrap_new_KeyTypeConversion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5519           0 :   PyObject *resultobj = 0;
    5520           0 :   kdb::KeyTypeConversion *result = 0 ;
    5521             :   
    5522           0 :   if (!SWIG_Python_UnpackTuple(args,"new_KeyTypeConversion",0,0,0)) SWIG_fail;
    5523           0 :   result = (kdb::KeyTypeConversion *)new kdb::KeyTypeConversion();
    5524           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeyTypeConversion, SWIG_POINTER_NEW |  0 );
    5525           0 :   return resultobj;
    5526             : fail:
    5527             :   return NULL;
    5528             : }
    5529             : 
    5530             : 
    5531           0 : SWIGINTERN PyObject *_wrap_delete_KeyTypeConversion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5532           0 :   PyObject *resultobj = 0;
    5533           0 :   kdb::KeyTypeConversion *arg1 = (kdb::KeyTypeConversion *) 0 ;
    5534           0 :   void *argp1 = 0 ;
    5535           0 :   int res1 = 0 ;
    5536             :   PyObject *swig_obj[1] ;
    5537             :   
    5538           0 :   if (!args) SWIG_fail;
    5539           0 :   swig_obj[0] = args;
    5540           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeyTypeConversion, SWIG_POINTER_DISOWN |  0 );
    5541           0 :   if (!SWIG_IsOK(res1)) {
    5542           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeyTypeConversion" "', argument " "1"" of type '" "kdb::KeyTypeConversion *""'"); 
    5543             :   }
    5544           0 :   arg1 = reinterpret_cast< kdb::KeyTypeConversion * >(argp1);
    5545           0 :   delete arg1;
    5546           0 :   resultobj = SWIG_Py_Void();
    5547           0 :   return resultobj;
    5548             : fail:
    5549             :   return NULL;
    5550             : }
    5551             : 
    5552             : 
    5553           3 : SWIGINTERN PyObject *KeyTypeConversion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5554             :   PyObject *obj;
    5555           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    5556           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeyTypeConversion, SWIG_NewClientData(obj));
    5557           3 :   return SWIG_Py_Void();
    5558             : }
    5559             : 
    5560           0 : SWIGINTERN PyObject *KeyTypeConversion_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5561           0 :   return SWIG_Python_InitShadowInstance(args);
    5562             : }
    5563             : 
    5564           0 : SWIGINTERN PyObject *_wrap_new_KeyInvalidName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5565           0 :   PyObject *resultobj = 0;
    5566           0 :   kdb::KeyInvalidName *result = 0 ;
    5567             :   
    5568           0 :   if (!SWIG_Python_UnpackTuple(args,"new_KeyInvalidName",0,0,0)) SWIG_fail;
    5569           0 :   result = (kdb::KeyInvalidName *)new kdb::KeyInvalidName();
    5570           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeyInvalidName, SWIG_POINTER_NEW |  0 );
    5571           0 :   return resultobj;
    5572             : fail:
    5573             :   return NULL;
    5574             : }
    5575             : 
    5576             : 
    5577           1 : SWIGINTERN PyObject *_wrap_delete_KeyInvalidName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5578           1 :   PyObject *resultobj = 0;
    5579           1 :   kdb::KeyInvalidName *arg1 = (kdb::KeyInvalidName *) 0 ;
    5580           1 :   void *argp1 = 0 ;
    5581           1 :   int res1 = 0 ;
    5582             :   PyObject *swig_obj[1] ;
    5583             :   
    5584           1 :   if (!args) SWIG_fail;
    5585           1 :   swig_obj[0] = args;
    5586           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeyInvalidName, SWIG_POINTER_DISOWN |  0 );
    5587           1 :   if (!SWIG_IsOK(res1)) {
    5588           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeyInvalidName" "', argument " "1"" of type '" "kdb::KeyInvalidName *""'"); 
    5589             :   }
    5590           1 :   arg1 = reinterpret_cast< kdb::KeyInvalidName * >(argp1);
    5591           1 :   delete arg1;
    5592           1 :   resultobj = SWIG_Py_Void();
    5593           1 :   return resultobj;
    5594             : fail:
    5595             :   return NULL;
    5596             : }
    5597             : 
    5598             : 
    5599           3 : SWIGINTERN PyObject *KeyInvalidName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5600             :   PyObject *obj;
    5601           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    5602           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeyInvalidName, SWIG_NewClientData(obj));
    5603           3 :   return SWIG_Py_Void();
    5604             : }
    5605             : 
    5606           0 : SWIGINTERN PyObject *KeyInvalidName_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5607           0 :   return SWIG_Python_InitShadowInstance(args);
    5608             : }
    5609             : 
    5610           0 : SWIGINTERN PyObject *_wrap_new_KDBException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5611           0 :   PyObject *resultobj = 0;
    5612           0 :   Key arg1 ;
    5613             :   void *argp1 ;
    5614           0 :   int res1 = 0 ;
    5615             :   PyObject *swig_obj[1] ;
    5616           0 :   kdb::KDBException *result = 0 ;
    5617             :   
    5618           0 :   if (!args) SWIG_fail;
    5619           0 :   swig_obj[0] = args;
    5620             :   {
    5621           0 :     res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Key,  0  | 0);
    5622           0 :     if (!SWIG_IsOK(res1)) {
    5623           0 :       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KDBException" "', argument " "1"" of type '" "Key""'"); 
    5624             :     }  
    5625           0 :     if (!argp1) {
    5626           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KDBException" "', argument " "1"" of type '" "Key""'");
    5627             :     } else {
    5628           0 :       Key * temp = reinterpret_cast< Key * >(argp1);
    5629           0 :       arg1 = *temp;
    5630           0 :       if (SWIG_IsNewObj(res1)) delete temp;
    5631             :     }
    5632             :   }
    5633           0 :   result = (kdb::KDBException *)new kdb::KDBException(arg1);
    5634           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KDBException, SWIG_POINTER_NEW |  0 );
    5635             :   return resultobj;
    5636             : fail:
    5637             :   return NULL;
    5638             : }
    5639             : 
    5640             : 
    5641           0 : SWIGINTERN PyObject *_wrap_delete_KDBException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5642           0 :   PyObject *resultobj = 0;
    5643           0 :   kdb::KDBException *arg1 = (kdb::KDBException *) 0 ;
    5644           0 :   void *argp1 = 0 ;
    5645           0 :   int res1 = 0 ;
    5646             :   PyObject *swig_obj[1] ;
    5647             :   
    5648           0 :   if (!args) SWIG_fail;
    5649           0 :   swig_obj[0] = args;
    5650           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDBException, SWIG_POINTER_DISOWN |  0 );
    5651           0 :   if (!SWIG_IsOK(res1)) {
    5652           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KDBException" "', argument " "1"" of type '" "kdb::KDBException *""'"); 
    5653             :   }
    5654           0 :   arg1 = reinterpret_cast< kdb::KDBException * >(argp1);
    5655           0 :   delete arg1;
    5656           0 :   resultobj = SWIG_Py_Void();
    5657           0 :   return resultobj;
    5658             : fail:
    5659             :   return NULL;
    5660             : }
    5661             : 
    5662             : 
    5663           0 : SWIGINTERN PyObject *_wrap_KDBException_whatWithArguments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5664           0 :   PyObject *resultobj = 0;
    5665           0 :   kdb::KDBException *arg1 = (kdb::KDBException *) 0 ;
    5666             :   bool arg2 ;
    5667             :   bool arg3 ;
    5668           0 :   void *argp1 = 0 ;
    5669           0 :   int res1 = 0 ;
    5670             :   bool val2 ;
    5671           0 :   int ecode2 = 0 ;
    5672             :   bool val3 ;
    5673           0 :   int ecode3 = 0 ;
    5674             :   PyObject *swig_obj[3] ;
    5675           0 :   char *result = 0 ;
    5676             :   
    5677           0 :   if (!SWIG_Python_UnpackTuple(args,"KDBException_whatWithArguments",3,3,swig_obj)) SWIG_fail;
    5678           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDBException, 0 |  0 );
    5679           0 :   if (!SWIG_IsOK(res1)) {
    5680           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDBException_whatWithArguments" "', argument " "1"" of type '" "kdb::KDBException const *""'"); 
    5681             :   }
    5682           0 :   arg1 = reinterpret_cast< kdb::KDBException * >(argp1);
    5683           0 :   ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
    5684           0 :   if (!SWIG_IsOK(ecode2)) {
    5685           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KDBException_whatWithArguments" "', argument " "2"" of type '" "bool""'");
    5686             :   } 
    5687           0 :   arg2 = static_cast< bool >(val2);
    5688           0 :   ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
    5689           0 :   if (!SWIG_IsOK(ecode3)) {
    5690           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KDBException_whatWithArguments" "', argument " "3"" of type '" "bool""'");
    5691             :   } 
    5692           0 :   arg3 = static_cast< bool >(val3);
    5693           0 :   result = (char *)((kdb::KDBException const *)arg1)->whatWithArguments(arg2,arg3);
    5694           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
    5695             :   return resultobj;
    5696             : fail:
    5697             :   return NULL;
    5698             : }
    5699             : 
    5700             : 
    5701           3 : SWIGINTERN PyObject *KDBException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5702             :   PyObject *obj;
    5703           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    5704           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KDBException, SWIG_NewClientData(obj));
    5705           3 :   return SWIG_Py_Void();
    5706             : }
    5707             : 
    5708           0 : SWIGINTERN PyObject *KDBException_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5709           0 :   return SWIG_Python_InitShadowInstance(args);
    5710             : }
    5711             : 
    5712           0 : SWIGINTERN PyObject *_wrap_new_ContractException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5713           0 :   PyObject *resultobj = 0;
    5714           0 :   Key arg1 ;
    5715             :   void *argp1 ;
    5716           0 :   int res1 = 0 ;
    5717             :   PyObject *swig_obj[1] ;
    5718           0 :   kdb::ContractException *result = 0 ;
    5719             :   
    5720           0 :   if (!args) SWIG_fail;
    5721           0 :   swig_obj[0] = args;
    5722             :   {
    5723           0 :     res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Key,  0  | 0);
    5724           0 :     if (!SWIG_IsOK(res1)) {
    5725           0 :       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContractException" "', argument " "1"" of type '" "Key""'"); 
    5726             :     }  
    5727           0 :     if (!argp1) {
    5728           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContractException" "', argument " "1"" of type '" "Key""'");
    5729             :     } else {
    5730           0 :       Key * temp = reinterpret_cast< Key * >(argp1);
    5731           0 :       arg1 = *temp;
    5732           0 :       if (SWIG_IsNewObj(res1)) delete temp;
    5733             :     }
    5734             :   }
    5735           0 :   result = (kdb::ContractException *)new kdb::ContractException(arg1);
    5736           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__ContractException, SWIG_POINTER_NEW |  0 );
    5737             :   return resultobj;
    5738             : fail:
    5739             :   return NULL;
    5740             : }
    5741             : 
    5742             : 
    5743           0 : SWIGINTERN PyObject *_wrap_delete_ContractException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5744           0 :   PyObject *resultobj = 0;
    5745           0 :   kdb::ContractException *arg1 = (kdb::ContractException *) 0 ;
    5746           0 :   void *argp1 = 0 ;
    5747           0 :   int res1 = 0 ;
    5748             :   PyObject *swig_obj[1] ;
    5749             :   
    5750           0 :   if (!args) SWIG_fail;
    5751           0 :   swig_obj[0] = args;
    5752           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__ContractException, SWIG_POINTER_DISOWN |  0 );
    5753           0 :   if (!SWIG_IsOK(res1)) {
    5754           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContractException" "', argument " "1"" of type '" "kdb::ContractException *""'"); 
    5755             :   }
    5756           0 :   arg1 = reinterpret_cast< kdb::ContractException * >(argp1);
    5757           0 :   delete arg1;
    5758           0 :   resultobj = SWIG_Py_Void();
    5759           0 :   return resultobj;
    5760             : fail:
    5761             :   return NULL;
    5762             : }
    5763             : 
    5764             : 
    5765           3 : SWIGINTERN PyObject *ContractException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5766             :   PyObject *obj;
    5767           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    5768           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_kdb__ContractException, SWIG_NewClientData(obj));
    5769           3 :   return SWIG_Py_Void();
    5770             : }
    5771             : 
    5772           0 : SWIGINTERN PyObject *ContractException_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5773           0 :   return SWIG_Python_InitShadowInstance(args);
    5774             : }
    5775             : 
    5776           8 : SWIGINTERN PyObject *_wrap_new_Key__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
    5777           8 :   PyObject *resultobj = 0;
    5778           8 :   kdb::Key *result = 0 ;
    5779             :   
    5780           8 :   if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
    5781             :   {
    5782             :     try {
    5783          16 :       result = (kdb::Key *)new kdb::Key();    
    5784           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    5785           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    5786           0 :     }    catch (...) {
    5787           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::Key()");    
    5788             :     }
    5789             :   }
    5790           8 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, SWIG_POINTER_NEW |  0 );
    5791             :   return resultobj;
    5792             : fail:
    5793             :   return NULL;
    5794             : }
    5795             : 
    5796             : 
    5797           1 : SWIGINTERN PyObject *_wrap_new_Key__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    5798           1 :   PyObject *resultobj = 0;
    5799           1 :   ckdb::Key *arg1 = (ckdb::Key *) 0 ;
    5800           1 :   void *argp1 = 0 ;
    5801           1 :   int res1 = 0 ;
    5802           1 :   kdb::Key *result = 0 ;
    5803             :   
    5804           1 :   if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
    5805           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__Key, 0 |  0 );
    5806           1 :   if (!SWIG_IsOK(res1)) {
    5807           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Key" "', argument " "1"" of type '" "ckdb::Key *""'"); 
    5808             :   }
    5809           1 :   arg1 = reinterpret_cast< ckdb::Key * >(argp1);
    5810             :   {
    5811             :     try {
    5812           2 :       result = (kdb::Key *)new kdb::Key(arg1);    
    5813           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    5814           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    5815           0 :     }    catch (...) {
    5816           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::Key(ckdb::Key *)");    
    5817             :     }
    5818             :   }
    5819           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, SWIG_POINTER_NEW |  0 );
    5820             :   return resultobj;
    5821             : fail:
    5822             :   return NULL;
    5823             : }
    5824             : 
    5825             : 
    5826           2 : SWIGINTERN PyObject *_wrap_new_Key__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    5827           2 :   PyObject *resultobj = 0;
    5828           2 :   kdb::Key *arg1 = 0 ;
    5829           2 :   void *argp1 = 0 ;
    5830           2 :   int res1 = 0 ;
    5831           2 :   kdb::Key *result = 0 ;
    5832             :   
    5833           2 :   if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
    5834           2 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_kdb__Key,  0 );
    5835           2 :   if (!SWIG_IsOK(res1)) {
    5836           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Key" "', argument " "1"" of type '" "kdb::Key &""'"); 
    5837             :   }
    5838           2 :   if (!argp1) {
    5839           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Key" "', argument " "1"" of type '" "kdb::Key &""'"); 
    5840             :   }
    5841           2 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    5842             :   {
    5843             :     try {
    5844           4 :       result = (kdb::Key *)new kdb::Key(*arg1);    
    5845           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    5846           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    5847           0 :     }    catch (...) {
    5848           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::Key(kdb::Key &)");    
    5849             :     }
    5850             :   }
    5851           2 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, SWIG_POINTER_NEW |  0 );
    5852             :   return resultobj;
    5853             : fail:
    5854             :   return NULL;
    5855             : }
    5856             : 
    5857             : 
    5858           0 : SWIGINTERN PyObject *_wrap_Key__incRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5859           0 :   PyObject *resultobj = 0;
    5860           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    5861           0 :   void *argp1 = 0 ;
    5862           0 :   int res1 = 0 ;
    5863             :   PyObject *swig_obj[1] ;
    5864             :   
    5865           0 :   if (!args) SWIG_fail;
    5866           0 :   swig_obj[0] = args;
    5867           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    5868           0 :   if (!SWIG_IsOK(res1)) {
    5869           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__incRef" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    5870             :   }
    5871           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    5872             :   {
    5873             :     try {
    5874           0 :       ((kdb::Key const *)arg1)->operator ++();    
    5875           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    5876           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    5877           0 :     }    catch (...) {
    5878           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator ++() const");    
    5879             :     }
    5880             :   }
    5881           0 :   resultobj = SWIG_Py_Void();
    5882           0 :   return resultobj;
    5883             : fail:
    5884             :   return NULL;
    5885             : }
    5886             : 
    5887             : 
    5888           0 : SWIGINTERN PyObject *_wrap_Key__decRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5889           0 :   PyObject *resultobj = 0;
    5890           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    5891           0 :   void *argp1 = 0 ;
    5892           0 :   int res1 = 0 ;
    5893             :   PyObject *swig_obj[1] ;
    5894             :   
    5895           0 :   if (!args) SWIG_fail;
    5896           0 :   swig_obj[0] = args;
    5897           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    5898           0 :   if (!SWIG_IsOK(res1)) {
    5899           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__decRef" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    5900             :   }
    5901           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    5902             :   {
    5903             :     try {
    5904           0 :       ((kdb::Key const *)arg1)->operator --();    
    5905           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    5906           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    5907           0 :     }    catch (...) {
    5908           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator --() const");    
    5909             :     }
    5910             :   }
    5911           0 :   resultobj = SWIG_Py_Void();
    5912           0 :   return resultobj;
    5913             : fail:
    5914             :   return NULL;
    5915             : }
    5916             : 
    5917             : 
    5918           0 : SWIGINTERN PyObject *_wrap_Key_getReferenceCounter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5919           0 :   PyObject *resultobj = 0;
    5920           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    5921           0 :   void *argp1 = 0 ;
    5922           0 :   int res1 = 0 ;
    5923             :   PyObject *swig_obj[1] ;
    5924             :   ssize_t result;
    5925             :   
    5926           0 :   if (!args) SWIG_fail;
    5927           0 :   swig_obj[0] = args;
    5928           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    5929           0 :   if (!SWIG_IsOK(res1)) {
    5930           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_getReferenceCounter" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    5931             :   }
    5932           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    5933             :   {
    5934             :     try {
    5935           0 :       result = ((kdb::Key const *)arg1)->getReferenceCounter();    
    5936           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    5937           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    5938           0 :     }    catch (...) {
    5939           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getReferenceCounter() const");    
    5940             :     }
    5941             :   }
    5942           0 :   resultobj = SWIG_From_long(static_cast< long >(result));
    5943             :   return resultobj;
    5944             : fail:
    5945             :   return NULL;
    5946             : }
    5947             : 
    5948             : 
    5949           0 : SWIGINTERN PyObject *_wrap_Key_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5950           0 :   PyObject *resultobj = 0;
    5951           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    5952           0 :   kdb::Key *arg2 = 0 ;
    5953           0 :   void *argp1 = 0 ;
    5954           0 :   int res1 = 0 ;
    5955           0 :   void *argp2 = 0 ;
    5956           0 :   int res2 = 0 ;
    5957             :   PyObject *swig_obj[2] ;
    5958             :   
    5959           0 :   if (!SWIG_Python_UnpackTuple(args,"Key_copy",2,2,swig_obj)) SWIG_fail;
    5960           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    5961           0 :   if (!SWIG_IsOK(res1)) {
    5962           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_copy" "', argument " "1"" of type '" "kdb::Key *""'"); 
    5963             :   }
    5964           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    5965           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    5966           0 :   if (!SWIG_IsOK(res2)) {
    5967           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_copy" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    5968             :   }
    5969           0 :   if (!argp2) {
    5970           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_copy" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    5971             :   }
    5972           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    5973             :   {
    5974             :     try {
    5975           0 :       (arg1)->copy((kdb::Key const &)*arg2);    
    5976           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    5977           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    5978           0 :     }    catch (...) {
    5979           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::copy(kdb::Key const &)");    
    5980             :     }
    5981             :   }
    5982           0 :   resultobj = SWIG_Py_Void();
    5983           0 :   return resultobj;
    5984             : fail:
    5985             :   return NULL;
    5986             : }
    5987             : 
    5988             : 
    5989           0 : SWIGINTERN PyObject *_wrap_Key_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5990           0 :   PyObject *resultobj = 0;
    5991           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    5992           0 :   void *argp1 = 0 ;
    5993           0 :   int res1 = 0 ;
    5994             :   PyObject *swig_obj[1] ;
    5995             :   
    5996           0 :   if (!args) SWIG_fail;
    5997           0 :   swig_obj[0] = args;
    5998           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    5999           0 :   if (!SWIG_IsOK(res1)) {
    6000           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_clear" "', argument " "1"" of type '" "kdb::Key *""'"); 
    6001             :   }
    6002           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6003             :   {
    6004             :     try {
    6005           0 :       (arg1)->clear();    
    6006           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6007           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6008           0 :     }    catch (...) {
    6009           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::clear()");    
    6010             :     }
    6011             :   }
    6012           0 :   resultobj = SWIG_Py_Void();
    6013           0 :   return resultobj;
    6014             : fail:
    6015             :   return NULL;
    6016             : }
    6017             : 
    6018             : 
    6019           4 : SWIGINTERN PyObject *_wrap_Key_getKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6020           4 :   PyObject *resultobj = 0;
    6021           4 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6022           4 :   void *argp1 = 0 ;
    6023           4 :   int res1 = 0 ;
    6024             :   PyObject *swig_obj[1] ;
    6025           4 :   ckdb::Key *result = 0 ;
    6026             :   
    6027           4 :   if (!args) SWIG_fail;
    6028           4 :   swig_obj[0] = args;
    6029           4 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6030           4 :   if (!SWIG_IsOK(res1)) {
    6031           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_getKey" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6032             :   }
    6033           4 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6034             :   {
    6035             :     try {
    6036           4 :       result = (ckdb::Key *)((kdb::Key const *)arg1)->getKey();    
    6037             :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6038             :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6039             :     }    catch (...) {
    6040             :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getKey() const");    
    6041             :     }
    6042             :   }
    6043           4 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__Key, 0 |  0 );
    6044             :   return resultobj;
    6045             : fail:
    6046             :   return NULL;
    6047             : }
    6048             : 
    6049             : 
    6050           0 : SWIGINTERN PyObject *_wrap_Key___ref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6051           0 :   PyObject *resultobj = 0;
    6052           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6053           0 :   void *argp1 = 0 ;
    6054           0 :   int res1 = 0 ;
    6055             :   PyObject *swig_obj[1] ;
    6056           0 :   ckdb::Key *result = 0 ;
    6057             :   
    6058           0 :   if (!args) SWIG_fail;
    6059           0 :   swig_obj[0] = args;
    6060           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6061           0 :   if (!SWIG_IsOK(res1)) {
    6062           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___ref__" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6063             :   }
    6064           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6065             :   {
    6066             :     try {
    6067           0 :       result = (ckdb::Key *)((kdb::Key const *)arg1)->operator *();    
    6068             :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6069             :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6070             :     }    catch (...) {
    6071             :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator *() const");    
    6072             :     }
    6073             :   }
    6074           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__Key, 0 |  0 );
    6075             :   return resultobj;
    6076             : fail:
    6077             :   return NULL;
    6078             : }
    6079             : 
    6080             : 
    6081           0 : SWIGINTERN PyObject *_wrap_Key_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6082           0 :   PyObject *resultobj = 0;
    6083           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6084           0 :   void *argp1 = 0 ;
    6085           0 :   int res1 = 0 ;
    6086             :   PyObject *swig_obj[1] ;
    6087           0 :   ckdb::Key *result = 0 ;
    6088             :   
    6089           0 :   if (!args) SWIG_fail;
    6090           0 :   swig_obj[0] = args;
    6091           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6092           0 :   if (!SWIG_IsOK(res1)) {
    6093           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_release" "', argument " "1"" of type '" "kdb::Key *""'"); 
    6094             :   }
    6095           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6096             :   {
    6097             :     try {
    6098           0 :       result = (ckdb::Key *)(arg1)->release();    
    6099           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6100           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6101           0 :     }    catch (...) {
    6102           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::release()");    
    6103             :     }
    6104             :   }
    6105           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__Key, 0 |  0 );
    6106             :   return resultobj;
    6107             : fail:
    6108             :   return NULL;
    6109             : }
    6110             : 
    6111             : 
    6112           1 : SWIGINTERN PyObject *_wrap_Key_dup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6113           1 :   PyObject *resultobj = 0;
    6114           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6115           1 :   void *argp1 = 0 ;
    6116           1 :   int res1 = 0 ;
    6117             :   PyObject *swig_obj[1] ;
    6118           1 :   ckdb::Key *result = 0 ;
    6119             :   
    6120           1 :   if (!args) SWIG_fail;
    6121           1 :   swig_obj[0] = args;
    6122           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6123           1 :   if (!SWIG_IsOK(res1)) {
    6124           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_dup" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6125             :   }
    6126           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6127             :   {
    6128             :     try {
    6129           1 :       result = (ckdb::Key *)((kdb::Key const *)arg1)->dup();    
    6130           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6131           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6132           0 :     }    catch (...) {
    6133           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::dup() const");    
    6134             :     }
    6135             :   }
    6136           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__Key, 0 |  0 );
    6137             :   return resultobj;
    6138             : fail:
    6139             :   return NULL;
    6140             : }
    6141             : 
    6142             : 
    6143         172 : SWIGINTERN PyObject *_wrap_delete_Key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6144         172 :   PyObject *resultobj = 0;
    6145         172 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6146         172 :   void *argp1 = 0 ;
    6147         172 :   int res1 = 0 ;
    6148             :   PyObject *swig_obj[1] ;
    6149             :   
    6150         172 :   if (!args) SWIG_fail;
    6151         172 :   swig_obj[0] = args;
    6152         172 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, SWIG_POINTER_DISOWN |  0 );
    6153         172 :   if (!SWIG_IsOK(res1)) {
    6154           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Key" "', argument " "1"" of type '" "kdb::Key *""'"); 
    6155             :   }
    6156         172 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6157             :   {
    6158             :     try {
    6159         344 :       delete arg1;    
    6160             :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6161             :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6162             :     }    catch (...) {
    6163             :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::~Key()");    
    6164             :     }
    6165             :   }
    6166         172 :   resultobj = SWIG_Py_Void();
    6167         172 :   return resultobj;
    6168             : fail:
    6169             :   return NULL;
    6170             : }
    6171             : 
    6172             : 
    6173           7 : SWIGINTERN PyObject *_wrap_Key__getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6174           7 :   PyObject *resultobj = 0;
    6175           7 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6176           7 :   void *argp1 = 0 ;
    6177           7 :   int res1 = 0 ;
    6178             :   PyObject *swig_obj[1] ;
    6179          14 :   std::string result;
    6180             :   
    6181           7 :   if (!args) SWIG_fail;
    6182           7 :   swig_obj[0] = args;
    6183           7 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6184           7 :   if (!SWIG_IsOK(res1)) {
    6185           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getName" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6186             :   }
    6187           7 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6188             :   {
    6189             :     try {
    6190          14 :       result = ((kdb::Key const *)arg1)->getName();    
    6191           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6192           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6193           0 :     }    catch (...) {
    6194           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getName() const");    
    6195             :     }
    6196             :   }
    6197          21 :   resultobj = SWIG_From_std_string(static_cast< std::string >(result));
    6198           7 :   return resultobj;
    6199             : fail:
    6200             :   return NULL;
    6201             : }
    6202             : 
    6203             : 
    6204           0 : SWIGINTERN PyObject *_wrap_Key__getNameSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6205           0 :   PyObject *resultobj = 0;
    6206           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6207           0 :   void *argp1 = 0 ;
    6208           0 :   int res1 = 0 ;
    6209             :   PyObject *swig_obj[1] ;
    6210             :   ssize_t result;
    6211             :   
    6212           0 :   if (!args) SWIG_fail;
    6213           0 :   swig_obj[0] = args;
    6214           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6215           0 :   if (!SWIG_IsOK(res1)) {
    6216           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getNameSize" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6217             :   }
    6218           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6219             :   {
    6220             :     try {
    6221           0 :       result = ((kdb::Key const *)arg1)->getNameSize();    
    6222           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6223           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6224           0 :     }    catch (...) {
    6225           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getNameSize() const");    
    6226             :     }
    6227             :   }
    6228           0 :   resultobj = SWIG_From_long(static_cast< long >(result));
    6229             :   return resultobj;
    6230             : fail:
    6231             :   return NULL;
    6232             : }
    6233             : 
    6234             : 
    6235           2 : SWIGINTERN PyObject *_wrap_Key__getBaseName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6236           2 :   PyObject *resultobj = 0;
    6237           2 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6238           2 :   void *argp1 = 0 ;
    6239           2 :   int res1 = 0 ;
    6240             :   PyObject *swig_obj[1] ;
    6241           4 :   std::string result;
    6242             :   
    6243           2 :   if (!args) SWIG_fail;
    6244           2 :   swig_obj[0] = args;
    6245           2 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6246           2 :   if (!SWIG_IsOK(res1)) {
    6247           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getBaseName" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6248             :   }
    6249           2 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6250             :   {
    6251             :     try {
    6252           4 :       result = ((kdb::Key const *)arg1)->getBaseName();    
    6253           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6254           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6255           0 :     }    catch (...) {
    6256           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getBaseName() const");    
    6257             :     }
    6258             :   }
    6259           6 :   resultobj = SWIG_From_std_string(static_cast< std::string >(result));
    6260           2 :   return resultobj;
    6261             : fail:
    6262             :   return NULL;
    6263             : }
    6264             : 
    6265             : 
    6266           0 : SWIGINTERN PyObject *_wrap_Key__getBaseNameSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6267           0 :   PyObject *resultobj = 0;
    6268           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6269           0 :   void *argp1 = 0 ;
    6270           0 :   int res1 = 0 ;
    6271             :   PyObject *swig_obj[1] ;
    6272             :   ssize_t result;
    6273             :   
    6274           0 :   if (!args) SWIG_fail;
    6275           0 :   swig_obj[0] = args;
    6276           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6277           0 :   if (!SWIG_IsOK(res1)) {
    6278           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getBaseNameSize" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6279             :   }
    6280           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6281             :   {
    6282             :     try {
    6283           0 :       result = ((kdb::Key const *)arg1)->getBaseNameSize();    
    6284           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6285           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6286           0 :     }    catch (...) {
    6287           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getBaseNameSize() const");    
    6288             :     }
    6289             :   }
    6290           0 :   resultobj = SWIG_From_long(static_cast< long >(result));
    6291             :   return resultobj;
    6292             : fail:
    6293             :   return NULL;
    6294             : }
    6295             : 
    6296             : 
    6297           4 : SWIGINTERN PyObject *_wrap_Key__setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6298           4 :   PyObject *resultobj = 0;
    6299           4 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6300           4 :   std::string *arg2 = 0 ;
    6301           4 :   void *argp1 = 0 ;
    6302           4 :   int res1 = 0 ;
    6303           4 :   int res2 = SWIG_OLDOBJ ;
    6304             :   PyObject *swig_obj[2] ;
    6305             :   
    6306           4 :   if (!SWIG_Python_UnpackTuple(args,"Key__setName",2,2,swig_obj)) SWIG_fail;
    6307           4 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6308           4 :   if (!SWIG_IsOK(res1)) {
    6309           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__setName" "', argument " "1"" of type '" "kdb::Key *""'"); 
    6310             :   }
    6311           4 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6312             :   {
    6313           4 :     std::string *ptr = (std::string *)0;
    6314           4 :     res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    6315           4 :     if (!SWIG_IsOK(res2)) {
    6316           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key__setName" "', argument " "2"" of type '" "std::string const &""'"); 
    6317             :     }
    6318           4 :     if (!ptr) {
    6319           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key__setName" "', argument " "2"" of type '" "std::string const &""'"); 
    6320             :     }
    6321           4 :     arg2 = ptr;
    6322             :   }
    6323             :   {
    6324             :     try {
    6325           4 :       (arg1)->setName((std::string const &)*arg2);    
    6326           2 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6327           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6328           0 :     }    catch (...) {
    6329           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setName(std::string const &)");    
    6330             :     }
    6331             :   }
    6332           3 :   resultobj = SWIG_Py_Void();
    6333           6 :   if (SWIG_IsNewObj(res2)) delete arg2;
    6334             :   return resultobj;
    6335             : fail:
    6336           2 :   if (SWIG_IsNewObj(res2)) delete arg2;
    6337             :   return NULL;
    6338             : }
    6339             : 
    6340             : 
    6341           0 : SWIGINTERN PyObject *_wrap_Key_addName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6342           0 :   PyObject *resultobj = 0;
    6343           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6344           0 :   std::string *arg2 = 0 ;
    6345           0 :   void *argp1 = 0 ;
    6346           0 :   int res1 = 0 ;
    6347           0 :   int res2 = SWIG_OLDOBJ ;
    6348             :   PyObject *swig_obj[2] ;
    6349             :   
    6350           0 :   if (!SWIG_Python_UnpackTuple(args,"Key_addName",2,2,swig_obj)) SWIG_fail;
    6351           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6352           0 :   if (!SWIG_IsOK(res1)) {
    6353           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_addName" "', argument " "1"" of type '" "kdb::Key *""'"); 
    6354             :   }
    6355           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6356             :   {
    6357           0 :     std::string *ptr = (std::string *)0;
    6358           0 :     res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    6359           0 :     if (!SWIG_IsOK(res2)) {
    6360           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_addName" "', argument " "2"" of type '" "std::string const &""'"); 
    6361             :     }
    6362           0 :     if (!ptr) {
    6363           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_addName" "', argument " "2"" of type '" "std::string const &""'"); 
    6364             :     }
    6365           0 :     arg2 = ptr;
    6366             :   }
    6367             :   {
    6368             :     try {
    6369           0 :       (arg1)->addName((std::string const &)*arg2);    
    6370           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6371           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6372           0 :     }    catch (...) {
    6373           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::addName(std::string const &)");    
    6374             :     }
    6375             :   }
    6376           0 :   resultobj = SWIG_Py_Void();
    6377           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    6378             :   return resultobj;
    6379             : fail:
    6380           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    6381             :   return NULL;
    6382             : }
    6383             : 
    6384             : 
    6385           1 : SWIGINTERN PyObject *_wrap_Key__setBaseName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6386           1 :   PyObject *resultobj = 0;
    6387           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6388           1 :   std::string *arg2 = 0 ;
    6389           1 :   void *argp1 = 0 ;
    6390           1 :   int res1 = 0 ;
    6391           1 :   int res2 = SWIG_OLDOBJ ;
    6392             :   PyObject *swig_obj[2] ;
    6393             :   
    6394           1 :   if (!SWIG_Python_UnpackTuple(args,"Key__setBaseName",2,2,swig_obj)) SWIG_fail;
    6395           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6396           1 :   if (!SWIG_IsOK(res1)) {
    6397           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__setBaseName" "', argument " "1"" of type '" "kdb::Key *""'"); 
    6398             :   }
    6399           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6400             :   {
    6401           1 :     std::string *ptr = (std::string *)0;
    6402           1 :     res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    6403           1 :     if (!SWIG_IsOK(res2)) {
    6404           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key__setBaseName" "', argument " "2"" of type '" "std::string const &""'"); 
    6405             :     }
    6406           1 :     if (!ptr) {
    6407           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key__setBaseName" "', argument " "2"" of type '" "std::string const &""'"); 
    6408             :     }
    6409           1 :     arg2 = ptr;
    6410             :   }
    6411             :   {
    6412             :     try {
    6413           1 :       (arg1)->setBaseName((std::string const &)*arg2);    
    6414           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6415           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6416           0 :     }    catch (...) {
    6417           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setBaseName(std::string const &)");    
    6418             :     }
    6419             :   }
    6420           1 :   resultobj = SWIG_Py_Void();
    6421           2 :   if (SWIG_IsNewObj(res2)) delete arg2;
    6422             :   return resultobj;
    6423             : fail:
    6424           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    6425             :   return NULL;
    6426             : }
    6427             : 
    6428             : 
    6429           0 : SWIGINTERN PyObject *_wrap_Key_addBaseName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6430           0 :   PyObject *resultobj = 0;
    6431           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6432           0 :   std::string *arg2 = 0 ;
    6433           0 :   void *argp1 = 0 ;
    6434           0 :   int res1 = 0 ;
    6435           0 :   int res2 = SWIG_OLDOBJ ;
    6436             :   PyObject *swig_obj[2] ;
    6437             :   
    6438           0 :   if (!SWIG_Python_UnpackTuple(args,"Key_addBaseName",2,2,swig_obj)) SWIG_fail;
    6439           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6440           0 :   if (!SWIG_IsOK(res1)) {
    6441           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_addBaseName" "', argument " "1"" of type '" "kdb::Key *""'"); 
    6442             :   }
    6443           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6444             :   {
    6445           0 :     std::string *ptr = (std::string *)0;
    6446           0 :     res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    6447           0 :     if (!SWIG_IsOK(res2)) {
    6448           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_addBaseName" "', argument " "2"" of type '" "std::string const &""'"); 
    6449             :     }
    6450           0 :     if (!ptr) {
    6451           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_addBaseName" "', argument " "2"" of type '" "std::string const &""'"); 
    6452             :     }
    6453           0 :     arg2 = ptr;
    6454             :   }
    6455             :   {
    6456             :     try {
    6457           0 :       (arg1)->addBaseName((std::string const &)*arg2);    
    6458           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6459           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6460           0 :     }    catch (...) {
    6461           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::addBaseName(std::string const &)");    
    6462             :     }
    6463             :   }
    6464           0 :   resultobj = SWIG_Py_Void();
    6465           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    6466             :   return resultobj;
    6467             : fail:
    6468           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    6469             :   return NULL;
    6470             : }
    6471             : 
    6472             : 
    6473           0 : SWIGINTERN PyObject *_wrap_Key_delBaseName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6474           0 :   PyObject *resultobj = 0;
    6475           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6476           0 :   void *argp1 = 0 ;
    6477           0 :   int res1 = 0 ;
    6478             :   PyObject *swig_obj[1] ;
    6479             :   
    6480           0 :   if (!args) SWIG_fail;
    6481           0 :   swig_obj[0] = args;
    6482           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6483           0 :   if (!SWIG_IsOK(res1)) {
    6484           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_delBaseName" "', argument " "1"" of type '" "kdb::Key *""'"); 
    6485             :   }
    6486           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6487             :   {
    6488             :     try {
    6489           0 :       (arg1)->delBaseName();    
    6490           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6491           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6492           0 :     }    catch (...) {
    6493           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::delBaseName()");    
    6494             :     }
    6495             :   }
    6496           0 :   resultobj = SWIG_Py_Void();
    6497           0 :   return resultobj;
    6498             : fail:
    6499             :   return NULL;
    6500             : }
    6501             : 
    6502             : 
    6503           0 : SWIGINTERN PyObject *_wrap_Key__getFullNameSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6504           0 :   PyObject *resultobj = 0;
    6505           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6506           0 :   void *argp1 = 0 ;
    6507           0 :   int res1 = 0 ;
    6508             :   PyObject *swig_obj[1] ;
    6509             :   ssize_t result;
    6510             :   
    6511           0 :   if (!args) SWIG_fail;
    6512           0 :   swig_obj[0] = args;
    6513           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6514           0 :   if (!SWIG_IsOK(res1)) {
    6515           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getFullNameSize" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6516             :   }
    6517           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6518             :   {
    6519             :     try {
    6520           0 :       result = ((kdb::Key const *)arg1)->getFullNameSize();    
    6521           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6522           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6523           0 :     }    catch (...) {
    6524           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getFullNameSize() const");    
    6525             :     }
    6526             :   }
    6527           0 :   resultobj = SWIG_From_long(static_cast< long >(result));
    6528             :   return resultobj;
    6529             : fail:
    6530             :   return NULL;
    6531             : }
    6532             : 
    6533             : 
    6534           2 : SWIGINTERN PyObject *_wrap_Key__getFullName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6535           2 :   PyObject *resultobj = 0;
    6536           2 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6537           2 :   void *argp1 = 0 ;
    6538           2 :   int res1 = 0 ;
    6539             :   PyObject *swig_obj[1] ;
    6540           4 :   std::string result;
    6541             :   
    6542           2 :   if (!args) SWIG_fail;
    6543           2 :   swig_obj[0] = args;
    6544           2 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6545           2 :   if (!SWIG_IsOK(res1)) {
    6546           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getFullName" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6547             :   }
    6548           2 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6549             :   {
    6550             :     try {
    6551           4 :       result = ((kdb::Key const *)arg1)->getFullName();    
    6552           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6553           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6554           0 :     }    catch (...) {
    6555           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getFullName() const");    
    6556             :     }
    6557             :   }
    6558           6 :   resultobj = SWIG_From_std_string(static_cast< std::string >(result));
    6559           2 :   return resultobj;
    6560             : fail:
    6561             :   return NULL;
    6562             : }
    6563             : 
    6564             : 
    6565          17 : SWIGINTERN PyObject *_wrap_Key___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6566          17 :   PyObject *resultobj = 0;
    6567          17 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6568          17 :   kdb::Key *arg2 = 0 ;
    6569          17 :   void *argp1 = 0 ;
    6570          17 :   int res1 = 0 ;
    6571          17 :   void *argp2 = 0 ;
    6572          17 :   int res2 = 0 ;
    6573             :   PyObject *swig_obj[2] ;
    6574             :   bool result;
    6575             :   
    6576          17 :   if (!SWIG_Python_UnpackTuple(args,"Key___eq__",2,2,swig_obj)) SWIG_fail;
    6577          17 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6578          17 :   if (!SWIG_IsOK(res1)) {
    6579           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___eq__" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6580             :   }
    6581          17 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6582          17 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    6583          17 :   if (!SWIG_IsOK(res2)) {
    6584           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___eq__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6585             :   }
    6586          17 :   if (!argp2) {
    6587           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___eq__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6588             :   }
    6589          17 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    6590             :   {
    6591             :     try {
    6592          17 :       result = (bool)((kdb::Key const *)arg1)->operator ==((kdb::Key const &)*arg2);    
    6593           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6594           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6595           0 :     }    catch (...) {
    6596           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator ==(kdb::Key const &) const");    
    6597             :     }
    6598             :   }
    6599             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6600             :   return resultobj;
    6601             : fail:
    6602             :   return NULL;
    6603             : }
    6604             : 
    6605             : 
    6606           5 : SWIGINTERN PyObject *_wrap_Key___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6607           5 :   PyObject *resultobj = 0;
    6608           5 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6609           5 :   kdb::Key *arg2 = 0 ;
    6610           5 :   void *argp1 = 0 ;
    6611           5 :   int res1 = 0 ;
    6612           5 :   void *argp2 = 0 ;
    6613           5 :   int res2 = 0 ;
    6614             :   PyObject *swig_obj[2] ;
    6615             :   bool result;
    6616             :   
    6617           5 :   if (!SWIG_Python_UnpackTuple(args,"Key___ne__",2,2,swig_obj)) SWIG_fail;
    6618           5 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6619           5 :   if (!SWIG_IsOK(res1)) {
    6620           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___ne__" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6621             :   }
    6622           5 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6623           5 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    6624           5 :   if (!SWIG_IsOK(res2)) {
    6625           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___ne__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6626             :   }
    6627           5 :   if (!argp2) {
    6628           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___ne__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6629             :   }
    6630           5 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    6631             :   {
    6632             :     try {
    6633           5 :       result = (bool)((kdb::Key const *)arg1)->operator !=((kdb::Key const &)*arg2);    
    6634           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6635           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6636           0 :     }    catch (...) {
    6637           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator !=(kdb::Key const &) const");    
    6638             :     }
    6639             :   }
    6640             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6641             :   return resultobj;
    6642             : fail:
    6643             :   return NULL;
    6644             : }
    6645             : 
    6646             : 
    6647           1 : SWIGINTERN PyObject *_wrap_Key___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6648           1 :   PyObject *resultobj = 0;
    6649           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6650           1 :   kdb::Key *arg2 = 0 ;
    6651           1 :   void *argp1 = 0 ;
    6652           1 :   int res1 = 0 ;
    6653           1 :   void *argp2 = 0 ;
    6654           1 :   int res2 = 0 ;
    6655             :   PyObject *swig_obj[2] ;
    6656             :   bool result;
    6657             :   
    6658           1 :   if (!SWIG_Python_UnpackTuple(args,"Key___lt__",2,2,swig_obj)) SWIG_fail;
    6659           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6660           1 :   if (!SWIG_IsOK(res1)) {
    6661           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___lt__" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6662             :   }
    6663           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6664           1 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    6665           1 :   if (!SWIG_IsOK(res2)) {
    6666           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___lt__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6667             :   }
    6668           1 :   if (!argp2) {
    6669           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___lt__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6670             :   }
    6671           1 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    6672             :   {
    6673             :     try {
    6674           1 :       result = (bool)((kdb::Key const *)arg1)->operator <((kdb::Key const &)*arg2);    
    6675           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6676           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6677           0 :     }    catch (...) {
    6678           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator <(kdb::Key const &) const");    
    6679             :     }
    6680             :   }
    6681             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6682             :   return resultobj;
    6683             : fail:
    6684             :   return NULL;
    6685             : }
    6686             : 
    6687             : 
    6688           1 : SWIGINTERN PyObject *_wrap_Key___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6689           1 :   PyObject *resultobj = 0;
    6690           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6691           1 :   kdb::Key *arg2 = 0 ;
    6692           1 :   void *argp1 = 0 ;
    6693           1 :   int res1 = 0 ;
    6694           1 :   void *argp2 = 0 ;
    6695           1 :   int res2 = 0 ;
    6696             :   PyObject *swig_obj[2] ;
    6697             :   bool result;
    6698             :   
    6699           1 :   if (!SWIG_Python_UnpackTuple(args,"Key___le__",2,2,swig_obj)) SWIG_fail;
    6700           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6701           1 :   if (!SWIG_IsOK(res1)) {
    6702           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___le__" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6703             :   }
    6704           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6705           1 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    6706           1 :   if (!SWIG_IsOK(res2)) {
    6707           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___le__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6708             :   }
    6709           1 :   if (!argp2) {
    6710           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___le__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6711             :   }
    6712           1 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    6713             :   {
    6714             :     try {
    6715           1 :       result = (bool)((kdb::Key const *)arg1)->operator <=((kdb::Key const &)*arg2);    
    6716           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6717           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6718           0 :     }    catch (...) {
    6719           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator <=(kdb::Key const &) const");    
    6720             :     }
    6721             :   }
    6722             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6723             :   return resultobj;
    6724             : fail:
    6725             :   return NULL;
    6726             : }
    6727             : 
    6728             : 
    6729           1 : SWIGINTERN PyObject *_wrap_Key___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6730           1 :   PyObject *resultobj = 0;
    6731           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6732           1 :   kdb::Key *arg2 = 0 ;
    6733           1 :   void *argp1 = 0 ;
    6734           1 :   int res1 = 0 ;
    6735           1 :   void *argp2 = 0 ;
    6736           1 :   int res2 = 0 ;
    6737             :   PyObject *swig_obj[2] ;
    6738             :   bool result;
    6739             :   
    6740           1 :   if (!SWIG_Python_UnpackTuple(args,"Key___gt__",2,2,swig_obj)) SWIG_fail;
    6741           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6742           1 :   if (!SWIG_IsOK(res1)) {
    6743           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___gt__" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6744             :   }
    6745           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6746           1 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    6747           1 :   if (!SWIG_IsOK(res2)) {
    6748           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___gt__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6749             :   }
    6750           1 :   if (!argp2) {
    6751           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___gt__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6752             :   }
    6753           1 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    6754             :   {
    6755             :     try {
    6756           1 :       result = (bool)((kdb::Key const *)arg1)->operator >((kdb::Key const &)*arg2);    
    6757           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6758           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6759           0 :     }    catch (...) {
    6760           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator >(kdb::Key const &) const");    
    6761             :     }
    6762             :   }
    6763             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6764             :   return resultobj;
    6765             : fail:
    6766             :   return NULL;
    6767             : }
    6768             : 
    6769             : 
    6770           1 : SWIGINTERN PyObject *_wrap_Key___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6771           1 :   PyObject *resultobj = 0;
    6772           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6773           1 :   kdb::Key *arg2 = 0 ;
    6774           1 :   void *argp1 = 0 ;
    6775           1 :   int res1 = 0 ;
    6776           1 :   void *argp2 = 0 ;
    6777           1 :   int res2 = 0 ;
    6778             :   PyObject *swig_obj[2] ;
    6779             :   bool result;
    6780             :   
    6781           1 :   if (!SWIG_Python_UnpackTuple(args,"Key___ge__",2,2,swig_obj)) SWIG_fail;
    6782           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6783           1 :   if (!SWIG_IsOK(res1)) {
    6784           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___ge__" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6785             :   }
    6786           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6787           1 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    6788           1 :   if (!SWIG_IsOK(res2)) {
    6789           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___ge__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6790             :   }
    6791           1 :   if (!argp2) {
    6792           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___ge__" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    6793             :   }
    6794           1 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    6795             :   {
    6796             :     try {
    6797           1 :       result = (bool)((kdb::Key const *)arg1)->operator >=((kdb::Key const &)*arg2);    
    6798           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6799           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6800           0 :     }    catch (...) {
    6801           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator >=(kdb::Key const &) const");    
    6802             :     }
    6803             :   }
    6804             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6805             :   return resultobj;
    6806             : fail:
    6807             :   return NULL;
    6808             : }
    6809             : 
    6810             : 
    6811           0 : SWIGINTERN PyObject *_wrap_Key_isNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6812           0 :   PyObject *resultobj = 0;
    6813           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6814           0 :   void *argp1 = 0 ;
    6815           0 :   int res1 = 0 ;
    6816             :   PyObject *swig_obj[1] ;
    6817             :   bool result;
    6818             :   
    6819           0 :   if (!args) SWIG_fail;
    6820           0 :   swig_obj[0] = args;
    6821           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6822           0 :   if (!SWIG_IsOK(res1)) {
    6823           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isNull" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6824             :   }
    6825           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6826             :   {
    6827             :     try {
    6828           0 :       result = (bool)((kdb::Key const *)arg1)->isNull();    
    6829             :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6830             :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6831             :     }    catch (...) {
    6832             :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isNull() const");    
    6833             :     }
    6834             :   }
    6835             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6836             :   return resultobj;
    6837             : fail:
    6838             :   return NULL;
    6839             : }
    6840             : 
    6841             : 
    6842          49 : SWIGINTERN PyObject *_wrap_Key___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6843          49 :   PyObject *resultobj = 0;
    6844          49 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6845          49 :   void *argp1 = 0 ;
    6846          49 :   int res1 = 0 ;
    6847             :   PyObject *swig_obj[1] ;
    6848             :   bool result;
    6849             :   
    6850          49 :   if (!args) SWIG_fail;
    6851          49 :   swig_obj[0] = args;
    6852          49 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6853          49 :   if (!SWIG_IsOK(res1)) {
    6854           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___nonzero__" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6855             :   }
    6856          49 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6857             :   {
    6858             :     try {
    6859          49 :       result = (bool)((kdb::Key const *)arg1)->operator bool();    
    6860             :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6861             :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6862             :     }    catch (...) {
    6863             :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator bool() const");    
    6864             :     }
    6865             :   }
    6866             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6867             :   return resultobj;
    6868             : fail:
    6869             :   return NULL;
    6870             : }
    6871             : 
    6872             : 
    6873           0 : SWIGINTERN PyObject *_wrap_Key_needSync(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6874           0 :   PyObject *resultobj = 0;
    6875           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6876           0 :   void *argp1 = 0 ;
    6877           0 :   int res1 = 0 ;
    6878             :   PyObject *swig_obj[1] ;
    6879             :   bool result;
    6880             :   
    6881           0 :   if (!args) SWIG_fail;
    6882           0 :   swig_obj[0] = args;
    6883           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6884           0 :   if (!SWIG_IsOK(res1)) {
    6885           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_needSync" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6886             :   }
    6887           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6888             :   {
    6889             :     try {
    6890           0 :       result = (bool)((kdb::Key const *)arg1)->needSync();    
    6891           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6892           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6893           0 :     }    catch (...) {
    6894           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::needSync() const");    
    6895             :     }
    6896             :   }
    6897             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6898             :   return resultobj;
    6899             : fail:
    6900             :   return NULL;
    6901             : }
    6902             : 
    6903             : 
    6904           7 : SWIGINTERN PyObject *_wrap_Key__getString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6905           7 :   PyObject *resultobj = 0;
    6906           7 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6907           7 :   void *argp1 = 0 ;
    6908           7 :   int res1 = 0 ;
    6909             :   PyObject *swig_obj[1] ;
    6910          14 :   std::string result;
    6911             :   
    6912           7 :   if (!args) SWIG_fail;
    6913           7 :   swig_obj[0] = args;
    6914           7 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6915           7 :   if (!SWIG_IsOK(res1)) {
    6916           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getString" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6917             :   }
    6918           7 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6919             :   {
    6920             :     try {
    6921          14 :       result = ((kdb::Key const *)arg1)->getString();    
    6922           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6923           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6924           0 :     }    catch (...) {
    6925           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getString() const");    
    6926             :     }
    6927             :   }
    6928          21 :   resultobj = SWIG_From_std_string(static_cast< std::string >(result));
    6929           7 :   return resultobj;
    6930             : fail:
    6931             :   return NULL;
    6932             : }
    6933             : 
    6934             : 
    6935          10 : SWIGINTERN PyObject *_wrap_Key__setString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6936          10 :   PyObject *resultobj = 0;
    6937          10 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6938          20 :   std::string arg2 ;
    6939          10 :   void *argp1 = 0 ;
    6940          10 :   int res1 = 0 ;
    6941             :   PyObject *swig_obj[2] ;
    6942             :   
    6943          10 :   if (!SWIG_Python_UnpackTuple(args,"Key__setString",2,2,swig_obj)) SWIG_fail;
    6944          10 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6945          10 :   if (!SWIG_IsOK(res1)) {
    6946           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__setString" "', argument " "1"" of type '" "kdb::Key *""'"); 
    6947             :   }
    6948          10 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6949             :   {
    6950          10 :     std::string *ptr = (std::string *)0;
    6951          10 :     int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    6952          10 :     if (!SWIG_IsOK(res) || !ptr) {
    6953           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Key__setString" "', argument " "2"" of type '" "std::string""'"); 
    6954             :     }
    6955          20 :     arg2 = *ptr;
    6956          20 :     if (SWIG_IsNewObj(res)) delete ptr;
    6957             :   }
    6958             :   {
    6959             :     try {
    6960          30 :       (arg1)->setString(arg2);    
    6961           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6962           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6963           0 :     }    catch (...) {
    6964           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setString(std::string)");    
    6965             :     }
    6966             :   }
    6967          10 :   resultobj = SWIG_Py_Void();
    6968          10 :   return resultobj;
    6969             : fail:
    6970             :   return NULL;
    6971             : }
    6972             : 
    6973             : 
    6974           0 : SWIGINTERN PyObject *_wrap_Key__getStringSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6975           0 :   PyObject *resultobj = 0;
    6976           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    6977           0 :   void *argp1 = 0 ;
    6978           0 :   int res1 = 0 ;
    6979             :   PyObject *swig_obj[1] ;
    6980             :   ssize_t result;
    6981             :   
    6982           0 :   if (!args) SWIG_fail;
    6983           0 :   swig_obj[0] = args;
    6984           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    6985           0 :   if (!SWIG_IsOK(res1)) {
    6986           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getStringSize" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    6987             :   }
    6988           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    6989             :   {
    6990             :     try {
    6991           0 :       result = ((kdb::Key const *)arg1)->getStringSize();    
    6992           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    6993           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    6994           0 :     }    catch (...) {
    6995           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getStringSize() const");    
    6996             :     }
    6997             :   }
    6998           0 :   resultobj = SWIG_From_long(static_cast< long >(result));
    6999             :   return resultobj;
    7000             : fail:
    7001             :   return NULL;
    7002             : }
    7003             : 
    7004             : 
    7005           0 : SWIGINTERN PyObject *_wrap_Key__getFunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7006           0 :   PyObject *resultobj = 0;
    7007           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7008           0 :   void *argp1 = 0 ;
    7009           0 :   int res1 = 0 ;
    7010             :   PyObject *swig_obj[1] ;
    7011             :   kdb::Key::func_t result;
    7012             :   
    7013           0 :   if (!args) SWIG_fail;
    7014           0 :   swig_obj[0] = args;
    7015           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7016           0 :   if (!SWIG_IsOK(res1)) {
    7017           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getFunc" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7018             :   }
    7019           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7020             :   {
    7021             :     try {
    7022           0 :       result = (kdb::Key::func_t)((kdb::Key const *)arg1)->getFunc();    
    7023           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7024           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7025           0 :     }    catch (...) {
    7026           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getFunc() const");    
    7027             :     }
    7028             :   }
    7029           0 :   resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f___void);
    7030             :   return resultobj;
    7031             : fail:
    7032             :   return NULL;
    7033             : }
    7034             : 
    7035             : 
    7036           0 : SWIGINTERN PyObject *_wrap_Key_setCallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7037           0 :   PyObject *resultobj = 0;
    7038           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7039           0 :   kdb::Key::callback_t arg2 = (kdb::Key::callback_t) 0 ;
    7040           0 :   void *argp1 = 0 ;
    7041           0 :   int res1 = 0 ;
    7042             :   PyObject *swig_obj[2] ;
    7043             :   
    7044           0 :   if (!SWIG_Python_UnpackTuple(args,"Key_setCallback",2,2,swig_obj)) SWIG_fail;
    7045           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7046           0 :   if (!SWIG_IsOK(res1)) {
    7047           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_setCallback" "', argument " "1"" of type '" "kdb::Key *""'"); 
    7048             :   }
    7049           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7050             :   {
    7051           0 :     int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p__KeySet_p__Key_p__Key_option_t__p__Key);
    7052           0 :     if (!SWIG_IsOK(res)) {
    7053           0 :       SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Key_setCallback" "', argument " "2"" of type '" "kdb::Key::callback_t""'"); 
    7054             :     }
    7055             :   }
    7056             :   {
    7057             :     try {
    7058           0 :       (arg1)->setCallback(arg2);    
    7059           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7060           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7061           0 :     }    catch (...) {
    7062           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setCallback(kdb::Key::callback_t)");    
    7063             :     }
    7064             :   }
    7065           0 :   resultobj = SWIG_Py_Void();
    7066           0 :   return resultobj;
    7067             : fail:
    7068             :   return NULL;
    7069             : }
    7070             : 
    7071             : 
    7072           0 : SWIGINTERN PyObject *_wrap_Key__getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7073           0 :   PyObject *resultobj = 0;
    7074           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7075           0 :   void *argp1 = 0 ;
    7076           0 :   int res1 = 0 ;
    7077             :   PyObject *swig_obj[1] ;
    7078           0 :   void *result = 0 ;
    7079             :   
    7080           0 :   if (!args) SWIG_fail;
    7081           0 :   swig_obj[0] = args;
    7082           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7083           0 :   if (!SWIG_IsOK(res1)) {
    7084           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getValue" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7085             :   }
    7086           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7087             :   {
    7088             :     try {
    7089           0 :       result = (void *)((kdb::Key const *)arg1)->getValue();    
    7090           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7091           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7092           0 :     }    catch (...) {
    7093           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getValue() const");    
    7094             :     }
    7095             :   }
    7096             :   {
    7097           0 :     ssize_t size = arg1->getBinarySize();
    7098           0 :     resultobj = PyBytes_FromStringAndSize((const char*)result, (size > 0) ? size : 0);
    7099             :   }
    7100             :   return resultobj;
    7101             : fail:
    7102             :   return NULL;
    7103             : }
    7104             : 
    7105             : 
    7106           2 : SWIGINTERN PyObject *_wrap_Key__getBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7107           2 :   PyObject *resultobj = 0;
    7108           2 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7109           2 :   void *argp1 = 0 ;
    7110           2 :   int res1 = 0 ;
    7111             :   PyObject *swig_obj[1] ;
    7112           4 :   std::string result;
    7113             :   
    7114           2 :   if (!args) SWIG_fail;
    7115           2 :   swig_obj[0] = args;
    7116           2 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7117           2 :   if (!SWIG_IsOK(res1)) {
    7118           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getBinary" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7119             :   }
    7120           2 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7121             :   {
    7122             :     try {
    7123           4 :       result = ((kdb::Key const *)arg1)->getBinary();    
    7124           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7125           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7126           0 :     }    catch (...) {
    7127           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getBinary() const");    
    7128             :     }
    7129             :   }
    7130             :   {
    7131           4 :     resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
    7132             :   }
    7133             :   return resultobj;
    7134             : fail:
    7135             :   return NULL;
    7136             : }
    7137             : 
    7138             : 
    7139           0 : SWIGINTERN PyObject *_wrap_Key__getBinarySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7140           0 :   PyObject *resultobj = 0;
    7141           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7142           0 :   void *argp1 = 0 ;
    7143           0 :   int res1 = 0 ;
    7144             :   PyObject *swig_obj[1] ;
    7145             :   ssize_t result;
    7146             :   
    7147           0 :   if (!args) SWIG_fail;
    7148           0 :   swig_obj[0] = args;
    7149           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7150           0 :   if (!SWIG_IsOK(res1)) {
    7151           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getBinarySize" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7152             :   }
    7153           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7154             :   {
    7155             :     try {
    7156           0 :       result = ((kdb::Key const *)arg1)->getBinarySize();    
    7157           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7158           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7159           0 :     }    catch (...) {
    7160           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getBinarySize() const");    
    7161             :     }
    7162             :   }
    7163           0 :   resultobj = SWIG_From_long(static_cast< long >(result));
    7164             :   return resultobj;
    7165             : fail:
    7166             :   return NULL;
    7167             : }
    7168             : 
    7169             : 
    7170           8 : SWIGINTERN PyObject *_wrap_Key__setBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7171           8 :   PyObject *resultobj = 0;
    7172           8 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7173           8 :   void *arg2 = (void *) 0 ;
    7174             :   size_t arg3 ;
    7175           8 :   void *argp1 = 0 ;
    7176           8 :   int res1 = 0 ;
    7177             :   PyObject *swig_obj[2] ;
    7178             :   ssize_t result;
    7179             :   
    7180           8 :   if (!SWIG_Python_UnpackTuple(args,"Key__setBinary",2,2,swig_obj)) SWIG_fail;
    7181           8 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7182           8 :   if (!SWIG_IsOK(res1)) {
    7183           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__setBinary" "', argument " "1"" of type '" "kdb::Key *""'"); 
    7184             :   }
    7185           8 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7186             :   {
    7187             :     Py_ssize_t len;
    7188           8 :     if (PyBytes_AsStringAndSize(swig_obj[1], reinterpret_cast<char **>(&arg2), &len) == -1)
    7189           0 :     return NULL;
    7190           8 :     arg3 = len;
    7191             :   }
    7192             :   {
    7193             :     try {
    7194          16 :       result = (arg1)->setBinary((void const *)arg2,arg3);    
    7195           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7196           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7197           0 :     }    catch (...) {
    7198           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setBinary(void const *,size_t)");    
    7199             :     }
    7200             :   }
    7201           8 :   resultobj = SWIG_From_long(static_cast< long >(result));
    7202             :   return resultobj;
    7203             : fail:
    7204             :   return NULL;
    7205             : }
    7206             : 
    7207             : 
    7208           1 : SWIGINTERN PyObject *_wrap_Key_hasMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7209           1 :   PyObject *resultobj = 0;
    7210           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7211           1 :   std::string *arg2 = 0 ;
    7212           1 :   void *argp1 = 0 ;
    7213           1 :   int res1 = 0 ;
    7214           1 :   int res2 = SWIG_OLDOBJ ;
    7215             :   PyObject *swig_obj[2] ;
    7216             :   bool result;
    7217             :   
    7218           1 :   if (!SWIG_Python_UnpackTuple(args,"Key_hasMeta",2,2,swig_obj)) SWIG_fail;
    7219           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7220           1 :   if (!SWIG_IsOK(res1)) {
    7221           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_hasMeta" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7222             :   }
    7223           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7224             :   {
    7225           1 :     std::string *ptr = (std::string *)0;
    7226           1 :     res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    7227           1 :     if (!SWIG_IsOK(res2)) {
    7228           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_hasMeta" "', argument " "2"" of type '" "std::string const &""'"); 
    7229             :     }
    7230           1 :     if (!ptr) {
    7231           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_hasMeta" "', argument " "2"" of type '" "std::string const &""'"); 
    7232             :     }
    7233           1 :     arg2 = ptr;
    7234             :   }
    7235             :   {
    7236             :     try {
    7237           2 :       result = (bool)((kdb::Key const *)arg1)->hasMeta((std::string const &)*arg2);    
    7238           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7239           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7240           0 :     }    catch (...) {
    7241           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::hasMeta(std::string const &) const");    
    7242             :     }
    7243             :   }
    7244           1 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7245           2 :   if (SWIG_IsNewObj(res2)) delete arg2;
    7246             :   return resultobj;
    7247             : fail:
    7248           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    7249             :   return NULL;
    7250             : }
    7251             : 
    7252             : 
    7253           0 : SWIGINTERN PyObject *_wrap_Key_delMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7254           0 :   PyObject *resultobj = 0;
    7255           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7256           0 :   std::string *arg2 = 0 ;
    7257           0 :   void *argp1 = 0 ;
    7258           0 :   int res1 = 0 ;
    7259           0 :   int res2 = SWIG_OLDOBJ ;
    7260             :   PyObject *swig_obj[2] ;
    7261             :   
    7262           0 :   if (!SWIG_Python_UnpackTuple(args,"Key_delMeta",2,2,swig_obj)) SWIG_fail;
    7263           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7264           0 :   if (!SWIG_IsOK(res1)) {
    7265           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_delMeta" "', argument " "1"" of type '" "kdb::Key *""'"); 
    7266             :   }
    7267           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7268             :   {
    7269           0 :     std::string *ptr = (std::string *)0;
    7270           0 :     res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    7271           0 :     if (!SWIG_IsOK(res2)) {
    7272           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_delMeta" "', argument " "2"" of type '" "std::string const &""'"); 
    7273             :     }
    7274           0 :     if (!ptr) {
    7275           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_delMeta" "', argument " "2"" of type '" "std::string const &""'"); 
    7276             :     }
    7277           0 :     arg2 = ptr;
    7278             :   }
    7279             :   {
    7280             :     try {
    7281           0 :       (arg1)->delMeta((std::string const &)*arg2);    
    7282           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7283           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7284           0 :     }    catch (...) {
    7285           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::delMeta(std::string const &)");    
    7286             :     }
    7287             :   }
    7288           0 :   resultobj = SWIG_Py_Void();
    7289           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    7290             :   return resultobj;
    7291             : fail:
    7292           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    7293             :   return NULL;
    7294             : }
    7295             : 
    7296             : 
    7297           0 : SWIGINTERN PyObject *_wrap_Key_copyMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7298           0 :   PyObject *resultobj = 0;
    7299           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7300           0 :   kdb::Key *arg2 = 0 ;
    7301           0 :   std::string *arg3 = 0 ;
    7302           0 :   void *argp1 = 0 ;
    7303           0 :   int res1 = 0 ;
    7304           0 :   void *argp2 = 0 ;
    7305           0 :   int res2 = 0 ;
    7306           0 :   int res3 = SWIG_OLDOBJ ;
    7307             :   PyObject *swig_obj[3] ;
    7308             :   
    7309           0 :   if (!SWIG_Python_UnpackTuple(args,"Key_copyMeta",3,3,swig_obj)) SWIG_fail;
    7310           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7311           0 :   if (!SWIG_IsOK(res1)) {
    7312           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_copyMeta" "', argument " "1"" of type '" "kdb::Key *""'"); 
    7313             :   }
    7314           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7315           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    7316           0 :   if (!SWIG_IsOK(res2)) {
    7317           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_copyMeta" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    7318             :   }
    7319           0 :   if (!argp2) {
    7320           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_copyMeta" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    7321             :   }
    7322           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    7323             :   {
    7324           0 :     std::string *ptr = (std::string *)0;
    7325           0 :     res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    7326           0 :     if (!SWIG_IsOK(res3)) {
    7327           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Key_copyMeta" "', argument " "3"" of type '" "std::string const &""'"); 
    7328             :     }
    7329           0 :     if (!ptr) {
    7330           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_copyMeta" "', argument " "3"" of type '" "std::string const &""'"); 
    7331             :     }
    7332           0 :     arg3 = ptr;
    7333             :   }
    7334             :   {
    7335             :     try {
    7336           0 :       (arg1)->copyMeta((kdb::Key const &)*arg2,(std::string const &)*arg3);    
    7337           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7338           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7339           0 :     }    catch (...) {
    7340           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::copyMeta(kdb::Key const &,std::string const &)");    
    7341             :     }
    7342             :   }
    7343           0 :   resultobj = SWIG_Py_Void();
    7344           0 :   if (SWIG_IsNewObj(res3)) delete arg3;
    7345             :   return resultobj;
    7346             : fail:
    7347           0 :   if (SWIG_IsNewObj(res3)) delete arg3;
    7348             :   return NULL;
    7349             : }
    7350             : 
    7351             : 
    7352           0 : SWIGINTERN PyObject *_wrap_Key_copyAllMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7353           0 :   PyObject *resultobj = 0;
    7354           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7355           0 :   kdb::Key *arg2 = 0 ;
    7356           0 :   void *argp1 = 0 ;
    7357           0 :   int res1 = 0 ;
    7358           0 :   void *argp2 = 0 ;
    7359           0 :   int res2 = 0 ;
    7360             :   PyObject *swig_obj[2] ;
    7361             :   
    7362           0 :   if (!SWIG_Python_UnpackTuple(args,"Key_copyAllMeta",2,2,swig_obj)) SWIG_fail;
    7363           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7364           0 :   if (!SWIG_IsOK(res1)) {
    7365           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_copyAllMeta" "', argument " "1"" of type '" "kdb::Key *""'"); 
    7366             :   }
    7367           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7368           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    7369           0 :   if (!SWIG_IsOK(res2)) {
    7370           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_copyAllMeta" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    7371             :   }
    7372           0 :   if (!argp2) {
    7373           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_copyAllMeta" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    7374             :   }
    7375           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    7376             :   {
    7377             :     try {
    7378           0 :       (arg1)->copyAllMeta((kdb::Key const &)*arg2);    
    7379           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7380           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7381           0 :     }    catch (...) {
    7382           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::copyAllMeta(kdb::Key const &)");    
    7383             :     }
    7384             :   }
    7385           0 :   resultobj = SWIG_Py_Void();
    7386           0 :   return resultobj;
    7387             : fail:
    7388             :   return NULL;
    7389             : }
    7390             : 
    7391             : 
    7392           2 : SWIGINTERN PyObject *_wrap_Key__rewindMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7393           2 :   PyObject *resultobj = 0;
    7394           2 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7395           2 :   void *argp1 = 0 ;
    7396           2 :   int res1 = 0 ;
    7397             :   PyObject *swig_obj[1] ;
    7398             :   
    7399           2 :   if (!args) SWIG_fail;
    7400           2 :   swig_obj[0] = args;
    7401           2 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7402           2 :   if (!SWIG_IsOK(res1)) {
    7403           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__rewindMeta" "', argument " "1"" of type '" "kdb::Key *""'"); 
    7404             :   }
    7405           2 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7406             :   {
    7407             :     try {
    7408           2 :       (arg1)->rewindMeta();    
    7409           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7410           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7411           0 :     }    catch (...) {
    7412           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::rewindMeta()");    
    7413             :     }
    7414             :   }
    7415           2 :   resultobj = SWIG_Py_Void();
    7416           2 :   return resultobj;
    7417             : fail:
    7418             :   return NULL;
    7419             : }
    7420             : 
    7421             : 
    7422           5 : SWIGINTERN PyObject *_wrap_Key__nextMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7423           5 :   PyObject *resultobj = 0;
    7424           5 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7425           5 :   void *argp1 = 0 ;
    7426           5 :   int res1 = 0 ;
    7427             :   PyObject *swig_obj[1] ;
    7428          10 :   kdb::Key result;
    7429             :   
    7430           5 :   if (!args) SWIG_fail;
    7431           5 :   swig_obj[0] = args;
    7432           5 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7433           5 :   if (!SWIG_IsOK(res1)) {
    7434           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__nextMeta" "', argument " "1"" of type '" "kdb::Key *""'"); 
    7435             :   }
    7436           5 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7437             :   {
    7438             :     try {
    7439          15 :       result = (arg1)->nextMeta();    
    7440           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7441           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7442           0 :     }    catch (...) {
    7443           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::nextMeta()");    
    7444             :     }
    7445             :   }
    7446          10 :   resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN |  0 );
    7447             :   return resultobj;
    7448             : fail:
    7449             :   return NULL;
    7450             : }
    7451             : 
    7452             : 
    7453           0 : SWIGINTERN PyObject *_wrap_Key__currentMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7454           0 :   PyObject *resultobj = 0;
    7455           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7456           0 :   void *argp1 = 0 ;
    7457           0 :   int res1 = 0 ;
    7458             :   PyObject *swig_obj[1] ;
    7459           0 :   kdb::Key result;
    7460             :   
    7461           0 :   if (!args) SWIG_fail;
    7462           0 :   swig_obj[0] = args;
    7463           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7464           0 :   if (!SWIG_IsOK(res1)) {
    7465           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__currentMeta" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7466             :   }
    7467           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7468             :   {
    7469             :     try {
    7470           0 :       result = ((kdb::Key const *)arg1)->currentMeta();    
    7471           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7472           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7473           0 :     }    catch (...) {
    7474           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::currentMeta() const");    
    7475             :     }
    7476             :   }
    7477           0 :   resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN |  0 );
    7478             :   return resultobj;
    7479             : fail:
    7480             :   return NULL;
    7481             : }
    7482             : 
    7483             : 
    7484          11 : SWIGINTERN PyObject *_wrap_Key_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7485          11 :   PyObject *resultobj = 0;
    7486          11 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7487          11 :   void *argp1 = 0 ;
    7488          11 :   int res1 = 0 ;
    7489             :   PyObject *swig_obj[1] ;
    7490             :   bool result;
    7491             :   
    7492          11 :   if (!args) SWIG_fail;
    7493          11 :   swig_obj[0] = args;
    7494          11 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7495          11 :   if (!SWIG_IsOK(res1)) {
    7496           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isValid" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7497             :   }
    7498          11 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7499             :   {
    7500             :     try {
    7501          11 :       result = (bool)((kdb::Key const *)arg1)->isValid();    
    7502           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7503           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7504           0 :     }    catch (...) {
    7505           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isValid() const");    
    7506             :     }
    7507             :   }
    7508             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7509             :   return resultobj;
    7510             : fail:
    7511             :   return NULL;
    7512             : }
    7513             : 
    7514             : 
    7515           0 : SWIGINTERN PyObject *_wrap_Key_getNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7516           0 :   PyObject *resultobj = 0;
    7517           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7518           0 :   void *argp1 = 0 ;
    7519           0 :   int res1 = 0 ;
    7520             :   PyObject *swig_obj[1] ;
    7521           0 :   std::string result;
    7522             :   
    7523           0 :   if (!args) SWIG_fail;
    7524           0 :   swig_obj[0] = args;
    7525           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7526           0 :   if (!SWIG_IsOK(res1)) {
    7527           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_getNamespace" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7528             :   }
    7529           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7530             :   {
    7531             :     try {
    7532           0 :       result = ((kdb::Key const *)arg1)->getNamespace();    
    7533           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7534           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7535           0 :     }    catch (...) {
    7536           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getNamespace() const");    
    7537             :     }
    7538             :   }
    7539           0 :   resultobj = SWIG_From_std_string(static_cast< std::string >(result));
    7540           0 :   return resultobj;
    7541             : fail:
    7542             :   return NULL;
    7543             : }
    7544             : 
    7545             : 
    7546           0 : SWIGINTERN PyObject *_wrap_Key_isCascading(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7547           0 :   PyObject *resultobj = 0;
    7548           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7549           0 :   void *argp1 = 0 ;
    7550           0 :   int res1 = 0 ;
    7551             :   PyObject *swig_obj[1] ;
    7552             :   bool result;
    7553             :   
    7554           0 :   if (!args) SWIG_fail;
    7555           0 :   swig_obj[0] = args;
    7556           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7557           0 :   if (!SWIG_IsOK(res1)) {
    7558           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isCascading" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7559             :   }
    7560           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7561             :   {
    7562             :     try {
    7563           0 :       result = (bool)((kdb::Key const *)arg1)->isCascading();    
    7564           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7565           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7566           0 :     }    catch (...) {
    7567           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isCascading() const");    
    7568             :     }
    7569             :   }
    7570             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7571             :   return resultobj;
    7572             : fail:
    7573             :   return NULL;
    7574             : }
    7575             : 
    7576             : 
    7577           0 : SWIGINTERN PyObject *_wrap_Key_isSpec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7578           0 :   PyObject *resultobj = 0;
    7579           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7580           0 :   void *argp1 = 0 ;
    7581           0 :   int res1 = 0 ;
    7582             :   PyObject *swig_obj[1] ;
    7583             :   bool result;
    7584             :   
    7585           0 :   if (!args) SWIG_fail;
    7586           0 :   swig_obj[0] = args;
    7587           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7588           0 :   if (!SWIG_IsOK(res1)) {
    7589           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isSpec" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7590             :   }
    7591           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7592             :   {
    7593             :     try {
    7594           0 :       result = (bool)((kdb::Key const *)arg1)->isSpec();    
    7595           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7596           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7597           0 :     }    catch (...) {
    7598           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isSpec() const");    
    7599             :     }
    7600             :   }
    7601             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7602             :   return resultobj;
    7603             : fail:
    7604             :   return NULL;
    7605             : }
    7606             : 
    7607             : 
    7608           0 : SWIGINTERN PyObject *_wrap_Key_isProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7609           0 :   PyObject *resultobj = 0;
    7610           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7611           0 :   void *argp1 = 0 ;
    7612           0 :   int res1 = 0 ;
    7613             :   PyObject *swig_obj[1] ;
    7614             :   bool result;
    7615             :   
    7616           0 :   if (!args) SWIG_fail;
    7617           0 :   swig_obj[0] = args;
    7618           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7619           0 :   if (!SWIG_IsOK(res1)) {
    7620           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isProc" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7621             :   }
    7622           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7623             :   {
    7624             :     try {
    7625           0 :       result = (bool)((kdb::Key const *)arg1)->isProc();    
    7626           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7627           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7628           0 :     }    catch (...) {
    7629           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isProc() const");    
    7630             :     }
    7631             :   }
    7632             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7633             :   return resultobj;
    7634             : fail:
    7635             :   return NULL;
    7636             : }
    7637             : 
    7638             : 
    7639           0 : SWIGINTERN PyObject *_wrap_Key_isDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7640           0 :   PyObject *resultobj = 0;
    7641           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7642           0 :   void *argp1 = 0 ;
    7643           0 :   int res1 = 0 ;
    7644             :   PyObject *swig_obj[1] ;
    7645             :   bool result;
    7646             :   
    7647           0 :   if (!args) SWIG_fail;
    7648           0 :   swig_obj[0] = args;
    7649           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7650           0 :   if (!SWIG_IsOK(res1)) {
    7651           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isDir" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7652             :   }
    7653           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7654             :   {
    7655             :     try {
    7656           0 :       result = (bool)((kdb::Key const *)arg1)->isDir();    
    7657           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7658           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7659           0 :     }    catch (...) {
    7660           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isDir() const");    
    7661             :     }
    7662             :   }
    7663             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7664             :   return resultobj;
    7665             : fail:
    7666             :   return NULL;
    7667             : }
    7668             : 
    7669             : 
    7670           1 : SWIGINTERN PyObject *_wrap_Key_isUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7671           1 :   PyObject *resultobj = 0;
    7672           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7673           1 :   void *argp1 = 0 ;
    7674           1 :   int res1 = 0 ;
    7675             :   PyObject *swig_obj[1] ;
    7676             :   bool result;
    7677             :   
    7678           1 :   if (!args) SWIG_fail;
    7679           1 :   swig_obj[0] = args;
    7680           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7681           1 :   if (!SWIG_IsOK(res1)) {
    7682           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isUser" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7683             :   }
    7684           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7685             :   {
    7686             :     try {
    7687           1 :       result = (bool)((kdb::Key const *)arg1)->isUser();    
    7688           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7689           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7690           0 :     }    catch (...) {
    7691           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isUser() const");    
    7692             :     }
    7693             :   }
    7694             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7695             :   return resultobj;
    7696             : fail:
    7697             :   return NULL;
    7698             : }
    7699             : 
    7700             : 
    7701           1 : SWIGINTERN PyObject *_wrap_Key_isSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7702           1 :   PyObject *resultobj = 0;
    7703           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7704           1 :   void *argp1 = 0 ;
    7705           1 :   int res1 = 0 ;
    7706             :   PyObject *swig_obj[1] ;
    7707             :   bool result;
    7708             :   
    7709           1 :   if (!args) SWIG_fail;
    7710           1 :   swig_obj[0] = args;
    7711           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7712           1 :   if (!SWIG_IsOK(res1)) {
    7713           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isSystem" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7714             :   }
    7715           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7716             :   {
    7717             :     try {
    7718           1 :       result = (bool)((kdb::Key const *)arg1)->isSystem();    
    7719           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7720           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7721           0 :     }    catch (...) {
    7722           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isSystem() const");    
    7723             :     }
    7724             :   }
    7725             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7726             :   return resultobj;
    7727             : fail:
    7728             :   return NULL;
    7729             : }
    7730             : 
    7731             : 
    7732           1 : SWIGINTERN PyObject *_wrap_Key_isString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7733           1 :   PyObject *resultobj = 0;
    7734           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7735           1 :   void *argp1 = 0 ;
    7736           1 :   int res1 = 0 ;
    7737             :   PyObject *swig_obj[1] ;
    7738             :   bool result;
    7739             :   
    7740           1 :   if (!args) SWIG_fail;
    7741           1 :   swig_obj[0] = args;
    7742           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7743           1 :   if (!SWIG_IsOK(res1)) {
    7744           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isString" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7745             :   }
    7746           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7747             :   {
    7748             :     try {
    7749           1 :       result = (bool)((kdb::Key const *)arg1)->isString();    
    7750           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7751           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7752           0 :     }    catch (...) {
    7753           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isString() const");    
    7754             :     }
    7755             :   }
    7756             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7757             :   return resultobj;
    7758             : fail:
    7759             :   return NULL;
    7760             : }
    7761             : 
    7762             : 
    7763          28 : SWIGINTERN PyObject *_wrap_Key_isBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7764          28 :   PyObject *resultobj = 0;
    7765          28 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7766          28 :   void *argp1 = 0 ;
    7767          28 :   int res1 = 0 ;
    7768             :   PyObject *swig_obj[1] ;
    7769             :   bool result;
    7770             :   
    7771          28 :   if (!args) SWIG_fail;
    7772          28 :   swig_obj[0] = args;
    7773          28 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7774          28 :   if (!SWIG_IsOK(res1)) {
    7775           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isBinary" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7776             :   }
    7777          28 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7778             :   {
    7779             :     try {
    7780          28 :       result = (bool)((kdb::Key const *)arg1)->isBinary();    
    7781           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7782           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7783           0 :     }    catch (...) {
    7784           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isBinary() const");    
    7785             :     }
    7786             :   }
    7787             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7788             :   return resultobj;
    7789             : fail:
    7790             :   return NULL;
    7791             : }
    7792             : 
    7793             : 
    7794           0 : SWIGINTERN PyObject *_wrap_Key_isInactive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7795           0 :   PyObject *resultobj = 0;
    7796           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7797           0 :   void *argp1 = 0 ;
    7798           0 :   int res1 = 0 ;
    7799             :   PyObject *swig_obj[1] ;
    7800             :   bool result;
    7801             :   
    7802           0 :   if (!args) SWIG_fail;
    7803           0 :   swig_obj[0] = args;
    7804           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7805           0 :   if (!SWIG_IsOK(res1)) {
    7806           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isInactive" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7807             :   }
    7808           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7809             :   {
    7810             :     try {
    7811           0 :       result = (bool)((kdb::Key const *)arg1)->isInactive();    
    7812           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7813           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7814           0 :     }    catch (...) {
    7815           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isInactive() const");    
    7816             :     }
    7817             :   }
    7818             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7819             :   return resultobj;
    7820             : fail:
    7821             :   return NULL;
    7822             : }
    7823             : 
    7824             : 
    7825           1 : SWIGINTERN PyObject *_wrap_Key_isBelow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7826           1 :   PyObject *resultobj = 0;
    7827           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7828           1 :   kdb::Key *arg2 = 0 ;
    7829           1 :   void *argp1 = 0 ;
    7830           1 :   int res1 = 0 ;
    7831           1 :   void *argp2 = 0 ;
    7832           1 :   int res2 = 0 ;
    7833             :   PyObject *swig_obj[2] ;
    7834             :   bool result;
    7835             :   
    7836           1 :   if (!SWIG_Python_UnpackTuple(args,"Key_isBelow",2,2,swig_obj)) SWIG_fail;
    7837           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7838           1 :   if (!SWIG_IsOK(res1)) {
    7839           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isBelow" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7840             :   }
    7841           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7842           1 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    7843           1 :   if (!SWIG_IsOK(res2)) {
    7844           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_isBelow" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    7845             :   }
    7846           1 :   if (!argp2) {
    7847           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_isBelow" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    7848             :   }
    7849           1 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    7850             :   {
    7851             :     try {
    7852           1 :       result = (bool)((kdb::Key const *)arg1)->isBelow((kdb::Key const &)*arg2);    
    7853           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7854           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7855           0 :     }    catch (...) {
    7856           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isBelow(kdb::Key const &) const");    
    7857             :     }
    7858             :   }
    7859             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7860             :   return resultobj;
    7861             : fail:
    7862             :   return NULL;
    7863             : }
    7864             : 
    7865             : 
    7866           0 : SWIGINTERN PyObject *_wrap_Key_isBelowOrSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7867           0 :   PyObject *resultobj = 0;
    7868           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7869           0 :   kdb::Key *arg2 = 0 ;
    7870           0 :   void *argp1 = 0 ;
    7871           0 :   int res1 = 0 ;
    7872           0 :   void *argp2 = 0 ;
    7873           0 :   int res2 = 0 ;
    7874             :   PyObject *swig_obj[2] ;
    7875             :   bool result;
    7876             :   
    7877           0 :   if (!SWIG_Python_UnpackTuple(args,"Key_isBelowOrSame",2,2,swig_obj)) SWIG_fail;
    7878           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7879           0 :   if (!SWIG_IsOK(res1)) {
    7880           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isBelowOrSame" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7881             :   }
    7882           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7883           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    7884           0 :   if (!SWIG_IsOK(res2)) {
    7885           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_isBelowOrSame" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    7886             :   }
    7887           0 :   if (!argp2) {
    7888           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_isBelowOrSame" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    7889             :   }
    7890           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    7891             :   {
    7892             :     try {
    7893           0 :       result = (bool)((kdb::Key const *)arg1)->isBelowOrSame((kdb::Key const &)*arg2);    
    7894           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7895           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7896           0 :     }    catch (...) {
    7897           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isBelowOrSame(kdb::Key const &) const");    
    7898             :     }
    7899             :   }
    7900             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7901             :   return resultobj;
    7902             : fail:
    7903             :   return NULL;
    7904             : }
    7905             : 
    7906             : 
    7907           0 : SWIGINTERN PyObject *_wrap_Key_isDirectBelow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7908           0 :   PyObject *resultobj = 0;
    7909           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    7910           0 :   kdb::Key *arg2 = 0 ;
    7911           0 :   void *argp1 = 0 ;
    7912           0 :   int res1 = 0 ;
    7913           0 :   void *argp2 = 0 ;
    7914           0 :   int res2 = 0 ;
    7915             :   PyObject *swig_obj[2] ;
    7916             :   bool result;
    7917             :   
    7918           0 :   if (!SWIG_Python_UnpackTuple(args,"Key_isDirectBelow",2,2,swig_obj)) SWIG_fail;
    7919           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    7920           0 :   if (!SWIG_IsOK(res1)) {
    7921           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isDirectBelow" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    7922             :   }
    7923           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    7924           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    7925           0 :   if (!SWIG_IsOK(res2)) {
    7926           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_isDirectBelow" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    7927             :   }
    7928           0 :   if (!argp2) {
    7929           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_isDirectBelow" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    7930             :   }
    7931           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    7932             :   {
    7933             :     try {
    7934           0 :       result = (bool)((kdb::Key const *)arg1)->isDirectBelow((kdb::Key const &)*arg2);    
    7935           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7936           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7937           0 :     }    catch (...) {
    7938           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isDirectBelow(kdb::Key const &) const");    
    7939             :     }
    7940             :   }
    7941             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7942             :   return resultobj;
    7943             : fail:
    7944             :   return NULL;
    7945             : }
    7946             : 
    7947             : 
    7948         106 : SWIGINTERN PyObject *_wrap_new_Key__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    7949         106 :   PyObject *resultobj = 0;
    7950         106 :   char *arg1 = (char *) 0 ;
    7951             :   int arg2 ;
    7952             :   int res1 ;
    7953         106 :   char *buf1 = 0 ;
    7954         106 :   int alloc1 = 0 ;
    7955             :   int val2 ;
    7956         106 :   int ecode2 = 0 ;
    7957         106 :   kdb::Key *result = 0 ;
    7958             :   
    7959         106 :   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
    7960         106 :   res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
    7961         106 :   if (!SWIG_IsOK(res1)) {
    7962           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Key" "', argument " "1"" of type '" "char const *""'");
    7963             :   }
    7964         106 :   arg1 = reinterpret_cast< char * >(buf1);
    7965         212 :   ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
    7966         106 :   if (!SWIG_IsOK(ecode2)) {
    7967           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Key" "', argument " "2"" of type '" "int""'");
    7968             :   } 
    7969         106 :   arg2 = static_cast< int >(val2);
    7970             :   {
    7971             :     try {
    7972         106 :       result = (kdb::Key *)new_kdb_Key__SWIG_3((char const *)arg1,arg2);    
    7973           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    7974           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    7975           0 :     }    catch (...) {
    7976           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::Key(char const *,int)");    
    7977             :     }
    7978             :   }
    7979         106 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, SWIG_POINTER_NEW |  0 );
    7980         106 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    7981             :   return resultobj;
    7982             : fail:
    7983           0 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    7984             :   return NULL;
    7985             : }
    7986             : 
    7987             : 
    7988           0 : SWIGINTERN PyObject *_wrap_new_Key__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    7989           0 :   PyObject *resultobj = 0;
    7990           0 :   char *arg1 = (char *) 0 ;
    7991             :   int res1 ;
    7992           0 :   char *buf1 = 0 ;
    7993           0 :   int alloc1 = 0 ;
    7994           0 :   kdb::Key *result = 0 ;
    7995             :   
    7996           0 :   if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
    7997           0 :   res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
    7998           0 :   if (!SWIG_IsOK(res1)) {
    7999           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Key" "', argument " "1"" of type '" "char const *""'");
    8000             :   }
    8001           0 :   arg1 = reinterpret_cast< char * >(buf1);
    8002             :   {
    8003             :     try {
    8004           0 :       result = (kdb::Key *)new_kdb_Key__SWIG_3((char const *)arg1);    
    8005           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    8006           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    8007           0 :     }    catch (...) {
    8008           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::Key(char const *)");    
    8009             :     }
    8010             :   }
    8011           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, SWIG_POINTER_NEW |  0 );
    8012           0 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    8013             :   return resultobj;
    8014             : fail:
    8015           0 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    8016             :   return NULL;
    8017             : }
    8018             : 
    8019             : 
    8020         117 : SWIGINTERN PyObject *_wrap_new_Key(PyObject *self, PyObject *args) {
    8021             :   Py_ssize_t argc;
    8022             :   PyObject *argv[3] = {
    8023             :     0
    8024         117 :   };
    8025             :   
    8026         117 :   if (!(argc = SWIG_Python_UnpackTuple(args,"new_Key",0,2,argv))) SWIG_fail;
    8027         117 :   --argc;
    8028         117 :   if (argc == 0) {
    8029           8 :     return _wrap_new_Key__SWIG_0(self, argc, argv);
    8030             :   }
    8031         109 :   if (argc == 1) {
    8032           3 :     int _v = 0;
    8033             :     {
    8034           3 :       void *vptr = 0;
    8035           3 :       int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__Key, 0);
    8036           3 :       _v = SWIG_CheckState(res);
    8037             :     }
    8038           3 :     if (!_v) goto check_2;
    8039           1 :     return _wrap_new_Key__SWIG_1(self, argc, argv);
    8040             :   }
    8041             : check_2:
    8042             :   
    8043         108 :   if (argc == 1) {
    8044           2 :     int _v = 0;
    8045             :     {
    8046           2 :       void *vptr = 0;
    8047           2 :       int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_kdb__Key, 0);
    8048           2 :       _v = SWIG_CheckState(res);
    8049             :     }
    8050           2 :     if (!_v) goto check_3;
    8051           2 :     return _wrap_new_Key__SWIG_2(self, argc, argv);
    8052             :   }
    8053             : check_3:
    8054             :   
    8055         106 :   if (argc == 1) {
    8056           0 :     return _wrap_new_Key__SWIG_4(self, argc, argv);
    8057             :   }
    8058         106 :   if (argc == 2) {
    8059         106 :     return _wrap_new_Key__SWIG_3(self, argc, argv);
    8060             :   }
    8061             :   
    8062             : fail:
    8063             :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Key'.\n"
    8064             :     "  Possible C/C++ prototypes are:\n"
    8065             :     "    kdb::Key::Key()\n"
    8066             :     "    kdb::Key::Key(ckdb::Key *)\n"
    8067             :     "    kdb::Key::Key(kdb::Key &)\n"
    8068             :     "    kdb::Key::Key(char const *,int)\n"
    8069           0 :     "    kdb::Key::Key(char const *)\n");
    8070             :   return 0;
    8071             : }
    8072             : 
    8073             : 
    8074           0 : SWIGINTERN PyObject *_wrap_Key___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8075           0 :   PyObject *resultobj = 0;
    8076           0 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    8077           0 :   kdb::Key *arg2 = (kdb::Key *) 0 ;
    8078           0 :   void *argp1 = 0 ;
    8079           0 :   int res1 = 0 ;
    8080           0 :   void *argp2 = 0 ;
    8081           0 :   int res2 = 0 ;
    8082             :   PyObject *swig_obj[2] ;
    8083             :   int result;
    8084             :   
    8085           0 :   if (!SWIG_Python_UnpackTuple(args,"Key___cmp__",2,2,swig_obj)) SWIG_fail;
    8086           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    8087           0 :   if (!SWIG_IsOK(res1)) {
    8088           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___cmp__" "', argument " "1"" of type '" "kdb::Key *""'"); 
    8089             :   }
    8090           0 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    8091           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_kdb__Key, 0 |  0 );
    8092           0 :   if (!SWIG_IsOK(res2)) {
    8093           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___cmp__" "', argument " "2"" of type '" "kdb::Key const *""'"); 
    8094             :   }
    8095           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    8096             :   {
    8097             :     try {
    8098           0 :       result = (int)kdb_Key___cmp__(arg1,(kdb::Key const *)arg2);    
    8099           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    8100           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    8101           0 :     }    catch (...) {
    8102           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::__cmp__(kdb::Key const *)");    
    8103             :     }
    8104             :   }
    8105             :   resultobj = SWIG_From_int(static_cast< int >(result));
    8106             :   return resultobj;
    8107             : fail:
    8108             :   return NULL;
    8109             : }
    8110             : 
    8111             : 
    8112           1 : SWIGINTERN PyObject *_wrap_Key___copy__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8113           1 :   PyObject *resultobj = 0;
    8114           1 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    8115           1 :   void *argp1 = 0 ;
    8116           1 :   int res1 = 0 ;
    8117             :   PyObject *swig_obj[1] ;
    8118           1 :   kdb::Key *result = 0 ;
    8119             :   
    8120           1 :   if (!args) SWIG_fail;
    8121           1 :   swig_obj[0] = args;
    8122           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    8123           1 :   if (!SWIG_IsOK(res1)) {
    8124           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___copy__" "', argument " "1"" of type '" "kdb::Key *""'"); 
    8125             :   }
    8126           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    8127             :   {
    8128             :     try {
    8129           1 :       result = (kdb::Key *)kdb_Key___copy__(arg1);    
    8130           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    8131           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    8132           0 :     }    catch (...) {
    8133           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::__copy__()");    
    8134             :     }
    8135             :   }
    8136           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, 0 |  0 );
    8137             :   return resultobj;
    8138             : fail:
    8139             :   return NULL;
    8140             : }
    8141             : 
    8142             : 
    8143           2 : SWIGINTERN PyObject *_wrap_Key___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8144           2 :   PyObject *resultobj = 0;
    8145           2 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    8146           2 :   PyObject **arg2 = (PyObject **) 0 ;
    8147           2 :   void *argp1 = 0 ;
    8148           2 :   int res1 = 0 ;
    8149             :   PyObject *swig_obj[1] ;
    8150           2 :   swig::SwigPyIterator *result = 0 ;
    8151             :   
    8152           2 :   arg2 = &swig_obj[0];
    8153           2 :   if (!args) SWIG_fail;
    8154           2 :   swig_obj[0] = args;
    8155           2 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    8156           2 :   if (!SWIG_IsOK(res1)) {
    8157           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___iter__" "', argument " "1"" of type '" "kdb::Key *""'"); 
    8158             :   }
    8159           2 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    8160             :   {
    8161             :     try {
    8162           2 :       result = (swig::SwigPyIterator *)kdb_Key___iter__(arg1,arg2);    
    8163           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    8164           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    8165           0 :     }    catch (...) {
    8166           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::__iter__(PyObject **)");    
    8167             :     }
    8168             :   }
    8169           2 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    8170             :   return resultobj;
    8171             : fail:
    8172             :   return NULL;
    8173             : }
    8174             : 
    8175             : 
    8176           2 : SWIGINTERN PyObject *_wrap_Key___reversed__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8177           2 :   PyObject *resultobj = 0;
    8178           2 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    8179           2 :   PyObject **arg2 = (PyObject **) 0 ;
    8180           2 :   void *argp1 = 0 ;
    8181           2 :   int res1 = 0 ;
    8182             :   PyObject *swig_obj[1] ;
    8183           2 :   swig::SwigPyIterator *result = 0 ;
    8184             :   
    8185           2 :   arg2 = &swig_obj[0];
    8186           2 :   if (!args) SWIG_fail;
    8187           2 :   swig_obj[0] = args;
    8188           2 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    8189           2 :   if (!SWIG_IsOK(res1)) {
    8190           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___reversed__" "', argument " "1"" of type '" "kdb::Key *""'"); 
    8191             :   }
    8192           2 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    8193             :   {
    8194             :     try {
    8195           2 :       result = (swig::SwigPyIterator *)kdb_Key___reversed__(arg1,arg2);    
    8196           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    8197           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    8198           0 :     }    catch (...) {
    8199           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::__reversed__(PyObject **)");    
    8200             :     }
    8201             :   }
    8202           2 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    8203             :   return resultobj;
    8204             : fail:
    8205             :   return NULL;
    8206             : }
    8207             : 
    8208             : 
    8209          10 : SWIGINTERN PyObject *_wrap_Key__getMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8210          10 :   PyObject *resultobj = 0;
    8211          10 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    8212          10 :   std::string *arg2 = 0 ;
    8213          10 :   void *argp1 = 0 ;
    8214          10 :   int res1 = 0 ;
    8215          10 :   int res2 = SWIG_OLDOBJ ;
    8216             :   PyObject *swig_obj[2] ;
    8217          20 :   kdb::Key result;
    8218             :   
    8219          10 :   if (!SWIG_Python_UnpackTuple(args,"Key__getMeta",2,2,swig_obj)) SWIG_fail;
    8220          10 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    8221          10 :   if (!SWIG_IsOK(res1)) {
    8222           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getMeta" "', argument " "1"" of type '" "kdb::Key const *""'"); 
    8223             :   }
    8224          10 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    8225             :   {
    8226          10 :     std::string *ptr = (std::string *)0;
    8227          10 :     res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    8228          10 :     if (!SWIG_IsOK(res2)) {
    8229           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key__getMeta" "', argument " "2"" of type '" "std::string const &""'"); 
    8230             :     }
    8231          10 :     if (!ptr) {
    8232           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key__getMeta" "', argument " "2"" of type '" "std::string const &""'"); 
    8233             :     }
    8234          10 :     arg2 = ptr;
    8235             :   }
    8236             :   {
    8237             :     try {
    8238          30 :       result = ((kdb::Key const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getMeta< kdb::Key const >((std::string const &)*arg2);    
    8239           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    8240           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    8241           0 :     }    catch (...) {
    8242           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getMeta< kdb::Key const >(std::string const &) const");    
    8243             :     }
    8244             :   }
    8245          20 :   resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN |  0 );
    8246          20 :   if (SWIG_IsNewObj(res2)) delete arg2;
    8247             :   return resultobj;
    8248             : fail:
    8249           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    8250             :   return NULL;
    8251             : }
    8252             : 
    8253             : 
    8254          16 : SWIGINTERN PyObject *_wrap_Key__setMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8255          16 :   PyObject *resultobj = 0;
    8256          16 :   kdb::Key *arg1 = (kdb::Key *) 0 ;
    8257          16 :   std::string *arg2 = 0 ;
    8258          32 :   std::string arg3 ;
    8259          16 :   void *argp1 = 0 ;
    8260          16 :   int res1 = 0 ;
    8261          16 :   int res2 = SWIG_OLDOBJ ;
    8262             :   PyObject *swig_obj[3] ;
    8263             :   
    8264          16 :   if (!SWIG_Python_UnpackTuple(args,"Key__setMeta",3,3,swig_obj)) SWIG_fail;
    8265          16 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 |  0 );
    8266          16 :   if (!SWIG_IsOK(res1)) {
    8267           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__setMeta" "', argument " "1"" of type '" "kdb::Key *""'"); 
    8268             :   }
    8269          16 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    8270             :   {
    8271          16 :     std::string *ptr = (std::string *)0;
    8272          16 :     res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    8273          16 :     if (!SWIG_IsOK(res2)) {
    8274           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key__setMeta" "', argument " "2"" of type '" "std::string const &""'"); 
    8275             :     }
    8276          16 :     if (!ptr) {
    8277           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key__setMeta" "', argument " "2"" of type '" "std::string const &""'"); 
    8278             :     }
    8279          16 :     arg2 = ptr;
    8280             :   }
    8281             :   {
    8282          16 :     std::string *ptr = (std::string *)0;
    8283          32 :     int res = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    8284          16 :     if (!SWIG_IsOK(res) || !ptr) {
    8285           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Key__setMeta" "', argument " "3"" of type '" "std::string""'"); 
    8286             :     }
    8287          32 :     arg3 = *ptr;
    8288          32 :     if (SWIG_IsNewObj(res)) delete ptr;
    8289             :   }
    8290             :   {
    8291             :     try {
    8292          32 :       (arg1)->SWIGTEMPLATEDISAMBIGUATOR setMeta< std::string >((std::string const &)*arg2,arg3);    
    8293           0 :     }    KEY_EXCEPTIONS    catch (const std::exception & e) {
    8294           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    8295           0 :     }    catch (...) {
    8296           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setMeta< std::string >(std::string const &,std::string)");    
    8297             :     }
    8298             :   }
    8299          16 :   resultobj = SWIG_Py_Void();
    8300          32 :   if (SWIG_IsNewObj(res2)) delete arg2;
    8301             :   return resultobj;
    8302             : fail:
    8303           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    8304             :   return NULL;
    8305             : }
    8306             : 
    8307             : 
    8308           3 : SWIGINTERN PyObject *Key_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8309             :   PyObject *obj;
    8310           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    8311           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_kdb__Key, SWIG_NewClientData(obj));
    8312           3 :   return SWIG_Py_Void();
    8313             : }
    8314             : 
    8315         117 : SWIGINTERN PyObject *Key_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8316         117 :   return SWIG_Python_InitShadowInstance(args);
    8317             : }
    8318             : 
    8319           1 : SWIGINTERN PyObject *_wrap_new_KeySet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
    8320           1 :   PyObject *resultobj = 0;
    8321           1 :   kdb::KeySet *result = 0 ;
    8322             :   
    8323           1 :   if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
    8324           2 :   result = (kdb::KeySet *)new kdb::KeySet();
    8325           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_NEW |  0 );
    8326             :   return resultobj;
    8327             : fail:
    8328             :   return NULL;
    8329             : }
    8330             : 
    8331             : 
    8332           1 : SWIGINTERN PyObject *_wrap_new_KeySet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    8333           1 :   PyObject *resultobj = 0;
    8334           1 :   ckdb::KeySet *arg1 = (ckdb::KeySet *) 0 ;
    8335           1 :   void *argp1 = 0 ;
    8336           1 :   int res1 = 0 ;
    8337           1 :   kdb::KeySet *result = 0 ;
    8338             :   
    8339           1 :   if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
    8340           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__KeySet, 0 |  0 );
    8341           1 :   if (!SWIG_IsOK(res1)) {
    8342           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KeySet" "', argument " "1"" of type '" "ckdb::KeySet *""'"); 
    8343             :   }
    8344           1 :   arg1 = reinterpret_cast< ckdb::KeySet * >(argp1);
    8345           2 :   result = (kdb::KeySet *)new kdb::KeySet(arg1);
    8346           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_NEW |  0 );
    8347             :   return resultobj;
    8348             : fail:
    8349             :   return NULL;
    8350             : }
    8351             : 
    8352             : 
    8353           1 : SWIGINTERN PyObject *_wrap_new_KeySet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    8354           1 :   PyObject *resultobj = 0;
    8355           1 :   kdb::KeySet *arg1 = 0 ;
    8356           1 :   void *argp1 = 0 ;
    8357           1 :   int res1 = 0 ;
    8358           1 :   kdb::KeySet *result = 0 ;
    8359             :   
    8360           1 :   if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
    8361           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_kdb__KeySet,  0  | 0);
    8362           1 :   if (!SWIG_IsOK(res1)) {
    8363           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KeySet" "', argument " "1"" of type '" "kdb::KeySet const &""'"); 
    8364             :   }
    8365           1 :   if (!argp1) {
    8366           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KeySet" "', argument " "1"" of type '" "kdb::KeySet const &""'"); 
    8367             :   }
    8368           1 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8369           2 :   result = (kdb::KeySet *)new kdb::KeySet((kdb::KeySet const &)*arg1);
    8370           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_NEW |  0 );
    8371             :   return resultobj;
    8372             : fail:
    8373             :   return NULL;
    8374             : }
    8375             : 
    8376             : 
    8377          19 : SWIGINTERN PyObject *_wrap_delete_KeySet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8378          19 :   PyObject *resultobj = 0;
    8379          19 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8380          19 :   void *argp1 = 0 ;
    8381          19 :   int res1 = 0 ;
    8382             :   PyObject *swig_obj[1] ;
    8383             :   
    8384          19 :   if (!args) SWIG_fail;
    8385          19 :   swig_obj[0] = args;
    8386          19 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_DISOWN |  0 );
    8387          19 :   if (!SWIG_IsOK(res1)) {
    8388           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeySet" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    8389             :   }
    8390          19 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8391          38 :   delete arg1;
    8392          19 :   resultobj = SWIG_Py_Void();
    8393          19 :   return resultobj;
    8394             : fail:
    8395             :   return NULL;
    8396             : }
    8397             : 
    8398             : 
    8399           0 : SWIGINTERN PyObject *_wrap_KeySet_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8400           0 :   PyObject *resultobj = 0;
    8401           0 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8402           0 :   void *argp1 = 0 ;
    8403           0 :   int res1 = 0 ;
    8404             :   PyObject *swig_obj[1] ;
    8405           0 :   ckdb::KeySet *result = 0 ;
    8406             :   
    8407           0 :   if (!args) SWIG_fail;
    8408           0 :   swig_obj[0] = args;
    8409           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8410           0 :   if (!SWIG_IsOK(res1)) {
    8411           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_release" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    8412             :   }
    8413           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8414           0 :   result = (ckdb::KeySet *)(arg1)->release();
    8415           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__KeySet, 0 |  0 );
    8416             :   return resultobj;
    8417             : fail:
    8418             :   return NULL;
    8419             : }
    8420             : 
    8421             : 
    8422           0 : SWIGINTERN PyObject *_wrap_KeySet_getKeySet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8423           0 :   PyObject *resultobj = 0;
    8424           0 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8425           0 :   void *argp1 = 0 ;
    8426           0 :   int res1 = 0 ;
    8427             :   PyObject *swig_obj[1] ;
    8428           0 :   ckdb::KeySet *result = 0 ;
    8429             :   
    8430           0 :   if (!args) SWIG_fail;
    8431           0 :   swig_obj[0] = args;
    8432           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8433           0 :   if (!SWIG_IsOK(res1)) {
    8434           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_getKeySet" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    8435             :   }
    8436           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8437           0 :   result = (ckdb::KeySet *)((kdb::KeySet const *)arg1)->getKeySet();
    8438           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__KeySet, 0 |  0 );
    8439             :   return resultobj;
    8440             : fail:
    8441             :   return NULL;
    8442             : }
    8443             : 
    8444             : 
    8445           0 : SWIGINTERN PyObject *_wrap_KeySet_setKeySet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8446           0 :   PyObject *resultobj = 0;
    8447           0 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8448           0 :   ckdb::KeySet *arg2 = (ckdb::KeySet *) 0 ;
    8449           0 :   void *argp1 = 0 ;
    8450           0 :   int res1 = 0 ;
    8451           0 :   void *argp2 = 0 ;
    8452           0 :   int res2 = 0 ;
    8453             :   PyObject *swig_obj[2] ;
    8454             :   
    8455           0 :   if (!SWIG_Python_UnpackTuple(args,"KeySet_setKeySet",2,2,swig_obj)) SWIG_fail;
    8456           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8457           0 :   if (!SWIG_IsOK(res1)) {
    8458           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_setKeySet" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    8459             :   }
    8460           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8461           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__KeySet, 0 |  0 );
    8462           0 :   if (!SWIG_IsOK(res2)) {
    8463           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet_setKeySet" "', argument " "2"" of type '" "ckdb::KeySet *""'"); 
    8464             :   }
    8465           0 :   arg2 = reinterpret_cast< ckdb::KeySet * >(argp2);
    8466           0 :   (arg1)->setKeySet(arg2);
    8467           0 :   resultobj = SWIG_Py_Void();
    8468           0 :   return resultobj;
    8469             : fail:
    8470             :   return NULL;
    8471             : }
    8472             : 
    8473             : 
    8474          18 : SWIGINTERN PyObject *_wrap_KeySet___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8475          18 :   PyObject *resultobj = 0;
    8476          18 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8477          18 :   void *argp1 = 0 ;
    8478          18 :   int res1 = 0 ;
    8479             :   PyObject *swig_obj[1] ;
    8480             :   ssize_t result;
    8481             :   
    8482          18 :   if (!args) SWIG_fail;
    8483          18 :   swig_obj[0] = args;
    8484          18 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8485          18 :   if (!SWIG_IsOK(res1)) {
    8486           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet___len__" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    8487             :   }
    8488          18 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8489          18 :   result = ((kdb::KeySet const *)arg1)->size();
    8490          18 :   resultobj = SWIG_From_long(static_cast< long >(result));
    8491             :   return resultobj;
    8492             : fail:
    8493             :   return NULL;
    8494             : }
    8495             : 
    8496             : 
    8497           1 : SWIGINTERN PyObject *_wrap_KeySet_dup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8498           1 :   PyObject *resultobj = 0;
    8499           1 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8500           1 :   void *argp1 = 0 ;
    8501           1 :   int res1 = 0 ;
    8502             :   PyObject *swig_obj[1] ;
    8503           1 :   ckdb::KeySet *result = 0 ;
    8504             :   
    8505           1 :   if (!args) SWIG_fail;
    8506           1 :   swig_obj[0] = args;
    8507           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8508           1 :   if (!SWIG_IsOK(res1)) {
    8509           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_dup" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    8510             :   }
    8511           1 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8512           1 :   result = (ckdb::KeySet *)((kdb::KeySet const *)arg1)->dup();
    8513           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__KeySet, 0 |  0 );
    8514             :   return resultobj;
    8515             : fail:
    8516             :   return NULL;
    8517             : }
    8518             : 
    8519             : 
    8520           0 : SWIGINTERN PyObject *_wrap_KeySet_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8521           0 :   PyObject *resultobj = 0;
    8522           0 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8523           0 :   kdb::KeySet *arg2 = 0 ;
    8524           0 :   void *argp1 = 0 ;
    8525           0 :   int res1 = 0 ;
    8526           0 :   void *argp2 = 0 ;
    8527           0 :   int res2 = 0 ;
    8528             :   PyObject *swig_obj[2] ;
    8529             :   
    8530           0 :   if (!SWIG_Python_UnpackTuple(args,"KeySet_copy",2,2,swig_obj)) SWIG_fail;
    8531           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8532           0 :   if (!SWIG_IsOK(res1)) {
    8533           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_copy" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    8534             :   }
    8535           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8536           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0  | 0);
    8537           0 :   if (!SWIG_IsOK(res2)) {
    8538           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet_copy" "', argument " "2"" of type '" "kdb::KeySet const &""'"); 
    8539             :   }
    8540           0 :   if (!argp2) {
    8541           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet_copy" "', argument " "2"" of type '" "kdb::KeySet const &""'"); 
    8542             :   }
    8543           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
    8544           0 :   (arg1)->copy((kdb::KeySet const &)*arg2);
    8545           0 :   resultobj = SWIG_Py_Void();
    8546           0 :   return resultobj;
    8547             : fail:
    8548             :   return NULL;
    8549             : }
    8550             : 
    8551             : 
    8552           1 : SWIGINTERN PyObject *_wrap_KeySet_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8553           1 :   PyObject *resultobj = 0;
    8554           1 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8555           1 :   void *argp1 = 0 ;
    8556           1 :   int res1 = 0 ;
    8557             :   PyObject *swig_obj[1] ;
    8558             :   
    8559           1 :   if (!args) SWIG_fail;
    8560           1 :   swig_obj[0] = args;
    8561           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8562           1 :   if (!SWIG_IsOK(res1)) {
    8563           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_clear" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    8564             :   }
    8565           1 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8566           1 :   (arg1)->clear();
    8567           1 :   resultobj = SWIG_Py_Void();
    8568           1 :   return resultobj;
    8569             : fail:
    8570             :   return NULL;
    8571             : }
    8572             : 
    8573             : 
    8574          35 : SWIGINTERN PyObject *_wrap_KeySet_append__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    8575          35 :   PyObject *resultobj = 0;
    8576          35 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8577          35 :   kdb::Key *arg2 = 0 ;
    8578          35 :   void *argp1 = 0 ;
    8579          35 :   int res1 = 0 ;
    8580          35 :   void *argp2 = 0 ;
    8581          35 :   int res2 = 0 ;
    8582             :   ssize_t result;
    8583             :   
    8584          35 :   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
    8585          35 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8586          35 :   if (!SWIG_IsOK(res1)) {
    8587           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_append" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    8588             :   }
    8589          35 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8590          35 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    8591          35 :   if (!SWIG_IsOK(res2)) {
    8592           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet_append" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    8593             :   }
    8594          35 :   if (!argp2) {
    8595           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet_append" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    8596             :   }
    8597          35 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    8598          35 :   result = (arg1)->append((kdb::Key const &)*arg2);
    8599          35 :   resultobj = SWIG_From_long(static_cast< long >(result));
    8600             :   return resultobj;
    8601             : fail:
    8602             :   return NULL;
    8603             : }
    8604             : 
    8605             : 
    8606           0 : SWIGINTERN PyObject *_wrap_KeySet_append__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    8607           0 :   PyObject *resultobj = 0;
    8608           0 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8609           0 :   kdb::KeySet *arg2 = 0 ;
    8610           0 :   void *argp1 = 0 ;
    8611           0 :   int res1 = 0 ;
    8612           0 :   void *argp2 = 0 ;
    8613           0 :   int res2 = 0 ;
    8614             :   ssize_t result;
    8615             :   
    8616           0 :   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
    8617           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8618           0 :   if (!SWIG_IsOK(res1)) {
    8619           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_append" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    8620             :   }
    8621           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8622           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0  | 0);
    8623           0 :   if (!SWIG_IsOK(res2)) {
    8624           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet_append" "', argument " "2"" of type '" "kdb::KeySet const &""'"); 
    8625             :   }
    8626           0 :   if (!argp2) {
    8627           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet_append" "', argument " "2"" of type '" "kdb::KeySet const &""'"); 
    8628             :   }
    8629           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
    8630           0 :   result = (arg1)->append((kdb::KeySet const &)*arg2);
    8631           0 :   resultobj = SWIG_From_long(static_cast< long >(result));
    8632             :   return resultobj;
    8633             : fail:
    8634             :   return NULL;
    8635             : }
    8636             : 
    8637             : 
    8638          35 : SWIGINTERN PyObject *_wrap_KeySet_append(PyObject *self, PyObject *args) {
    8639             :   Py_ssize_t argc;
    8640             :   PyObject *argv[3] = {
    8641             :     0
    8642          35 :   };
    8643             :   
    8644          35 :   if (!(argc = SWIG_Python_UnpackTuple(args,"KeySet_append",0,2,argv))) SWIG_fail;
    8645          35 :   --argc;
    8646          35 :   if (argc == 2) {
    8647          35 :     int _v = 0;
    8648             :     {
    8649          35 :       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_kdb__Key, 0);
    8650          35 :       _v = SWIG_CheckState(res);
    8651             :     }
    8652          35 :     if (!_v) goto check_1;
    8653          35 :     return _wrap_KeySet_append__SWIG_0(self, argc, argv);
    8654             :   }
    8655             : check_1:
    8656             :   
    8657           0 :   if (argc == 2) {
    8658           0 :     return _wrap_KeySet_append__SWIG_1(self, argc, argv);
    8659             :   }
    8660             :   
    8661             : fail:
    8662             :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'KeySet_append'.\n"
    8663             :     "  Possible C/C++ prototypes are:\n"
    8664             :     "    kdb::KeySet::append(kdb::Key const &)\n"
    8665           0 :     "    kdb::KeySet::append(kdb::KeySet const &)\n");
    8666             :   return 0;
    8667             : }
    8668             : 
    8669             : 
    8670           0 : SWIGINTERN PyObject *_wrap_KeySet_head(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8671           0 :   PyObject *resultobj = 0;
    8672           0 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8673           0 :   void *argp1 = 0 ;
    8674           0 :   int res1 = 0 ;
    8675             :   PyObject *swig_obj[1] ;
    8676           0 :   kdb::Key result;
    8677             :   
    8678           0 :   if (!args) SWIG_fail;
    8679           0 :   swig_obj[0] = args;
    8680           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8681           0 :   if (!SWIG_IsOK(res1)) {
    8682           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_head" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    8683             :   }
    8684           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8685           0 :   result = ((kdb::KeySet const *)arg1)->head();
    8686           0 :   resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN |  0 );
    8687             :   return resultobj;
    8688             : fail:
    8689             :   return NULL;
    8690             : }
    8691             : 
    8692             : 
    8693           0 : SWIGINTERN PyObject *_wrap_KeySet_tail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8694           0 :   PyObject *resultobj = 0;
    8695           0 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8696           0 :   void *argp1 = 0 ;
    8697           0 :   int res1 = 0 ;
    8698             :   PyObject *swig_obj[1] ;
    8699           0 :   kdb::Key result;
    8700             :   
    8701           0 :   if (!args) SWIG_fail;
    8702           0 :   swig_obj[0] = args;
    8703           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8704           0 :   if (!SWIG_IsOK(res1)) {
    8705           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_tail" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    8706             :   }
    8707           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8708           0 :   result = ((kdb::KeySet const *)arg1)->tail();
    8709           0 :   resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN |  0 );
    8710             :   return resultobj;
    8711             : fail:
    8712             :   return NULL;
    8713             : }
    8714             : 
    8715             : 
    8716           0 : SWIGINTERN PyObject *_wrap_KeySet_setCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8717           0 :   PyObject *resultobj = 0;
    8718           0 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8719             :   cursor_t arg2 ;
    8720           0 :   void *argp1 = 0 ;
    8721           0 :   int res1 = 0 ;
    8722             :   long val2 ;
    8723           0 :   int ecode2 = 0 ;
    8724             :   PyObject *swig_obj[2] ;
    8725             :   
    8726           0 :   if (!SWIG_Python_UnpackTuple(args,"KeySet_setCursor",2,2,swig_obj)) SWIG_fail;
    8727           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8728           0 :   if (!SWIG_IsOK(res1)) {
    8729           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_setCursor" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    8730             :   }
    8731           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8732           0 :   ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
    8733           0 :   if (!SWIG_IsOK(ecode2)) {
    8734           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeySet_setCursor" "', argument " "2"" of type '" "cursor_t""'");
    8735             :   } 
    8736           0 :   arg2 = static_cast< cursor_t >(val2);
    8737           0 :   ((kdb::KeySet const *)arg1)->setCursor(arg2);
    8738           0 :   resultobj = SWIG_Py_Void();
    8739           0 :   return resultobj;
    8740             : fail:
    8741             :   return NULL;
    8742             : }
    8743             : 
    8744             : 
    8745           0 : SWIGINTERN PyObject *_wrap_KeySet_getCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8746           0 :   PyObject *resultobj = 0;
    8747           0 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8748           0 :   void *argp1 = 0 ;
    8749           0 :   int res1 = 0 ;
    8750             :   PyObject *swig_obj[1] ;
    8751             :   cursor_t result;
    8752             :   
    8753           0 :   if (!args) SWIG_fail;
    8754           0 :   swig_obj[0] = args;
    8755           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8756           0 :   if (!SWIG_IsOK(res1)) {
    8757           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_getCursor" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    8758             :   }
    8759           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8760           0 :   result = ((kdb::KeySet const *)arg1)->getCursor();
    8761           0 :   resultobj = SWIG_From_long(static_cast< long >(result));
    8762             :   return resultobj;
    8763             : fail:
    8764             :   return NULL;
    8765             : }
    8766             : 
    8767             : 
    8768           2 : SWIGINTERN PyObject *_wrap_KeySet_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8769           2 :   PyObject *resultobj = 0;
    8770           2 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8771           2 :   void *argp1 = 0 ;
    8772           2 :   int res1 = 0 ;
    8773             :   PyObject *swig_obj[1] ;
    8774           4 :   kdb::Key result;
    8775             :   
    8776           2 :   if (!args) SWIG_fail;
    8777           2 :   swig_obj[0] = args;
    8778           2 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8779           2 :   if (!SWIG_IsOK(res1)) {
    8780           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_pop" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    8781             :   }
    8782           2 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8783           6 :   result = (arg1)->pop();
    8784           4 :   resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN |  0 );
    8785             :   return resultobj;
    8786             : fail:
    8787             :   return NULL;
    8788             : }
    8789             : 
    8790             : 
    8791          14 : SWIGINTERN PyObject *_wrap_KeySet__lookup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    8792          14 :   PyObject *resultobj = 0;
    8793          14 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8794             :   cursor_t arg2 ;
    8795          14 :   void *argp1 = 0 ;
    8796          14 :   int res1 = 0 ;
    8797             :   long val2 ;
    8798          14 :   int ecode2 = 0 ;
    8799          28 :   kdb::Key result;
    8800             :   
    8801          14 :   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
    8802          14 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8803          14 :   if (!SWIG_IsOK(res1)) {
    8804           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet__lookup" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    8805             :   }
    8806          14 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8807          14 :   ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
    8808          14 :   if (!SWIG_IsOK(ecode2)) {
    8809           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeySet__lookup" "', argument " "2"" of type '" "cursor_t""'");
    8810             :   } 
    8811          14 :   arg2 = static_cast< cursor_t >(val2);
    8812          42 :   result = ((kdb::KeySet const *)arg1)->at(arg2);
    8813          28 :   resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN |  0 );
    8814             :   return resultobj;
    8815             : fail:
    8816             :   return NULL;
    8817             : }
    8818             : 
    8819             : 
    8820           3 : SWIGINTERN PyObject *_wrap_KeySet_cut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8821           3 :   PyObject *resultobj = 0;
    8822           3 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8823           6 :   kdb::Key arg2 ;
    8824           3 :   void *argp1 = 0 ;
    8825           3 :   int res1 = 0 ;
    8826             :   void *argp2 ;
    8827           3 :   int res2 = 0 ;
    8828             :   PyObject *swig_obj[2] ;
    8829           6 :   kdb::KeySet result;
    8830             :   
    8831           3 :   if (!SWIG_Python_UnpackTuple(args,"KeySet_cut",2,2,swig_obj)) SWIG_fail;
    8832           3 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8833           3 :   if (!SWIG_IsOK(res1)) {
    8834           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_cut" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    8835             :   }
    8836           3 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8837             :   {
    8838           3 :     res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    8839           3 :     if (!SWIG_IsOK(res2)) {
    8840           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet_cut" "', argument " "2"" of type '" "kdb::Key""'"); 
    8841             :     }  
    8842           3 :     if (!argp2) {
    8843           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet_cut" "', argument " "2"" of type '" "kdb::Key""'");
    8844             :     } else {
    8845           3 :       kdb::Key * temp = reinterpret_cast< kdb::Key * >(argp2);
    8846           3 :       arg2 = *temp;
    8847           3 :       if (SWIG_IsNewObj(res2)) delete temp;
    8848             :     }
    8849             :   }
    8850          15 :   result = (arg1)->cut(arg2);
    8851           6 :   resultobj = SWIG_NewPointerObj((new kdb::KeySet(static_cast< const kdb::KeySet& >(result))), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_OWN |  0 );
    8852             :   return resultobj;
    8853             : fail:
    8854             :   return NULL;
    8855             : }
    8856             : 
    8857             : 
    8858           0 : SWIGINTERN PyObject *_wrap_KeySet__lookup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    8859           0 :   PyObject *resultobj = 0;
    8860           0 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8861           0 :   kdb::Key *arg2 = 0 ;
    8862             :   option_t arg3 ;
    8863           0 :   void *argp1 = 0 ;
    8864           0 :   int res1 = 0 ;
    8865           0 :   void *argp2 = 0 ;
    8866           0 :   int res2 = 0 ;
    8867             :   void *argp3 ;
    8868           0 :   int res3 = 0 ;
    8869           0 :   kdb::Key result;
    8870             :   
    8871           0 :   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
    8872           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8873           0 :   if (!SWIG_IsOK(res1)) {
    8874           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet__lookup" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    8875             :   }
    8876           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8877           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    8878           0 :   if (!SWIG_IsOK(res2)) {
    8879           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet__lookup" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    8880             :   }
    8881           0 :   if (!argp2) {
    8882           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    8883             :   }
    8884           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    8885             :   {
    8886           0 :     res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_option_t,  0  | 0);
    8887           0 :     if (!SWIG_IsOK(res3)) {
    8888           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KeySet__lookup" "', argument " "3"" of type '" "option_t const""'"); 
    8889             :     }  
    8890           0 :     if (!argp3) {
    8891           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "3"" of type '" "option_t const""'");
    8892             :     } else {
    8893           0 :       option_t * temp = reinterpret_cast< option_t * >(argp3);
    8894           0 :       arg3 = *temp;
    8895           0 :       if (SWIG_IsNewObj(res3)) delete temp;
    8896             :     }
    8897             :   }
    8898           0 :   result = ((kdb::KeySet const *)arg1)->lookup((kdb::Key const &)*arg2,arg3);
    8899           0 :   resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN |  0 );
    8900             :   return resultobj;
    8901             : fail:
    8902             :   return NULL;
    8903             : }
    8904             : 
    8905             : 
    8906          11 : SWIGINTERN PyObject *_wrap_KeySet__lookup__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    8907          11 :   PyObject *resultobj = 0;
    8908          11 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8909          11 :   kdb::Key *arg2 = 0 ;
    8910          11 :   void *argp1 = 0 ;
    8911          11 :   int res1 = 0 ;
    8912          11 :   void *argp2 = 0 ;
    8913          11 :   int res2 = 0 ;
    8914          22 :   kdb::Key result;
    8915             :   
    8916          11 :   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
    8917          11 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8918          11 :   if (!SWIG_IsOK(res1)) {
    8919           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet__lookup" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    8920             :   }
    8921          11 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8922          11 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0  | 0);
    8923          11 :   if (!SWIG_IsOK(res2)) {
    8924           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet__lookup" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    8925             :   }
    8926          11 :   if (!argp2) {
    8927           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "2"" of type '" "kdb::Key const &""'"); 
    8928             :   }
    8929          11 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    8930          33 :   result = ((kdb::KeySet const *)arg1)->lookup((kdb::Key const &)*arg2);
    8931          22 :   resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN |  0 );
    8932             :   return resultobj;
    8933             : fail:
    8934             :   return NULL;
    8935             : }
    8936             : 
    8937             : 
    8938           0 : SWIGINTERN PyObject *_wrap_KeySet__lookup__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    8939           0 :   PyObject *resultobj = 0;
    8940           0 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8941           0 :   std::string *arg2 = 0 ;
    8942             :   option_t arg3 ;
    8943           0 :   void *argp1 = 0 ;
    8944           0 :   int res1 = 0 ;
    8945           0 :   int res2 = SWIG_OLDOBJ ;
    8946             :   void *argp3 ;
    8947           0 :   int res3 = 0 ;
    8948           0 :   kdb::Key result;
    8949             :   
    8950           0 :   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
    8951           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    8952           0 :   if (!SWIG_IsOK(res1)) {
    8953           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet__lookup" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    8954             :   }
    8955           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    8956             :   {
    8957           0 :     std::string *ptr = (std::string *)0;
    8958           0 :     res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    8959           0 :     if (!SWIG_IsOK(res2)) {
    8960           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet__lookup" "', argument " "2"" of type '" "std::string const &""'"); 
    8961             :     }
    8962           0 :     if (!ptr) {
    8963           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "2"" of type '" "std::string const &""'"); 
    8964             :     }
    8965           0 :     arg2 = ptr;
    8966             :   }
    8967             :   {
    8968           0 :     res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_option_t,  0  | 0);
    8969           0 :     if (!SWIG_IsOK(res3)) {
    8970           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KeySet__lookup" "', argument " "3"" of type '" "option_t const""'"); 
    8971             :     }  
    8972           0 :     if (!argp3) {
    8973           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "3"" of type '" "option_t const""'");
    8974             :     } else {
    8975           0 :       option_t * temp = reinterpret_cast< option_t * >(argp3);
    8976           0 :       arg3 = *temp;
    8977           0 :       if (SWIG_IsNewObj(res3)) delete temp;
    8978             :     }
    8979             :   }
    8980           0 :   result = ((kdb::KeySet const *)arg1)->lookup((std::string const &)*arg2,arg3);
    8981           0 :   resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN |  0 );
    8982           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    8983             :   return resultobj;
    8984             : fail:
    8985           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    8986             :   return NULL;
    8987             : }
    8988             : 
    8989             : 
    8990           6 : SWIGINTERN PyObject *_wrap_KeySet__lookup__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    8991           6 :   PyObject *resultobj = 0;
    8992           6 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    8993           6 :   std::string *arg2 = 0 ;
    8994           6 :   void *argp1 = 0 ;
    8995           6 :   int res1 = 0 ;
    8996           6 :   int res2 = SWIG_OLDOBJ ;
    8997          12 :   kdb::Key result;
    8998             :   
    8999           6 :   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
    9000           6 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    9001           6 :   if (!SWIG_IsOK(res1)) {
    9002           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet__lookup" "', argument " "1"" of type '" "kdb::KeySet const *""'"); 
    9003             :   }
    9004           6 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    9005             :   {
    9006           6 :     std::string *ptr = (std::string *)0;
    9007           6 :     res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    9008           6 :     if (!SWIG_IsOK(res2)) {
    9009           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet__lookup" "', argument " "2"" of type '" "std::string const &""'"); 
    9010             :     }
    9011           6 :     if (!ptr) {
    9012           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "2"" of type '" "std::string const &""'"); 
    9013             :     }
    9014           6 :     arg2 = ptr;
    9015             :   }
    9016          18 :   result = ((kdb::KeySet const *)arg1)->lookup((std::string const &)*arg2);
    9017          12 :   resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN |  0 );
    9018          12 :   if (SWIG_IsNewObj(res2)) delete arg2;
    9019             :   return resultobj;
    9020             : fail:
    9021             :   if (SWIG_IsNewObj(res2)) delete arg2;
    9022             :   return NULL;
    9023             : }
    9024             : 
    9025             : 
    9026          31 : SWIGINTERN PyObject *_wrap_KeySet__lookup(PyObject *self, PyObject *args) {
    9027             :   Py_ssize_t argc;
    9028             :   PyObject *argv[4] = {
    9029             :     0
    9030          31 :   };
    9031             :   
    9032          31 :   if (!(argc = SWIG_Python_UnpackTuple(args,"KeySet__lookup",0,3,argv))) SWIG_fail;
    9033          31 :   --argc;
    9034          31 :   if (argc == 2) {
    9035          31 :     int _v = 0;
    9036             :     {
    9037          31 :       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_kdb__Key, 0);
    9038          31 :       _v = SWIG_CheckState(res);
    9039             :     }
    9040          31 :     if (!_v) goto check_1;
    9041          11 :     return _wrap_KeySet__lookup__SWIG_2(self, argc, argv);
    9042             :   }
    9043             : check_1:
    9044             :   
    9045          20 :   if (argc == 2) {
    9046          20 :     int _v = 0;
    9047             :     {
    9048             :       {
    9049          20 :         int res = SWIG_AsVal_long(argv[1], NULL);
    9050          20 :         _v = SWIG_CheckState(res);
    9051             :       }
    9052             :     }
    9053          20 :     if (!_v) goto check_2;
    9054          14 :     return _wrap_KeySet__lookup__SWIG_0(self, argc, argv);
    9055             :   }
    9056             : check_2:
    9057             :   
    9058           6 :   if (argc == 2) {
    9059           6 :     return _wrap_KeySet__lookup__SWIG_4(self, argc, argv);
    9060             :   }
    9061           0 :   if (argc == 3) {
    9062           0 :     int _v = 0;
    9063             :     {
    9064           0 :       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_kdb__Key, 0);
    9065           0 :       _v = SWIG_CheckState(res);
    9066             :     }
    9067           0 :     if (!_v) goto check_4;
    9068           0 :     return _wrap_KeySet__lookup__SWIG_1(self, argc, argv);
    9069             :   }
    9070             : check_4:
    9071             :   
    9072           0 :   if (argc == 3) {
    9073           0 :     return _wrap_KeySet__lookup__SWIG_3(self, argc, argv);
    9074             :   }
    9075             :   
    9076             : fail:
    9077             :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'KeySet__lookup'.\n"
    9078             :     "  Possible C/C++ prototypes are:\n"
    9079             :     "    kdb::KeySet::at(cursor_t) const\n"
    9080             :     "    kdb::KeySet::lookup(kdb::Key const &,option_t const) const\n"
    9081             :     "    kdb::KeySet::lookup(kdb::Key const &) const\n"
    9082             :     "    kdb::KeySet::lookup(std::string const &,option_t const) const\n"
    9083           0 :     "    kdb::KeySet::lookup(std::string const &) const\n");
    9084             :   return 0;
    9085             : }
    9086             : 
    9087             : 
    9088          15 : SWIGINTERN PyObject *_wrap_new_KeySet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    9089          15 :   PyObject *resultobj = 0;
    9090             :   size_t arg1 ;
    9091             :   size_t val1 ;
    9092          15 :   int ecode1 = 0 ;
    9093          15 :   kdb::KeySet *result = 0 ;
    9094             :   
    9095          15 :   if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
    9096          30 :   ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
    9097          15 :   if (!SWIG_IsOK(ecode1)) {
    9098           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeySet" "', argument " "1"" of type '" "size_t""'");
    9099             :   } 
    9100          15 :   arg1 = static_cast< size_t >(val1);
    9101          15 :   result = (kdb::KeySet *)new_kdb_KeySet__SWIG_3(arg1);
    9102          15 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_NEW |  0 );
    9103             :   return resultobj;
    9104             : fail:
    9105             :   return NULL;
    9106             : }
    9107             : 
    9108             : 
    9109          18 : SWIGINTERN PyObject *_wrap_new_KeySet(PyObject *self, PyObject *args) {
    9110             :   Py_ssize_t argc;
    9111             :   PyObject *argv[2] = {
    9112             :     0
    9113          18 :   };
    9114             :   
    9115          18 :   if (!(argc = SWIG_Python_UnpackTuple(args,"new_KeySet",0,1,argv))) SWIG_fail;
    9116          18 :   --argc;
    9117          18 :   if (argc == 0) {
    9118           1 :     return _wrap_new_KeySet__SWIG_0(self, argc, argv);
    9119             :   }
    9120          17 :   if (argc == 1) {
    9121          17 :     int _v = 0;
    9122             :     {
    9123          17 :       void *vptr = 0;
    9124          17 :       int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__KeySet, 0);
    9125          17 :       _v = SWIG_CheckState(res);
    9126             :     }
    9127          17 :     if (!_v) goto check_2;
    9128           1 :     return _wrap_new_KeySet__SWIG_1(self, argc, argv);
    9129             :   }
    9130             : check_2:
    9131             :   
    9132          16 :   if (argc == 1) {
    9133          16 :     int _v = 0;
    9134             :     {
    9135          16 :       int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_kdb__KeySet, 0);
    9136          16 :       _v = SWIG_CheckState(res);
    9137             :     }
    9138          16 :     if (!_v) goto check_3;
    9139           1 :     return _wrap_new_KeySet__SWIG_2(self, argc, argv);
    9140             :   }
    9141             : check_3:
    9142             :   
    9143          15 :   if (argc == 1) {
    9144          15 :     return _wrap_new_KeySet__SWIG_3(self, argc, argv);
    9145             :   }
    9146             :   
    9147             : fail:
    9148             :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_KeySet'.\n"
    9149             :     "  Possible C/C++ prototypes are:\n"
    9150             :     "    kdb::KeySet::KeySet()\n"
    9151             :     "    kdb::KeySet::KeySet(ckdb::KeySet *)\n"
    9152             :     "    kdb::KeySet::KeySet(kdb::KeySet const &)\n"
    9153           0 :     "    kdb::KeySet::KeySet(size_t)\n");
    9154             :   return 0;
    9155             : }
    9156             : 
    9157             : 
    9158           1 : SWIGINTERN PyObject *_wrap_KeySet___copy__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9159           1 :   PyObject *resultobj = 0;
    9160           1 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    9161           1 :   void *argp1 = 0 ;
    9162           1 :   int res1 = 0 ;
    9163             :   PyObject *swig_obj[1] ;
    9164           1 :   kdb::KeySet *result = 0 ;
    9165             :   
    9166           1 :   if (!args) SWIG_fail;
    9167           1 :   swig_obj[0] = args;
    9168           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    9169           1 :   if (!SWIG_IsOK(res1)) {
    9170           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet___copy__" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    9171             :   }
    9172           1 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    9173           1 :   result = (kdb::KeySet *)kdb_KeySet___copy__(arg1);
    9174           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    9175             :   return resultobj;
    9176             : fail:
    9177             :   return NULL;
    9178             : }
    9179             : 
    9180             : 
    9181           1 : SWIGINTERN PyObject *_wrap_KeySet___deepcopy__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9182           1 :   PyObject *resultobj = 0;
    9183           1 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    9184           1 :   PyObject *arg2 = (PyObject *) 0 ;
    9185           1 :   void *argp1 = 0 ;
    9186           1 :   int res1 = 0 ;
    9187             :   PyObject *swig_obj[2] ;
    9188           1 :   kdb::KeySet *result = 0 ;
    9189             :   
    9190           1 :   if (!SWIG_Python_UnpackTuple(args,"KeySet___deepcopy__",2,2,swig_obj)) SWIG_fail;
    9191           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    9192           1 :   if (!SWIG_IsOK(res1)) {
    9193           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet___deepcopy__" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    9194             :   }
    9195           1 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    9196           1 :   arg2 = swig_obj[1];
    9197           1 :   result = (kdb::KeySet *)kdb_KeySet___deepcopy__(arg1,arg2);
    9198           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    9199             :   return resultobj;
    9200             : fail:
    9201             :   return NULL;
    9202             : }
    9203             : 
    9204             : 
    9205           2 : SWIGINTERN PyObject *_wrap_KeySet___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9206           2 :   PyObject *resultobj = 0;
    9207           2 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    9208           2 :   PyObject **arg2 = (PyObject **) 0 ;
    9209           2 :   void *argp1 = 0 ;
    9210           2 :   int res1 = 0 ;
    9211             :   PyObject *swig_obj[1] ;
    9212           2 :   swig::SwigPyIterator *result = 0 ;
    9213             :   
    9214           2 :   arg2 = &swig_obj[0];
    9215           2 :   if (!args) SWIG_fail;
    9216           2 :   swig_obj[0] = args;
    9217           2 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    9218           2 :   if (!SWIG_IsOK(res1)) {
    9219           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet___iter__" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    9220             :   }
    9221           2 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    9222           2 :   result = (swig::SwigPyIterator *)kdb_KeySet___iter__(arg1,arg2);
    9223           2 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    9224             :   return resultobj;
    9225             : fail:
    9226             :   return NULL;
    9227             : }
    9228             : 
    9229             : 
    9230           1 : SWIGINTERN PyObject *_wrap_KeySet___reversed__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9231           1 :   PyObject *resultobj = 0;
    9232           1 :   kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
    9233           1 :   PyObject **arg2 = (PyObject **) 0 ;
    9234           1 :   void *argp1 = 0 ;
    9235           1 :   int res1 = 0 ;
    9236             :   PyObject *swig_obj[1] ;
    9237           1 :   swig::SwigPyIterator *result = 0 ;
    9238             :   
    9239           1 :   arg2 = &swig_obj[0];
    9240           1 :   if (!args) SWIG_fail;
    9241           1 :   swig_obj[0] = args;
    9242           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 |  0 );
    9243           1 :   if (!SWIG_IsOK(res1)) {
    9244           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet___reversed__" "', argument " "1"" of type '" "kdb::KeySet *""'"); 
    9245             :   }
    9246           1 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    9247           1 :   result = (swig::SwigPyIterator *)kdb_KeySet___reversed__(arg1,arg2);
    9248           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
    9249             :   return resultobj;
    9250             : fail:
    9251             :   return NULL;
    9252             : }
    9253             : 
    9254             : 
    9255           3 : SWIGINTERN PyObject *KeySet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9256             :   PyObject *obj;
    9257           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    9258           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeySet, SWIG_NewClientData(obj));
    9259           3 :   return SWIG_Py_Void();
    9260             : }
    9261             : 
    9262          18 : SWIGINTERN PyObject *KeySet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9263          18 :   return SWIG_Python_InitShadowInstance(args);
    9264             : }
    9265             : 
    9266           0 : SWIGINTERN PyObject *_wrap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9267           0 :   PyObject *resultobj = 0;
    9268           0 :   kdb::KeySet *arg1 = 0 ;
    9269           0 :   kdb::KeySet *arg2 = 0 ;
    9270           0 :   void *argp1 = 0 ;
    9271           0 :   int res1 = 0 ;
    9272           0 :   void *argp2 = 0 ;
    9273           0 :   int res2 = 0 ;
    9274             :   PyObject *swig_obj[2] ;
    9275             :   bool result;
    9276             :   
    9277           0 :   if (!SWIG_Python_UnpackTuple(args,"__eq__",2,2,swig_obj)) SWIG_fail;
    9278           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_kdb__KeySet,  0  | 0);
    9279           0 :   if (!SWIG_IsOK(res1)) {
    9280           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "kdb::KeySet const &""'"); 
    9281             :   }
    9282           0 :   if (!argp1) {
    9283           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "kdb::KeySet const &""'"); 
    9284             :   }
    9285           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    9286           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0  | 0);
    9287           0 :   if (!SWIG_IsOK(res2)) {
    9288           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "kdb::KeySet const &""'"); 
    9289             :   }
    9290           0 :   if (!argp2) {
    9291           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "kdb::KeySet const &""'"); 
    9292             :   }
    9293           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
    9294           0 :   result = (bool)kdb::operator ==((kdb::KeySet const &)*arg1,(kdb::KeySet const &)*arg2);
    9295             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9296             :   return resultobj;
    9297             : fail:
    9298             :   return NULL;
    9299             : }
    9300             : 
    9301             : 
    9302           0 : SWIGINTERN PyObject *_wrap___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9303           0 :   PyObject *resultobj = 0;
    9304           0 :   kdb::KeySet *arg1 = 0 ;
    9305           0 :   kdb::KeySet *arg2 = 0 ;
    9306           0 :   void *argp1 = 0 ;
    9307           0 :   int res1 = 0 ;
    9308           0 :   void *argp2 = 0 ;
    9309           0 :   int res2 = 0 ;
    9310             :   PyObject *swig_obj[2] ;
    9311             :   bool result;
    9312             :   
    9313           0 :   if (!SWIG_Python_UnpackTuple(args,"__ne__",2,2,swig_obj)) SWIG_fail;
    9314           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_kdb__KeySet,  0  | 0);
    9315           0 :   if (!SWIG_IsOK(res1)) {
    9316           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "kdb::KeySet const &""'"); 
    9317             :   }
    9318           0 :   if (!argp1) {
    9319           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "kdb::KeySet const &""'"); 
    9320             :   }
    9321           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
    9322           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0  | 0);
    9323           0 :   if (!SWIG_IsOK(res2)) {
    9324           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "kdb::KeySet const &""'"); 
    9325             :   }
    9326           0 :   if (!argp2) {
    9327           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "kdb::KeySet const &""'"); 
    9328             :   }
    9329           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
    9330           0 :   result = (bool)kdb::operator !=((kdb::KeySet const &)*arg1,(kdb::KeySet const &)*arg2);
    9331             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9332             :   return resultobj;
    9333             : fail:
    9334             :   return NULL;
    9335             : }
    9336             : 
    9337             : 
    9338           5 : SWIGINTERN PyObject *_wrap_new_KDB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
    9339           5 :   PyObject *resultobj = 0;
    9340           5 :   kdb::KDB *result = 0 ;
    9341             :   
    9342           5 :   if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
    9343             :   {
    9344             :     try {
    9345           5 :       result = (kdb::KDB *)new kdb::KDB();    
    9346           0 :     }    KDB_EXCEPTIONS    catch (const std::exception & e) {
    9347           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    9348           0 :     }    catch (...) {
    9349           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::KDB()");    
    9350             :     }
    9351             :   }
    9352           5 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KDB, SWIG_POINTER_NEW |  0 );
    9353             :   return resultobj;
    9354             : fail:
    9355             :   return NULL;
    9356             : }
    9357             : 
    9358             : 
    9359           1 : SWIGINTERN PyObject *_wrap_new_KDB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    9360           1 :   PyObject *resultobj = 0;
    9361           1 :   kdb::Key *arg1 = 0 ;
    9362           1 :   void *argp1 = 0 ;
    9363           1 :   int res1 = 0 ;
    9364           1 :   kdb::KDB *result = 0 ;
    9365             :   
    9366           1 :   if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
    9367           1 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_kdb__Key,  0 );
    9368           1 :   if (!SWIG_IsOK(res1)) {
    9369           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KDB" "', argument " "1"" of type '" "kdb::Key &""'"); 
    9370             :   }
    9371           1 :   if (!argp1) {
    9372           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KDB" "', argument " "1"" of type '" "kdb::Key &""'"); 
    9373             :   }
    9374           1 :   arg1 = reinterpret_cast< kdb::Key * >(argp1);
    9375             :   {
    9376             :     try {
    9377           2 :       result = (kdb::KDB *)new kdb::KDB(*arg1);    
    9378           0 :     }    KDB_EXCEPTIONS    catch (const std::exception & e) {
    9379           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    9380           0 :     }    catch (...) {
    9381           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::KDB(kdb::Key &)");    
    9382             :     }
    9383             :   }
    9384           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KDB, SWIG_POINTER_NEW |  0 );
    9385             :   return resultobj;
    9386             : fail:
    9387             :   return NULL;
    9388             : }
    9389             : 
    9390             : 
    9391           6 : SWIGINTERN PyObject *_wrap_new_KDB(PyObject *self, PyObject *args) {
    9392             :   Py_ssize_t argc;
    9393             :   PyObject *argv[2] = {
    9394             :     0
    9395           6 :   };
    9396             :   
    9397           6 :   if (!(argc = SWIG_Python_UnpackTuple(args,"new_KDB",0,1,argv))) SWIG_fail;
    9398           6 :   --argc;
    9399           6 :   if (argc == 0) {
    9400           5 :     return _wrap_new_KDB__SWIG_0(self, argc, argv);
    9401             :   }
    9402           1 :   if (argc == 1) {
    9403           1 :     return _wrap_new_KDB__SWIG_1(self, argc, argv);
    9404             :   }
    9405             :   
    9406             : fail:
    9407             :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_KDB'.\n"
    9408             :     "  Possible C/C++ prototypes are:\n"
    9409             :     "    kdb::KDB::KDB()\n"
    9410           0 :     "    kdb::KDB::KDB(kdb::Key &)\n");
    9411             :   return 0;
    9412             : }
    9413             : 
    9414             : 
    9415           6 : SWIGINTERN PyObject *_wrap_delete_KDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9416           6 :   PyObject *resultobj = 0;
    9417           6 :   kdb::KDB *arg1 = (kdb::KDB *) 0 ;
    9418           6 :   void *argp1 = 0 ;
    9419           6 :   int res1 = 0 ;
    9420             :   PyObject *swig_obj[1] ;
    9421             :   
    9422           6 :   if (!args) SWIG_fail;
    9423           6 :   swig_obj[0] = args;
    9424           6 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, SWIG_POINTER_DISOWN |  0 );
    9425           6 :   if (!SWIG_IsOK(res1)) {
    9426           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KDB" "', argument " "1"" of type '" "kdb::KDB *""'"); 
    9427             :   }
    9428           6 :   arg1 = reinterpret_cast< kdb::KDB * >(argp1);
    9429             :   {
    9430             :     try {
    9431           6 :       delete arg1;    
    9432             :     }    KDB_EXCEPTIONS    catch (const std::exception & e) {
    9433             :       SWIG_exception(SWIG_RuntimeError, e.what());    
    9434             :     }    catch (...) {
    9435             :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::~KDB()");    
    9436             :     }
    9437             :   }
    9438           6 :   resultobj = SWIG_Py_Void();
    9439           6 :   return resultobj;
    9440             : fail:
    9441             :   return NULL;
    9442             : }
    9443             : 
    9444             : 
    9445           0 : SWIGINTERN PyObject *_wrap_KDB_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9446           0 :   PyObject *resultobj = 0;
    9447           0 :   kdb::KDB *arg1 = (kdb::KDB *) 0 ;
    9448           0 :   kdb::Key *arg2 = 0 ;
    9449           0 :   void *argp1 = 0 ;
    9450           0 :   int res1 = 0 ;
    9451           0 :   void *argp2 = 0 ;
    9452           0 :   int res2 = 0 ;
    9453             :   PyObject *swig_obj[2] ;
    9454             :   
    9455           0 :   if (!SWIG_Python_UnpackTuple(args,"KDB_open",2,2,swig_obj)) SWIG_fail;
    9456           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 |  0 );
    9457           0 :   if (!SWIG_IsOK(res1)) {
    9458           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_open" "', argument " "1"" of type '" "kdb::KDB *""'"); 
    9459             :   }
    9460           0 :   arg1 = reinterpret_cast< kdb::KDB * >(argp1);
    9461           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0 );
    9462           0 :   if (!SWIG_IsOK(res2)) {
    9463           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_open" "', argument " "2"" of type '" "kdb::Key &""'"); 
    9464             :   }
    9465           0 :   if (!argp2) {
    9466           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_open" "', argument " "2"" of type '" "kdb::Key &""'"); 
    9467             :   }
    9468           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    9469             :   {
    9470             :     try {
    9471           0 :       (arg1)->open(*arg2);    
    9472           0 :     }    KDB_EXCEPTIONS    catch (const std::exception & e) {
    9473           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    9474           0 :     }    catch (...) {
    9475           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::open(kdb::Key &)");    
    9476             :     }
    9477             :   }
    9478           0 :   resultobj = SWIG_Py_Void();
    9479           0 :   return resultobj;
    9480             : fail:
    9481             :   return NULL;
    9482             : }
    9483             : 
    9484             : 
    9485           0 : SWIGINTERN PyObject *_wrap_KDB_close__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    9486           0 :   PyObject *resultobj = 0;
    9487           0 :   kdb::KDB *arg1 = (kdb::KDB *) 0 ;
    9488           0 :   void *argp1 = 0 ;
    9489           0 :   int res1 = 0 ;
    9490             :   
    9491           0 :   if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
    9492           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 |  0 );
    9493           0 :   if (!SWIG_IsOK(res1)) {
    9494           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_close" "', argument " "1"" of type '" "kdb::KDB *""'"); 
    9495             :   }
    9496           0 :   arg1 = reinterpret_cast< kdb::KDB * >(argp1);
    9497             :   {
    9498             :     try {
    9499           0 :       (arg1)->close();    
    9500             :     }    KDB_EXCEPTIONS    catch (const std::exception & e) {
    9501             :       SWIG_exception(SWIG_RuntimeError, e.what());    
    9502             :     }    catch (...) {
    9503             :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::close()");    
    9504             :     }
    9505             :   }
    9506           0 :   resultobj = SWIG_Py_Void();
    9507             :   return resultobj;
    9508             : fail:
    9509             :   return NULL;
    9510             : }
    9511             : 
    9512             : 
    9513           4 : SWIGINTERN PyObject *_wrap_KDB_close__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    9514           4 :   PyObject *resultobj = 0;
    9515           4 :   kdb::KDB *arg1 = (kdb::KDB *) 0 ;
    9516           4 :   kdb::Key *arg2 = 0 ;
    9517           4 :   void *argp1 = 0 ;
    9518           4 :   int res1 = 0 ;
    9519           4 :   void *argp2 = 0 ;
    9520           4 :   int res2 = 0 ;
    9521             :   
    9522           4 :   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
    9523           4 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 |  0 );
    9524           4 :   if (!SWIG_IsOK(res1)) {
    9525           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_close" "', argument " "1"" of type '" "kdb::KDB *""'"); 
    9526             :   }
    9527           4 :   arg1 = reinterpret_cast< kdb::KDB * >(argp1);
    9528           4 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key,  0 );
    9529           4 :   if (!SWIG_IsOK(res2)) {
    9530           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_close" "', argument " "2"" of type '" "kdb::Key &""'"); 
    9531             :   }
    9532           4 :   if (!argp2) {
    9533           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_close" "', argument " "2"" of type '" "kdb::Key &""'"); 
    9534             :   }
    9535           4 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
    9536             :   {
    9537             :     try {
    9538           4 :       (arg1)->close(*arg2);    
    9539             :     }    KDB_EXCEPTIONS    catch (const std::exception & e) {
    9540             :       SWIG_exception(SWIG_RuntimeError, e.what());    
    9541             :     }    catch (...) {
    9542             :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::close(kdb::Key &)");    
    9543             :     }
    9544             :   }
    9545           4 :   resultobj = SWIG_Py_Void();
    9546             :   return resultobj;
    9547             : fail:
    9548             :   return NULL;
    9549             : }
    9550             : 
    9551             : 
    9552           4 : SWIGINTERN PyObject *_wrap_KDB_close(PyObject *self, PyObject *args) {
    9553             :   Py_ssize_t argc;
    9554             :   PyObject *argv[3] = {
    9555             :     0
    9556           4 :   };
    9557             :   
    9558           4 :   if (!(argc = SWIG_Python_UnpackTuple(args,"KDB_close",0,2,argv))) SWIG_fail;
    9559           4 :   --argc;
    9560           4 :   if (argc == 1) {
    9561           0 :     return _wrap_KDB_close__SWIG_0(self, argc, argv);
    9562             :   }
    9563           4 :   if (argc == 2) {
    9564           4 :     return _wrap_KDB_close__SWIG_1(self, argc, argv);
    9565             :   }
    9566             :   
    9567             : fail:
    9568             :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'KDB_close'.\n"
    9569             :     "  Possible C/C++ prototypes are:\n"
    9570             :     "    kdb::KDB::close()\n"
    9571           0 :     "    kdb::KDB::close(kdb::Key &)\n");
    9572             :   return 0;
    9573             : }
    9574             : 
    9575             : 
    9576           4 : SWIGINTERN PyObject *_wrap_KDB_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    9577           4 :   PyObject *resultobj = 0;
    9578           4 :   kdb::KDB *arg1 = (kdb::KDB *) 0 ;
    9579           4 :   kdb::KeySet *arg2 = 0 ;
    9580           4 :   std::string *arg3 = 0 ;
    9581           4 :   void *argp1 = 0 ;
    9582           4 :   int res1 = 0 ;
    9583           4 :   void *argp2 = 0 ;
    9584           4 :   int res2 = 0 ;
    9585           4 :   int res3 = SWIG_OLDOBJ ;
    9586             :   int result;
    9587             :   
    9588           4 :   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
    9589           4 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 |  0 );
    9590           4 :   if (!SWIG_IsOK(res1)) {
    9591           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_get" "', argument " "1"" of type '" "kdb::KDB *""'"); 
    9592             :   }
    9593           4 :   arg1 = reinterpret_cast< kdb::KDB * >(argp1);
    9594           4 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
    9595           4 :   if (!SWIG_IsOK(res2)) {
    9596           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_get" "', argument " "2"" of type '" "kdb::KeySet &""'"); 
    9597             :   }
    9598           4 :   if (!argp2) {
    9599           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_get" "', argument " "2"" of type '" "kdb::KeySet &""'"); 
    9600             :   }
    9601           4 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
    9602             :   {
    9603           4 :     std::string *ptr = (std::string *)0;
    9604           4 :     res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    9605           4 :     if (!SWIG_IsOK(res3)) {
    9606           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KDB_get" "', argument " "3"" of type '" "std::string const &""'"); 
    9607             :     }
    9608           4 :     if (!ptr) {
    9609           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_get" "', argument " "3"" of type '" "std::string const &""'"); 
    9610             :     }
    9611           4 :     arg3 = ptr;
    9612             :   }
    9613             :   {
    9614             :     try {
    9615           8 :       result = (int)(arg1)->get(*arg2,(std::string const &)*arg3);    
    9616           0 :     }    KDB_EXCEPTIONS    catch (const std::exception & e) {
    9617           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    9618           0 :     }    catch (...) {
    9619           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::get(kdb::KeySet &,std::string const &)");    
    9620             :     }
    9621             :   }
    9622           4 :   resultobj = SWIG_From_int(static_cast< int >(result));
    9623           8 :   if (SWIG_IsNewObj(res3)) delete arg3;
    9624             :   return resultobj;
    9625             : fail:
    9626           0 :   if (SWIG_IsNewObj(res3)) delete arg3;
    9627             :   return NULL;
    9628             : }
    9629             : 
    9630             : 
    9631           0 : SWIGINTERN PyObject *_wrap_KDB_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    9632           0 :   PyObject *resultobj = 0;
    9633           0 :   kdb::KDB *arg1 = (kdb::KDB *) 0 ;
    9634           0 :   kdb::KeySet *arg2 = 0 ;
    9635           0 :   kdb::Key *arg3 = 0 ;
    9636           0 :   void *argp1 = 0 ;
    9637           0 :   int res1 = 0 ;
    9638           0 :   void *argp2 = 0 ;
    9639           0 :   int res2 = 0 ;
    9640           0 :   void *argp3 = 0 ;
    9641           0 :   int res3 = 0 ;
    9642             :   int result;
    9643             :   
    9644           0 :   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
    9645           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 |  0 );
    9646           0 :   if (!SWIG_IsOK(res1)) {
    9647           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_get" "', argument " "1"" of type '" "kdb::KDB *""'"); 
    9648             :   }
    9649           0 :   arg1 = reinterpret_cast< kdb::KDB * >(argp1);
    9650           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
    9651           0 :   if (!SWIG_IsOK(res2)) {
    9652           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_get" "', argument " "2"" of type '" "kdb::KeySet &""'"); 
    9653             :   }
    9654           0 :   if (!argp2) {
    9655           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_get" "', argument " "2"" of type '" "kdb::KeySet &""'"); 
    9656             :   }
    9657           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
    9658           0 :   res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_kdb__Key,  0 );
    9659           0 :   if (!SWIG_IsOK(res3)) {
    9660           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KDB_get" "', argument " "3"" of type '" "kdb::Key &""'"); 
    9661             :   }
    9662           0 :   if (!argp3) {
    9663           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_get" "', argument " "3"" of type '" "kdb::Key &""'"); 
    9664             :   }
    9665           0 :   arg3 = reinterpret_cast< kdb::Key * >(argp3);
    9666             :   {
    9667             :     try {
    9668           0 :       result = (int)(arg1)->get(*arg2,*arg3);    
    9669           0 :     }    KDB_EXCEPTIONS    catch (const std::exception & e) {
    9670           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    9671           0 :     }    catch (...) {
    9672           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::get(kdb::KeySet &,kdb::Key &)");    
    9673             :     }
    9674             :   }
    9675             :   resultobj = SWIG_From_int(static_cast< int >(result));
    9676             :   return resultobj;
    9677             : fail:
    9678             :   return NULL;
    9679             : }
    9680             : 
    9681             : 
    9682           4 : SWIGINTERN PyObject *_wrap_KDB_get(PyObject *self, PyObject *args) {
    9683             :   Py_ssize_t argc;
    9684             :   PyObject *argv[4] = {
    9685             :     0
    9686           4 :   };
    9687             :   
    9688           4 :   if (!(argc = SWIG_Python_UnpackTuple(args,"KDB_get",0,3,argv))) SWIG_fail;
    9689           4 :   --argc;
    9690           4 :   if (argc == 3) {
    9691           4 :     int _v = 0;
    9692             :     {
    9693           4 :       void *vptr = 0;
    9694           4 :       int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_kdb__Key, 0);
    9695           4 :       _v = SWIG_CheckState(res);
    9696             :     }
    9697           4 :     if (!_v) goto check_1;
    9698           0 :     return _wrap_KDB_get__SWIG_1(self, argc, argv);
    9699             :   }
    9700             : check_1:
    9701             :   
    9702           4 :   if (argc == 3) {
    9703           4 :     return _wrap_KDB_get__SWIG_0(self, argc, argv);
    9704             :   }
    9705             :   
    9706             : fail:
    9707             :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'KDB_get'.\n"
    9708             :     "  Possible C/C++ prototypes are:\n"
    9709             :     "    kdb::KDB::get(kdb::KeySet &,std::string const &)\n"
    9710           0 :     "    kdb::KDB::get(kdb::KeySet &,kdb::Key &)\n");
    9711             :   return 0;
    9712             : }
    9713             : 
    9714             : 
    9715           2 : SWIGINTERN PyObject *_wrap_KDB_set__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    9716           2 :   PyObject *resultobj = 0;
    9717           2 :   kdb::KDB *arg1 = (kdb::KDB *) 0 ;
    9718           2 :   kdb::KeySet *arg2 = 0 ;
    9719           2 :   std::string *arg3 = 0 ;
    9720           2 :   void *argp1 = 0 ;
    9721           2 :   int res1 = 0 ;
    9722           2 :   void *argp2 = 0 ;
    9723           2 :   int res2 = 0 ;
    9724           2 :   int res3 = SWIG_OLDOBJ ;
    9725             :   int result;
    9726             :   
    9727           2 :   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
    9728           2 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 |  0 );
    9729           2 :   if (!SWIG_IsOK(res1)) {
    9730           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_set" "', argument " "1"" of type '" "kdb::KDB *""'"); 
    9731             :   }
    9732           2 :   arg1 = reinterpret_cast< kdb::KDB * >(argp1);
    9733           2 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
    9734           2 :   if (!SWIG_IsOK(res2)) {
    9735           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_set" "', argument " "2"" of type '" "kdb::KeySet &""'"); 
    9736             :   }
    9737           2 :   if (!argp2) {
    9738           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_set" "', argument " "2"" of type '" "kdb::KeySet &""'"); 
    9739             :   }
    9740           2 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
    9741             :   {
    9742           2 :     std::string *ptr = (std::string *)0;
    9743           2 :     res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    9744           2 :     if (!SWIG_IsOK(res3)) {
    9745           0 :       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KDB_set" "', argument " "3"" of type '" "std::string const &""'"); 
    9746             :     }
    9747           2 :     if (!ptr) {
    9748           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_set" "', argument " "3"" of type '" "std::string const &""'"); 
    9749             :     }
    9750           2 :     arg3 = ptr;
    9751             :   }
    9752             :   {
    9753             :     try {
    9754           4 :       result = (int)(arg1)->set(*arg2,(std::string const &)*arg3);    
    9755           0 :     }    KDB_EXCEPTIONS    catch (const std::exception & e) {
    9756           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    9757           0 :     }    catch (...) {
    9758           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::set(kdb::KeySet &,std::string const &)");    
    9759             :     }
    9760             :   }
    9761           2 :   resultobj = SWIG_From_int(static_cast< int >(result));
    9762           4 :   if (SWIG_IsNewObj(res3)) delete arg3;
    9763             :   return resultobj;
    9764             : fail:
    9765           0 :   if (SWIG_IsNewObj(res3)) delete arg3;
    9766             :   return NULL;
    9767             : }
    9768             : 
    9769             : 
    9770           0 : SWIGINTERN PyObject *_wrap_KDB_set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
    9771           0 :   PyObject *resultobj = 0;
    9772           0 :   kdb::KDB *arg1 = (kdb::KDB *) 0 ;
    9773           0 :   kdb::KeySet *arg2 = 0 ;
    9774           0 :   kdb::Key *arg3 = 0 ;
    9775           0 :   void *argp1 = 0 ;
    9776           0 :   int res1 = 0 ;
    9777           0 :   void *argp2 = 0 ;
    9778           0 :   int res2 = 0 ;
    9779           0 :   void *argp3 = 0 ;
    9780           0 :   int res3 = 0 ;
    9781             :   int result;
    9782             :   
    9783           0 :   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
    9784           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 |  0 );
    9785           0 :   if (!SWIG_IsOK(res1)) {
    9786           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_set" "', argument " "1"" of type '" "kdb::KDB *""'"); 
    9787             :   }
    9788           0 :   arg1 = reinterpret_cast< kdb::KDB * >(argp1);
    9789           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
    9790           0 :   if (!SWIG_IsOK(res2)) {
    9791           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_set" "', argument " "2"" of type '" "kdb::KeySet &""'"); 
    9792             :   }
    9793           0 :   if (!argp2) {
    9794           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_set" "', argument " "2"" of type '" "kdb::KeySet &""'"); 
    9795             :   }
    9796           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
    9797           0 :   res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_kdb__Key,  0 );
    9798           0 :   if (!SWIG_IsOK(res3)) {
    9799           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KDB_set" "', argument " "3"" of type '" "kdb::Key &""'"); 
    9800             :   }
    9801           0 :   if (!argp3) {
    9802           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_set" "', argument " "3"" of type '" "kdb::Key &""'"); 
    9803             :   }
    9804           0 :   arg3 = reinterpret_cast< kdb::Key * >(argp3);
    9805             :   {
    9806             :     try {
    9807           0 :       result = (int)(arg1)->set(*arg2,*arg3);    
    9808           0 :     }    KDB_EXCEPTIONS    catch (const std::exception & e) {
    9809           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    9810           0 :     }    catch (...) {
    9811           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::set(kdb::KeySet &,kdb::Key &)");    
    9812             :     }
    9813             :   }
    9814             :   resultobj = SWIG_From_int(static_cast< int >(result));
    9815             :   return resultobj;
    9816             : fail:
    9817             :   return NULL;
    9818             : }
    9819             : 
    9820             : 
    9821           2 : SWIGINTERN PyObject *_wrap_KDB_set(PyObject *self, PyObject *args) {
    9822             :   Py_ssize_t argc;
    9823             :   PyObject *argv[4] = {
    9824             :     0
    9825           2 :   };
    9826             :   
    9827           2 :   if (!(argc = SWIG_Python_UnpackTuple(args,"KDB_set",0,3,argv))) SWIG_fail;
    9828           2 :   --argc;
    9829           2 :   if (argc == 3) {
    9830           2 :     int _v = 0;
    9831             :     {
    9832           2 :       void *vptr = 0;
    9833           2 :       int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_kdb__Key, 0);
    9834           2 :       _v = SWIG_CheckState(res);
    9835             :     }
    9836           2 :     if (!_v) goto check_1;
    9837           0 :     return _wrap_KDB_set__SWIG_1(self, argc, argv);
    9838             :   }
    9839             : check_1:
    9840             :   
    9841           2 :   if (argc == 3) {
    9842           2 :     return _wrap_KDB_set__SWIG_0(self, argc, argv);
    9843             :   }
    9844             :   
    9845             : fail:
    9846             :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'KDB_set'.\n"
    9847             :     "  Possible C/C++ prototypes are:\n"
    9848             :     "    kdb::KDB::set(kdb::KeySet &,std::string const &)\n"
    9849           0 :     "    kdb::KDB::set(kdb::KeySet &,kdb::Key &)\n");
    9850             :   return 0;
    9851             : }
    9852             : 
    9853             : 
    9854           0 : SWIGINTERN PyObject *_wrap_KDB_ensure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9855           0 :   PyObject *resultobj = 0;
    9856           0 :   kdb::KDB *arg1 = (kdb::KDB *) 0 ;
    9857           0 :   kdb::KeySet *arg2 = 0 ;
    9858           0 :   kdb::Key *arg3 = 0 ;
    9859           0 :   void *argp1 = 0 ;
    9860           0 :   int res1 = 0 ;
    9861           0 :   void *argp2 = 0 ;
    9862           0 :   int res2 = 0 ;
    9863           0 :   void *argp3 = 0 ;
    9864           0 :   int res3 = 0 ;
    9865             :   PyObject *swig_obj[3] ;
    9866             :   int result;
    9867             :   
    9868           0 :   if (!SWIG_Python_UnpackTuple(args,"KDB_ensure",3,3,swig_obj)) SWIG_fail;
    9869           0 :   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 |  0 );
    9870           0 :   if (!SWIG_IsOK(res1)) {
    9871           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_ensure" "', argument " "1"" of type '" "kdb::KDB *""'"); 
    9872             :   }
    9873           0 :   arg1 = reinterpret_cast< kdb::KDB * >(argp1);
    9874           0 :   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0  | 0);
    9875           0 :   if (!SWIG_IsOK(res2)) {
    9876           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_ensure" "', argument " "2"" of type '" "kdb::KeySet const &""'"); 
    9877             :   }
    9878           0 :   if (!argp2) {
    9879           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_ensure" "', argument " "2"" of type '" "kdb::KeySet const &""'"); 
    9880             :   }
    9881           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
    9882           0 :   res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_kdb__Key,  0 );
    9883           0 :   if (!SWIG_IsOK(res3)) {
    9884           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KDB_ensure" "', argument " "3"" of type '" "kdb::Key &""'"); 
    9885             :   }
    9886           0 :   if (!argp3) {
    9887           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_ensure" "', argument " "3"" of type '" "kdb::Key &""'"); 
    9888             :   }
    9889           0 :   arg3 = reinterpret_cast< kdb::Key * >(argp3);
    9890             :   {
    9891             :     try {
    9892           0 :       result = (int)(arg1)->ensure((kdb::KeySet const &)*arg2,*arg3);    
    9893           0 :     }    KDB_EXCEPTIONS    catch (const std::exception & e) {
    9894           0 :       SWIG_exception(SWIG_RuntimeError, e.what());    
    9895           0 :     }    catch (...) {
    9896           0 :       SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::ensure(kdb::KeySet const &,kdb::Key &)");    
    9897             :     }
    9898             :   }
    9899             :   resultobj = SWIG_From_int(static_cast< int >(result));
    9900             :   return resultobj;
    9901             : fail:
    9902             :   return NULL;
    9903             : }
    9904             : 
    9905             : 
    9906           3 : SWIGINTERN PyObject *KDB_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9907             :   PyObject *obj;
    9908           3 :   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
    9909           6 :   SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KDB, SWIG_NewClientData(obj));
    9910           3 :   return SWIG_Py_Void();
    9911             : }
    9912             : 
    9913           6 : SWIGINTERN PyObject *KDB_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9914           6 :   return SWIG_Python_InitShadowInstance(args);
    9915             : }
    9916             : 
    9917             : static PyMethodDef SwigMethods[] = {
    9918             :          { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
    9919             :          { (char *)"delete_SwigPyIterator", (PyCFunction)_wrap_delete_SwigPyIterator, METH_O, NULL},
    9920             :          { (char *)"SwigPyIterator_value", (PyCFunction)_wrap_SwigPyIterator_value, METH_O, NULL},
    9921             :          { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
    9922             :          { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
    9923             :          { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
    9924             :          { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
    9925             :          { (char *)"SwigPyIterator_copy", (PyCFunction)_wrap_SwigPyIterator_copy, METH_O, NULL},
    9926             :          { (char *)"SwigPyIterator_next", (PyCFunction)_wrap_SwigPyIterator_next, METH_O, NULL},
    9927             :          { (char *)"SwigPyIterator___next__", (PyCFunction)_wrap_SwigPyIterator___next__, METH_O, NULL},
    9928             :          { (char *)"SwigPyIterator_previous", (PyCFunction)_wrap_SwigPyIterator_previous, METH_O, NULL},
    9929             :          { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
    9930             :          { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
    9931             :          { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
    9932             :          { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
    9933             :          { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
    9934             :          { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
    9935             :          { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
    9936             :          { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
    9937             :          { (char *)"Exception_what", (PyCFunction)_wrap_Exception_what, METH_O, (char *)"\n"
    9938             :                 "Exception_what(Exception self) -> char const *\n"
    9939             :                 "\n"
    9940             :                 "Parameters\n"
    9941             :                 "----------\n"
    9942             :                 "self: kdb::Exception const *\n"
    9943             :                 "\n"
    9944             :                 ""},
    9945             :          { (char *)"new_Exception", (PyCFunction)_wrap_new_Exception, METH_NOARGS, (char *)"new_Exception() -> Exception"},
    9946             :          { (char *)"delete_Exception", (PyCFunction)_wrap_delete_Exception, METH_O, (char *)"\n"
    9947             :                 "delete_Exception(Exception self)\n"
    9948             :                 "\n"
    9949             :                 "Parameters\n"
    9950             :                 "----------\n"
    9951             :                 "self: kdb::Exception *\n"
    9952             :                 "\n"
    9953             :                 ""},
    9954             :          { (char *)"Exception_swigregister", Exception_swigregister, METH_VARARGS, NULL},
    9955             :          { (char *)"Exception_swiginit", Exception_swiginit, METH_VARARGS, NULL},
    9956             :          { (char *)"new_KeyException", (PyCFunction)_wrap_new_KeyException, METH_NOARGS, (char *)"new_KeyException() -> KeyException"},
    9957             :          { (char *)"delete_KeyException", (PyCFunction)_wrap_delete_KeyException, METH_O, (char *)"\n"
    9958             :                 "delete_KeyException(KeyException self)\n"
    9959             :                 "\n"
    9960             :                 "Parameters\n"
    9961             :                 "----------\n"
    9962             :                 "self: kdb::KeyException *\n"
    9963             :                 "\n"
    9964             :                 ""},
    9965             :          { (char *)"KeyException_swigregister", KeyException_swigregister, METH_VARARGS, NULL},
    9966             :          { (char *)"KeyException_swiginit", KeyException_swiginit, METH_VARARGS, NULL},
    9967             :          { (char *)"new_KeyNotFoundException", (PyCFunction)_wrap_new_KeyNotFoundException, METH_O, (char *)"\n"
    9968             :                 "new_KeyNotFoundException(std::string message) -> KeyNotFoundException\n"
    9969             :                 "\n"
    9970             :                 "Parameters\n"
    9971             :                 "----------\n"
    9972             :                 "message: std::string\n"
    9973             :                 "\n"
    9974             :                 ""},
    9975             :          { (char *)"delete_KeyNotFoundException", (PyCFunction)_wrap_delete_KeyNotFoundException, METH_O, (char *)"\n"
    9976             :                 "delete_KeyNotFoundException(KeyNotFoundException self)\n"
    9977             :                 "\n"
    9978             :                 "Parameters\n"
    9979             :                 "----------\n"
    9980             :                 "self: kdb::KeyNotFoundException *\n"
    9981             :                 "\n"
    9982             :                 ""},
    9983             :          { (char *)"KeyNotFoundException_swigregister", KeyNotFoundException_swigregister, METH_VARARGS, NULL},
    9984             :          { (char *)"KeyNotFoundException_swiginit", KeyNotFoundException_swiginit, METH_VARARGS, NULL},
    9985             :          { (char *)"new_KeyTypeMismatch", (PyCFunction)_wrap_new_KeyTypeMismatch, METH_NOARGS, (char *)"new_KeyTypeMismatch() -> KeyTypeMismatch"},
    9986             :          { (char *)"delete_KeyTypeMismatch", (PyCFunction)_wrap_delete_KeyTypeMismatch, METH_O, (char *)"\n"
    9987             :                 "delete_KeyTypeMismatch(KeyTypeMismatch self)\n"
    9988             :                 "\n"
    9989             :                 "Parameters\n"
    9990             :                 "----------\n"
    9991             :                 "self: kdb::KeyTypeMismatch *\n"
    9992             :                 "\n"
    9993             :                 ""},
    9994             :          { (char *)"KeyTypeMismatch_swigregister", KeyTypeMismatch_swigregister, METH_VARARGS, NULL},
    9995             :          { (char *)"KeyTypeMismatch_swiginit", KeyTypeMismatch_swiginit, METH_VARARGS, NULL},
    9996             :          { (char *)"new_KeyTypeConversion", (PyCFunction)_wrap_new_KeyTypeConversion, METH_NOARGS, (char *)"new_KeyTypeConversion() -> KeyTypeConversion"},
    9997             :          { (char *)"delete_KeyTypeConversion", (PyCFunction)_wrap_delete_KeyTypeConversion, METH_O, (char *)"\n"
    9998             :                 "delete_KeyTypeConversion(KeyTypeConversion self)\n"
    9999             :                 "\n"
   10000             :                 "Parameters\n"
   10001             :                 "----------\n"
   10002             :                 "self: kdb::KeyTypeConversion *\n"
   10003             :                 "\n"
   10004             :                 ""},
   10005             :          { (char *)"KeyTypeConversion_swigregister", KeyTypeConversion_swigregister, METH_VARARGS, NULL},
   10006             :          { (char *)"KeyTypeConversion_swiginit", KeyTypeConversion_swiginit, METH_VARARGS, NULL},
   10007             :          { (char *)"new_KeyInvalidName", (PyCFunction)_wrap_new_KeyInvalidName, METH_NOARGS, (char *)"new_KeyInvalidName() -> KeyInvalidName"},
   10008             :          { (char *)"delete_KeyInvalidName", (PyCFunction)_wrap_delete_KeyInvalidName, METH_O, (char *)"\n"
   10009             :                 "delete_KeyInvalidName(KeyInvalidName self)\n"
   10010             :                 "\n"
   10011             :                 "Parameters\n"
   10012             :                 "----------\n"
   10013             :                 "self: kdb::KeyInvalidName *\n"
   10014             :                 "\n"
   10015             :                 ""},
   10016             :          { (char *)"KeyInvalidName_swigregister", KeyInvalidName_swigregister, METH_VARARGS, NULL},
   10017             :          { (char *)"KeyInvalidName_swiginit", KeyInvalidName_swiginit, METH_VARARGS, NULL},
   10018             :          { (char *)"new_KDBException", (PyCFunction)_wrap_new_KDBException, METH_O, (char *)"\n"
   10019             :                 "new_KDBException(Key key) -> KDBException\n"
   10020             :                 "\n"
   10021             :                 "Parameters\n"
   10022             :                 "----------\n"
   10023             :                 "key: Key\n"
   10024             :                 "\n"
   10025             :                 ""},
   10026             :          { (char *)"delete_KDBException", (PyCFunction)_wrap_delete_KDBException, METH_O, (char *)"\n"
   10027             :                 "delete_KDBException(KDBException self)\n"
   10028             :                 "\n"
   10029             :                 "Parameters\n"
   10030             :                 "----------\n"
   10031             :                 "self: kdb::KDBException *\n"
   10032             :                 "\n"
   10033             :                 ""},
   10034             :          { (char *)"KDBException_whatWithArguments", _wrap_KDBException_whatWithArguments, METH_VARARGS, (char *)"\n"
   10035             :                 "KDBException_whatWithArguments(KDBException self, bool printVerbose, bool printDebug) -> char const *\n"
   10036             :                 "\n"
   10037             :                 "Parameters\n"
   10038             :                 "----------\n"
   10039             :                 "self: kdb::KDBException const *\n"
   10040             :                 "printVerbose: bool\n"
   10041             :                 "printDebug: bool\n"
   10042             :                 "\n"
   10043             :                 ""},
   10044             :          { (char *)"KDBException_swigregister", KDBException_swigregister, METH_VARARGS, NULL},
   10045             :          { (char *)"KDBException_swiginit", KDBException_swiginit, METH_VARARGS, NULL},
   10046             :          { (char *)"new_ContractException", (PyCFunction)_wrap_new_ContractException, METH_O, (char *)"\n"
   10047             :                 "new_ContractException(Key key) -> ContractException\n"
   10048             :                 "\n"
   10049             :                 "Parameters\n"
   10050             :                 "----------\n"
   10051             :                 "key: Key\n"
   10052             :                 "\n"
   10053             :                 ""},
   10054             :          { (char *)"delete_ContractException", (PyCFunction)_wrap_delete_ContractException, METH_O, (char *)"\n"
   10055             :                 "delete_ContractException(ContractException self)\n"
   10056             :                 "\n"
   10057             :                 "Parameters\n"
   10058             :                 "----------\n"
   10059             :                 "self: kdb::ContractException *\n"
   10060             :                 "\n"
   10061             :                 ""},
   10062             :          { (char *)"ContractException_swigregister", ContractException_swigregister, METH_VARARGS, NULL},
   10063             :          { (char *)"ContractException_swiginit", ContractException_swiginit, METH_VARARGS, NULL},
   10064             :          { (char *)"Key__incRef", (PyCFunction)_wrap_Key__incRef, METH_O, (char *)"\n"
   10065             :                 "Key__incRef(Key self)\n"
   10066             :                 "\n"
   10067             :                 "Parameters\n"
   10068             :                 "----------\n"
   10069             :                 "self: kdb::Key const *\n"
   10070             :                 "\n"
   10071             :                 ""},
   10072             :          { (char *)"Key__decRef", (PyCFunction)_wrap_Key__decRef, METH_O, (char *)"\n"
   10073             :                 "Key__decRef(Key self)\n"
   10074             :                 "\n"
   10075             :                 "Parameters\n"
   10076             :                 "----------\n"
   10077             :                 "self: kdb::Key const *\n"
   10078             :                 "\n"
   10079             :                 ""},
   10080             :          { (char *)"Key_getReferenceCounter", (PyCFunction)_wrap_Key_getReferenceCounter, METH_O, (char *)"\n"
   10081             :                 "Key_getReferenceCounter(Key self) -> ssize_t\n"
   10082             :                 "\n"
   10083             :                 "Parameters\n"
   10084             :                 "----------\n"
   10085             :                 "self: kdb::Key const *\n"
   10086             :                 "\n"
   10087             :                 ""},
   10088             :          { (char *)"Key_copy", _wrap_Key_copy, METH_VARARGS, (char *)"\n"
   10089             :                 "Key_copy(Key self, Key other)\n"
   10090             :                 "\n"
   10091             :                 "Parameters\n"
   10092             :                 "----------\n"
   10093             :                 "self: kdb::Key *\n"
   10094             :                 "other: kdb::Key const &\n"
   10095             :                 "\n"
   10096             :                 ""},
   10097             :          { (char *)"Key_clear", (PyCFunction)_wrap_Key_clear, METH_O, (char *)"\n"
   10098             :                 "Key_clear(Key self)\n"
   10099             :                 "\n"
   10100             :                 "Parameters\n"
   10101             :                 "----------\n"
   10102             :                 "self: kdb::Key *\n"
   10103             :                 "\n"
   10104             :                 ""},
   10105             :          { (char *)"Key_getKey", (PyCFunction)_wrap_Key_getKey, METH_O, (char *)"\n"
   10106             :                 "Key_getKey(Key self) -> ckdb::Key *\n"
   10107             :                 "\n"
   10108             :                 "Parameters\n"
   10109             :                 "----------\n"
   10110             :                 "self: kdb::Key const *\n"
   10111             :                 "\n"
   10112             :                 ""},
   10113             :          { (char *)"Key___ref__", (PyCFunction)_wrap_Key___ref__, METH_O, (char *)"\n"
   10114             :                 "Key___ref__(Key self) -> ckdb::Key *\n"
   10115             :                 "\n"
   10116             :                 "Parameters\n"
   10117             :                 "----------\n"
   10118             :                 "self: kdb::Key const *\n"
   10119             :                 "\n"
   10120             :                 ""},
   10121             :          { (char *)"Key_release", (PyCFunction)_wrap_Key_release, METH_O, (char *)"\n"
   10122             :                 "Key_release(Key self) -> ckdb::Key *\n"
   10123             :                 "\n"
   10124             :                 "Parameters\n"
   10125             :                 "----------\n"
   10126             :                 "self: kdb::Key *\n"
   10127             :                 "\n"
   10128             :                 ""},
   10129             :          { (char *)"Key_dup", (PyCFunction)_wrap_Key_dup, METH_O, (char *)"\n"
   10130             :                 "Key_dup(Key self) -> ckdb::Key *\n"
   10131             :                 "\n"
   10132             :                 "Parameters\n"
   10133             :                 "----------\n"
   10134             :                 "self: kdb::Key const *\n"
   10135             :                 "\n"
   10136             :                 ""},
   10137             :          { (char *)"delete_Key", (PyCFunction)_wrap_delete_Key, METH_O, (char *)"\n"
   10138             :                 "delete_Key(Key self)\n"
   10139             :                 "\n"
   10140             :                 "Parameters\n"
   10141             :                 "----------\n"
   10142             :                 "self: kdb::Key *\n"
   10143             :                 "\n"
   10144             :                 ""},
   10145             :          { (char *)"Key__getName", (PyCFunction)_wrap_Key__getName, METH_O, (char *)"\n"
   10146             :                 "Key__getName(Key self) -> std::string\n"
   10147             :                 "\n"
   10148             :                 "Parameters\n"
   10149             :                 "----------\n"
   10150             :                 "self: kdb::Key const *\n"
   10151             :                 "\n"
   10152             :                 ""},
   10153             :          { (char *)"Key__getNameSize", (PyCFunction)_wrap_Key__getNameSize, METH_O, (char *)"\n"
   10154             :                 "Key__getNameSize(Key self) -> ssize_t\n"
   10155             :                 "\n"
   10156             :                 "Parameters\n"
   10157             :                 "----------\n"
   10158             :                 "self: kdb::Key const *\n"
   10159             :                 "\n"
   10160             :                 ""},
   10161             :          { (char *)"Key__getBaseName", (PyCFunction)_wrap_Key__getBaseName, METH_O, (char *)"\n"
   10162             :                 "Key__getBaseName(Key self) -> std::string\n"
   10163             :                 "\n"
   10164             :                 "Parameters\n"
   10165             :                 "----------\n"
   10166             :                 "self: kdb::Key const *\n"
   10167             :                 "\n"
   10168             :                 ""},
   10169             :          { (char *)"Key__getBaseNameSize", (PyCFunction)_wrap_Key__getBaseNameSize, METH_O, (char *)"\n"
   10170             :                 "Key__getBaseNameSize(Key self) -> ssize_t\n"
   10171             :                 "\n"
   10172             :                 "Parameters\n"
   10173             :                 "----------\n"
   10174             :                 "self: kdb::Key const *\n"
   10175             :                 "\n"
   10176             :                 ""},
   10177             :          { (char *)"Key__setName", _wrap_Key__setName, METH_VARARGS, (char *)"\n"
   10178             :                 "Key__setName(Key self, std::string const & newName)\n"
   10179             :                 "\n"
   10180             :                 "Parameters\n"
   10181             :                 "----------\n"
   10182             :                 "self: kdb::Key *\n"
   10183             :                 "newName: std::string const &\n"
   10184             :                 "\n"
   10185             :                 ""},
   10186             :          { (char *)"Key_addName", _wrap_Key_addName, METH_VARARGS, (char *)"\n"
   10187             :                 "Key_addName(Key self, std::string const & addedName)\n"
   10188             :                 "\n"
   10189             :                 "Parameters\n"
   10190             :                 "----------\n"
   10191             :                 "self: kdb::Key *\n"
   10192             :                 "addedName: std::string const &\n"
   10193             :                 "\n"
   10194             :                 ""},
   10195             :          { (char *)"Key__setBaseName", _wrap_Key__setBaseName, METH_VARARGS, (char *)"\n"
   10196             :                 "Key__setBaseName(Key self, std::string const & baseName)\n"
   10197             :                 "\n"
   10198             :                 "Parameters\n"
   10199             :                 "----------\n"
   10200             :                 "self: kdb::Key *\n"
   10201             :                 "baseName: std::string const &\n"
   10202             :                 "\n"
   10203             :                 ""},
   10204             :          { (char *)"Key_addBaseName", _wrap_Key_addBaseName, METH_VARARGS, (char *)"\n"
   10205             :                 "Key_addBaseName(Key self, std::string const & baseName)\n"
   10206             :                 "\n"
   10207             :                 "Parameters\n"
   10208             :                 "----------\n"
   10209             :                 "self: kdb::Key *\n"
   10210             :                 "baseName: std::string const &\n"
   10211             :                 "\n"
   10212             :                 ""},
   10213             :          { (char *)"Key_delBaseName", (PyCFunction)_wrap_Key_delBaseName, METH_O, (char *)"\n"
   10214             :                 "Key_delBaseName(Key self)\n"
   10215             :                 "\n"
   10216             :                 "Parameters\n"
   10217             :                 "----------\n"
   10218             :                 "self: kdb::Key *\n"
   10219             :                 "\n"
   10220             :                 ""},
   10221             :          { (char *)"Key__getFullNameSize", (PyCFunction)_wrap_Key__getFullNameSize, METH_O, (char *)"\n"
   10222             :                 "Key__getFullNameSize(Key self) -> ssize_t\n"
   10223             :                 "\n"
   10224             :                 "Parameters\n"
   10225             :                 "----------\n"
   10226             :                 "self: kdb::Key const *\n"
   10227             :                 "\n"
   10228             :                 ""},
   10229             :          { (char *)"Key__getFullName", (PyCFunction)_wrap_Key__getFullName, METH_O, (char *)"\n"
   10230             :                 "Key__getFullName(Key self) -> std::string\n"
   10231             :                 "\n"
   10232             :                 "Parameters\n"
   10233             :                 "----------\n"
   10234             :                 "self: kdb::Key const *\n"
   10235             :                 "\n"
   10236             :                 ""},
   10237             :          { (char *)"Key___eq__", _wrap_Key___eq__, METH_VARARGS, (char *)"\n"
   10238             :                 "Key___eq__(Key self, Key k) -> bool\n"
   10239             :                 "\n"
   10240             :                 "Parameters\n"
   10241             :                 "----------\n"
   10242             :                 "self: kdb::Key const *\n"
   10243             :                 "k: kdb::Key const &\n"
   10244             :                 "\n"
   10245             :                 ""},
   10246             :          { (char *)"Key___ne__", _wrap_Key___ne__, METH_VARARGS, (char *)"\n"
   10247             :                 "Key___ne__(Key self, Key k) -> bool\n"
   10248             :                 "\n"
   10249             :                 "Parameters\n"
   10250             :                 "----------\n"
   10251             :                 "self: kdb::Key const *\n"
   10252             :                 "k: kdb::Key const &\n"
   10253             :                 "\n"
   10254             :                 ""},
   10255             :          { (char *)"Key___lt__", _wrap_Key___lt__, METH_VARARGS, (char *)"\n"
   10256             :                 "Key___lt__(Key self, Key other) -> bool\n"
   10257             :                 "\n"
   10258             :                 "Parameters\n"
   10259             :                 "----------\n"
   10260             :                 "self: kdb::Key const *\n"
   10261             :                 "other: kdb::Key const &\n"
   10262             :                 "\n"
   10263             :                 ""},
   10264             :          { (char *)"Key___le__", _wrap_Key___le__, METH_VARARGS, (char *)"\n"
   10265             :                 "Key___le__(Key self, Key other) -> bool\n"
   10266             :                 "\n"
   10267             :                 "Parameters\n"
   10268             :                 "----------\n"
   10269             :                 "self: kdb::Key const *\n"
   10270             :                 "other: kdb::Key const &\n"
   10271             :                 "\n"
   10272             :                 ""},
   10273             :          { (char *)"Key___gt__", _wrap_Key___gt__, METH_VARARGS, (char *)"\n"
   10274             :                 "Key___gt__(Key self, Key other) -> bool\n"
   10275             :                 "\n"
   10276             :                 "Parameters\n"
   10277             :                 "----------\n"
   10278             :                 "self: kdb::Key const *\n"
   10279             :                 "other: kdb::Key const &\n"
   10280             :                 "\n"
   10281             :                 ""},
   10282             :          { (char *)"Key___ge__", _wrap_Key___ge__, METH_VARARGS, (char *)"\n"
   10283             :                 "Key___ge__(Key self, Key other) -> bool\n"
   10284             :                 "\n"
   10285             :                 "Parameters\n"
   10286             :                 "----------\n"
   10287             :                 "self: kdb::Key const *\n"
   10288             :                 "other: kdb::Key const &\n"
   10289             :                 "\n"
   10290             :                 ""},
   10291             :          { (char *)"Key_isNull", (PyCFunction)_wrap_Key_isNull, METH_O, (char *)"\n"
   10292             :                 "Key_isNull(Key self) -> bool\n"
   10293             :                 "\n"
   10294             :                 "Parameters\n"
   10295             :                 "----------\n"
   10296             :                 "self: kdb::Key const *\n"
   10297             :                 "\n"
   10298             :                 ""},
   10299             :          { (char *)"Key___nonzero__", (PyCFunction)_wrap_Key___nonzero__, METH_O, (char *)"\n"
   10300             :                 "Key___nonzero__(Key self) -> bool\n"
   10301             :                 "\n"
   10302             :                 "Parameters\n"
   10303             :                 "----------\n"
   10304             :                 "self: kdb::Key const *\n"
   10305             :                 "\n"
   10306             :                 ""},
   10307             :          { (char *)"Key_needSync", (PyCFunction)_wrap_Key_needSync, METH_O, (char *)"\n"
   10308             :                 "Key_needSync(Key self) -> bool\n"
   10309             :                 "\n"
   10310             :                 "Parameters\n"
   10311             :                 "----------\n"
   10312             :                 "self: kdb::Key const *\n"
   10313             :                 "\n"
   10314             :                 ""},
   10315             :          { (char *)"Key__getString", (PyCFunction)_wrap_Key__getString, METH_O, (char *)"\n"
   10316             :                 "Key__getString(Key self) -> std::string\n"
   10317             :                 "\n"
   10318             :                 "Parameters\n"
   10319             :                 "----------\n"
   10320             :                 "self: kdb::Key const *\n"
   10321             :                 "\n"
   10322             :                 ""},
   10323             :          { (char *)"Key__setString", _wrap_Key__setString, METH_VARARGS, (char *)"\n"
   10324             :                 "Key__setString(Key self, std::string newString)\n"
   10325             :                 "\n"
   10326             :                 "Parameters\n"
   10327             :                 "----------\n"
   10328             :                 "self: kdb::Key *\n"
   10329             :                 "newString: std::string\n"
   10330             :                 "\n"
   10331             :                 ""},
   10332             :          { (char *)"Key__getStringSize", (PyCFunction)_wrap_Key__getStringSize, METH_O, (char *)"\n"
   10333             :                 "Key__getStringSize(Key self) -> ssize_t\n"
   10334             :                 "\n"
   10335             :                 "Parameters\n"
   10336             :                 "----------\n"
   10337             :                 "self: kdb::Key const *\n"
   10338             :                 "\n"
   10339             :                 ""},
   10340             :          { (char *)"Key__getFunc", (PyCFunction)_wrap_Key__getFunc, METH_O, (char *)"\n"
   10341             :                 "Key__getFunc(Key self) -> kdb::Key::func_t\n"
   10342             :                 "\n"
   10343             :                 "Parameters\n"
   10344             :                 "----------\n"
   10345             :                 "self: kdb::Key const *\n"
   10346             :                 "\n"
   10347             :                 ""},
   10348             :          { (char *)"Key_setCallback", _wrap_Key_setCallback, METH_VARARGS, (char *)"\n"
   10349             :                 "Key_setCallback(Key self, kdb::Key::callback_t fct)\n"
   10350             :                 "\n"
   10351             :                 "Parameters\n"
   10352             :                 "----------\n"
   10353             :                 "self: kdb::Key *\n"
   10354             :                 "fct: kdb::Key::callback_t\n"
   10355             :                 "\n"
   10356             :                 ""},
   10357             :          { (char *)"Key__getValue", (PyCFunction)_wrap_Key__getValue, METH_O, (char *)"\n"
   10358             :                 "Key__getValue(Key self) -> void const *\n"
   10359             :                 "\n"
   10360             :                 "Parameters\n"
   10361             :                 "----------\n"
   10362             :                 "self: kdb::Key const *\n"
   10363             :                 "\n"
   10364             :                 ""},
   10365             :          { (char *)"Key__getBinary", (PyCFunction)_wrap_Key__getBinary, METH_O, (char *)"\n"
   10366             :                 "Key__getBinary(Key self) -> std::string\n"
   10367             :                 "\n"
   10368             :                 "Parameters\n"
   10369             :                 "----------\n"
   10370             :                 "self: kdb::Key const *\n"
   10371             :                 "\n"
   10372             :                 ""},
   10373             :          { (char *)"Key__getBinarySize", (PyCFunction)_wrap_Key__getBinarySize, METH_O, (char *)"\n"
   10374             :                 "Key__getBinarySize(Key self) -> ssize_t\n"
   10375             :                 "\n"
   10376             :                 "Parameters\n"
   10377             :                 "----------\n"
   10378             :                 "self: kdb::Key const *\n"
   10379             :                 "\n"
   10380             :                 ""},
   10381             :          { (char *)"Key__setBinary", _wrap_Key__setBinary, METH_VARARGS, (char *)"\n"
   10382             :                 "Key__setBinary(Key self, void const * newBinary) -> ssize_t\n"
   10383             :                 "\n"
   10384             :                 "Parameters\n"
   10385             :                 "----------\n"
   10386             :                 "self: kdb::Key *\n"
   10387             :                 "newBinary: void const *\n"
   10388             :                 "\n"
   10389             :                 ""},
   10390             :          { (char *)"Key_hasMeta", _wrap_Key_hasMeta, METH_VARARGS, (char *)"\n"
   10391             :                 "Key_hasMeta(Key self, std::string const & metaName) -> bool\n"
   10392             :                 "\n"
   10393             :                 "Parameters\n"
   10394             :                 "----------\n"
   10395             :                 "self: kdb::Key const *\n"
   10396             :                 "metaName: std::string const &\n"
   10397             :                 "\n"
   10398             :                 ""},
   10399             :          { (char *)"Key_delMeta", _wrap_Key_delMeta, METH_VARARGS, (char *)"\n"
   10400             :                 "Key_delMeta(Key self, std::string const & metaName)\n"
   10401             :                 "\n"
   10402             :                 "Parameters\n"
   10403             :                 "----------\n"
   10404             :                 "self: kdb::Key *\n"
   10405             :                 "metaName: std::string const &\n"
   10406             :                 "\n"
   10407             :                 ""},
   10408             :          { (char *)"Key_copyMeta", _wrap_Key_copyMeta, METH_VARARGS, (char *)"\n"
   10409             :                 "Key_copyMeta(Key self, Key other, std::string const & metaName)\n"
   10410             :                 "\n"
   10411             :                 "Parameters\n"
   10412             :                 "----------\n"
   10413             :                 "self: kdb::Key *\n"
   10414             :                 "other: kdb::Key const &\n"
   10415             :                 "metaName: std::string const &\n"
   10416             :                 "\n"
   10417             :                 ""},
   10418             :          { (char *)"Key_copyAllMeta", _wrap_Key_copyAllMeta, METH_VARARGS, (char *)"\n"
   10419             :                 "Key_copyAllMeta(Key self, Key other)\n"
   10420             :                 "\n"
   10421             :                 "Parameters\n"
   10422             :                 "----------\n"
   10423             :                 "self: kdb::Key *\n"
   10424             :                 "other: kdb::Key const &\n"
   10425             :                 "\n"
   10426             :                 ""},
   10427             :          { (char *)"Key__rewindMeta", (PyCFunction)_wrap_Key__rewindMeta, METH_O, (char *)"\n"
   10428             :                 "Key__rewindMeta(Key self)\n"
   10429             :                 "\n"
   10430             :                 "Parameters\n"
   10431             :                 "----------\n"
   10432             :                 "self: kdb::Key *\n"
   10433             :                 "\n"
   10434             :                 ""},
   10435             :          { (char *)"Key__nextMeta", (PyCFunction)_wrap_Key__nextMeta, METH_O, (char *)"\n"
   10436             :                 "Key__nextMeta(Key self) -> Key\n"
   10437             :                 "\n"
   10438             :                 "Parameters\n"
   10439             :                 "----------\n"
   10440             :                 "self: kdb::Key *\n"
   10441             :                 "\n"
   10442             :                 ""},
   10443             :          { (char *)"Key__currentMeta", (PyCFunction)_wrap_Key__currentMeta, METH_O, (char *)"\n"
   10444             :                 "Key__currentMeta(Key self) -> Key\n"
   10445             :                 "\n"
   10446             :                 "Parameters\n"
   10447             :                 "----------\n"
   10448             :                 "self: kdb::Key const *\n"
   10449             :                 "\n"
   10450             :                 ""},
   10451             :          { (char *)"Key_isValid", (PyCFunction)_wrap_Key_isValid, METH_O, (char *)"\n"
   10452             :                 "Key_isValid(Key self) -> bool\n"
   10453             :                 "\n"
   10454             :                 "Parameters\n"
   10455             :                 "----------\n"
   10456             :                 "self: kdb::Key const *\n"
   10457             :                 "\n"
   10458             :                 ""},
   10459             :          { (char *)"Key_getNamespace", (PyCFunction)_wrap_Key_getNamespace, METH_O, (char *)"\n"
   10460             :                 "Key_getNamespace(Key self) -> std::string\n"
   10461             :                 "\n"
   10462             :                 "Parameters\n"
   10463             :                 "----------\n"
   10464             :                 "self: kdb::Key const *\n"
   10465             :                 "\n"
   10466             :                 ""},
   10467             :          { (char *)"Key_isCascading", (PyCFunction)_wrap_Key_isCascading, METH_O, (char *)"\n"
   10468             :                 "Key_isCascading(Key self) -> bool\n"
   10469             :                 "\n"
   10470             :                 "Parameters\n"
   10471             :                 "----------\n"
   10472             :                 "self: kdb::Key const *\n"
   10473             :                 "\n"
   10474             :                 ""},
   10475             :          { (char *)"Key_isSpec", (PyCFunction)_wrap_Key_isSpec, METH_O, (char *)"\n"
   10476             :                 "Key_isSpec(Key self) -> bool\n"
   10477             :                 "\n"
   10478             :                 "Parameters\n"
   10479             :                 "----------\n"
   10480             :                 "self: kdb::Key const *\n"
   10481             :                 "\n"
   10482             :                 ""},
   10483             :          { (char *)"Key_isProc", (PyCFunction)_wrap_Key_isProc, METH_O, (char *)"\n"
   10484             :                 "Key_isProc(Key self) -> bool\n"
   10485             :                 "\n"
   10486             :                 "Parameters\n"
   10487             :                 "----------\n"
   10488             :                 "self: kdb::Key const *\n"
   10489             :                 "\n"
   10490             :                 ""},
   10491             :          { (char *)"Key_isDir", (PyCFunction)_wrap_Key_isDir, METH_O, (char *)"\n"
   10492             :                 "Key_isDir(Key self) -> bool\n"
   10493             :                 "\n"
   10494             :                 "Parameters\n"
   10495             :                 "----------\n"
   10496             :                 "self: kdb::Key const *\n"
   10497             :                 "\n"
   10498             :                 ""},
   10499             :          { (char *)"Key_isUser", (PyCFunction)_wrap_Key_isUser, METH_O, (char *)"\n"
   10500             :                 "Key_isUser(Key self) -> bool\n"
   10501             :                 "\n"
   10502             :                 "Parameters\n"
   10503             :                 "----------\n"
   10504             :                 "self: kdb::Key const *\n"
   10505             :                 "\n"
   10506             :                 ""},
   10507             :          { (char *)"Key_isSystem", (PyCFunction)_wrap_Key_isSystem, METH_O, (char *)"\n"
   10508             :                 "Key_isSystem(Key self) -> bool\n"
   10509             :                 "\n"
   10510             :                 "Parameters\n"
   10511             :                 "----------\n"
   10512             :                 "self: kdb::Key const *\n"
   10513             :                 "\n"
   10514             :                 ""},
   10515             :          { (char *)"Key_isString", (PyCFunction)_wrap_Key_isString, METH_O, (char *)"\n"
   10516             :                 "Key_isString(Key self) -> bool\n"
   10517             :                 "\n"
   10518             :                 "Parameters\n"
   10519             :                 "----------\n"
   10520             :                 "self: kdb::Key const *\n"
   10521             :                 "\n"
   10522             :                 ""},
   10523             :          { (char *)"Key_isBinary", (PyCFunction)_wrap_Key_isBinary, METH_O, (char *)"\n"
   10524             :                 "Key_isBinary(Key self) -> bool\n"
   10525             :                 "\n"
   10526             :                 "Parameters\n"
   10527             :                 "----------\n"
   10528             :                 "self: kdb::Key const *\n"
   10529             :                 "\n"
   10530             :                 ""},
   10531             :          { (char *)"Key_isInactive", (PyCFunction)_wrap_Key_isInactive, METH_O, (char *)"\n"
   10532             :                 "Key_isInactive(Key self) -> bool\n"
   10533             :                 "\n"
   10534             :                 "Parameters\n"
   10535             :                 "----------\n"
   10536             :                 "self: kdb::Key const *\n"
   10537             :                 "\n"
   10538             :                 ""},
   10539             :          { (char *)"Key_isBelow", _wrap_Key_isBelow, METH_VARARGS, (char *)"\n"
   10540             :                 "Key_isBelow(Key self, Key k) -> bool\n"
   10541             :                 "\n"
   10542             :                 "Parameters\n"
   10543             :                 "----------\n"
   10544             :                 "self: kdb::Key const *\n"
   10545             :                 "k: kdb::Key const &\n"
   10546             :                 "\n"
   10547             :                 ""},
   10548             :          { (char *)"Key_isBelowOrSame", _wrap_Key_isBelowOrSame, METH_VARARGS, (char *)"\n"
   10549             :                 "Key_isBelowOrSame(Key self, Key k) -> bool\n"
   10550             :                 "\n"
   10551             :                 "Parameters\n"
   10552             :                 "----------\n"
   10553             :                 "self: kdb::Key const *\n"
   10554             :                 "k: kdb::Key const &\n"
   10555             :                 "\n"
   10556             :                 ""},
   10557             :          { (char *)"Key_isDirectBelow", _wrap_Key_isDirectBelow, METH_VARARGS, (char *)"\n"
   10558             :                 "Key_isDirectBelow(Key self, Key k) -> bool\n"
   10559             :                 "\n"
   10560             :                 "Parameters\n"
   10561             :                 "----------\n"
   10562             :                 "self: kdb::Key const *\n"
   10563             :                 "k: kdb::Key const &\n"
   10564             :                 "\n"
   10565             :                 ""},
   10566             :          { (char *)"new_Key", _wrap_new_Key, METH_VARARGS, (char *)"\n"
   10567             :                 "Key()\n"
   10568             :                 "Key(ckdb::Key * k)\n"
   10569             :                 "\n"
   10570             :                 "Parameters\n"
   10571             :                 "----------\n"
   10572             :                 "k: ckdb::Key *\n"
   10573             :                 "\n"
   10574             :                 "Key(Key k)\n"
   10575             :                 "\n"
   10576             :                 "Parameters\n"
   10577             :                 "----------\n"
   10578             :                 "k: kdb::Key &\n"
   10579             :                 "\n"
   10580             :                 "Key(char const * name, int flags=0)\n"
   10581             :                 "\n"
   10582             :                 "Parameters\n"
   10583             :                 "----------\n"
   10584             :                 "name: char const *\n"
   10585             :                 "flags: int\n"
   10586             :                 "\n"
   10587             :                 "new_Key(char const * name) -> Key\n"
   10588             :                 "\n"
   10589             :                 "Parameters\n"
   10590             :                 "----------\n"
   10591             :                 "name: char const *\n"
   10592             :                 "\n"
   10593             :                 ""},
   10594             :          { (char *)"Key___cmp__", _wrap_Key___cmp__, METH_VARARGS, (char *)"\n"
   10595             :                 "Key___cmp__(Key self, Key o) -> int\n"
   10596             :                 "\n"
   10597             :                 "Parameters\n"
   10598             :                 "----------\n"
   10599             :                 "self: kdb::Key *\n"
   10600             :                 "o: kdb::Key const *\n"
   10601             :                 "\n"
   10602             :                 ""},
   10603             :          { (char *)"Key___copy__", (PyCFunction)_wrap_Key___copy__, METH_O, (char *)"\n"
   10604             :                 "Key___copy__(Key self) -> Key\n"
   10605             :                 "\n"
   10606             :                 "Parameters\n"
   10607             :                 "----------\n"
   10608             :                 "self: kdb::Key *\n"
   10609             :                 "\n"
   10610             :                 ""},
   10611             :          { (char *)"Key___iter__", (PyCFunction)_wrap_Key___iter__, METH_O, (char *)"\n"
   10612             :                 "Key___iter__(Key self) -> SwigPyIterator\n"
   10613             :                 "\n"
   10614             :                 "Parameters\n"
   10615             :                 "----------\n"
   10616             :                 "self: kdb::Key *\n"
   10617             :                 "\n"
   10618             :                 ""},
   10619             :          { (char *)"Key___reversed__", (PyCFunction)_wrap_Key___reversed__, METH_O, (char *)"\n"
   10620             :                 "Key___reversed__(Key self) -> SwigPyIterator\n"
   10621             :                 "\n"
   10622             :                 "Parameters\n"
   10623             :                 "----------\n"
   10624             :                 "self: kdb::Key *\n"
   10625             :                 "\n"
   10626             :                 ""},
   10627             :          { (char *)"Key__getMeta", _wrap_Key__getMeta, METH_VARARGS, (char *)"\n"
   10628             :                 "Key__getMeta(Key self, std::string const & metaName) -> Key\n"
   10629             :                 "\n"
   10630             :                 "Parameters\n"
   10631             :                 "----------\n"
   10632             :                 "self: kdb::Key const *\n"
   10633             :                 "metaName: std::string const &\n"
   10634             :                 "\n"
   10635             :                 ""},
   10636             :          { (char *)"Key__setMeta", _wrap_Key__setMeta, METH_VARARGS, (char *)"\n"
   10637             :                 "Key__setMeta(Key self, std::string const & metaName, std::string x)\n"
   10638             :                 "\n"
   10639             :                 "Parameters\n"
   10640             :                 "----------\n"
   10641             :                 "self: kdb::Key *\n"
   10642             :                 "metaName: std::string const &\n"
   10643             :                 "x: std::string\n"
   10644             :                 "\n"
   10645             :                 ""},
   10646             :          { (char *)"Key_swigregister", Key_swigregister, METH_VARARGS, NULL},
   10647             :          { (char *)"Key_swiginit", Key_swiginit, METH_VARARGS, NULL},
   10648             :          { (char *)"delete_KeySet", (PyCFunction)_wrap_delete_KeySet, METH_O, (char *)"\n"
   10649             :                 "delete_KeySet(KeySet self)\n"
   10650             :                 "\n"
   10651             :                 "Parameters\n"
   10652             :                 "----------\n"
   10653             :                 "self: kdb::KeySet *\n"
   10654             :                 "\n"
   10655             :                 ""},
   10656             :          { (char *)"KeySet_release", (PyCFunction)_wrap_KeySet_release, METH_O, (char *)"\n"
   10657             :                 "KeySet_release(KeySet self) -> ckdb::KeySet *\n"
   10658             :                 "\n"
   10659             :                 "Parameters\n"
   10660             :                 "----------\n"
   10661             :                 "self: kdb::KeySet *\n"
   10662             :                 "\n"
   10663             :                 ""},
   10664             :          { (char *)"KeySet_getKeySet", (PyCFunction)_wrap_KeySet_getKeySet, METH_O, (char *)"\n"
   10665             :                 "KeySet_getKeySet(KeySet self) -> ckdb::KeySet *\n"
   10666             :                 "\n"
   10667             :                 "Parameters\n"
   10668             :                 "----------\n"
   10669             :                 "self: kdb::KeySet const *\n"
   10670             :                 "\n"
   10671             :                 ""},
   10672             :          { (char *)"KeySet_setKeySet", _wrap_KeySet_setKeySet, METH_VARARGS, (char *)"\n"
   10673             :                 "KeySet_setKeySet(KeySet self, ckdb::KeySet * k)\n"
   10674             :                 "\n"
   10675             :                 "Parameters\n"
   10676             :                 "----------\n"
   10677             :                 "self: kdb::KeySet *\n"
   10678             :                 "k: ckdb::KeySet *\n"
   10679             :                 "\n"
   10680             :                 ""},
   10681             :          { (char *)"KeySet___len__", (PyCFunction)_wrap_KeySet___len__, METH_O, (char *)"\n"
   10682             :                 "KeySet___len__(KeySet self) -> ssize_t\n"
   10683             :                 "\n"
   10684             :                 "Parameters\n"
   10685             :                 "----------\n"
   10686             :                 "self: kdb::KeySet const *\n"
   10687             :                 "\n"
   10688             :                 ""},
   10689             :          { (char *)"KeySet_dup", (PyCFunction)_wrap_KeySet_dup, METH_O, (char *)"\n"
   10690             :                 "KeySet_dup(KeySet self) -> ckdb::KeySet *\n"
   10691             :                 "\n"
   10692             :                 "Parameters\n"
   10693             :                 "----------\n"
   10694             :                 "self: kdb::KeySet const *\n"
   10695             :                 "\n"
   10696             :                 ""},
   10697             :          { (char *)"KeySet_copy", _wrap_KeySet_copy, METH_VARARGS, (char *)"\n"
   10698             :                 "KeySet_copy(KeySet self, KeySet other)\n"
   10699             :                 "\n"
   10700             :                 "Parameters\n"
   10701             :                 "----------\n"
   10702             :                 "self: kdb::KeySet *\n"
   10703             :                 "other: kdb::KeySet const &\n"
   10704             :                 "\n"
   10705             :                 ""},
   10706             :          { (char *)"KeySet_clear", (PyCFunction)_wrap_KeySet_clear, METH_O, (char *)"\n"
   10707             :                 "KeySet_clear(KeySet self)\n"
   10708             :                 "\n"
   10709             :                 "Parameters\n"
   10710             :                 "----------\n"
   10711             :                 "self: kdb::KeySet *\n"
   10712             :                 "\n"
   10713             :                 ""},
   10714             :          { (char *)"KeySet_append", _wrap_KeySet_append, METH_VARARGS, (char *)"\n"
   10715             :                 "append(Key toAppend) -> ssize_t\n"
   10716             :                 "\n"
   10717             :                 "Parameters\n"
   10718             :                 "----------\n"
   10719             :                 "toAppend: kdb::Key const &\n"
   10720             :                 "\n"
   10721             :                 "KeySet_append(KeySet self, KeySet toAppend) -> ssize_t\n"
   10722             :                 "\n"
   10723             :                 "Parameters\n"
   10724             :                 "----------\n"
   10725             :                 "self: kdb::KeySet *\n"
   10726             :                 "toAppend: kdb::KeySet const &\n"
   10727             :                 "\n"
   10728             :                 ""},
   10729             :          { (char *)"KeySet_head", (PyCFunction)_wrap_KeySet_head, METH_O, (char *)"\n"
   10730             :                 "KeySet_head(KeySet self) -> Key\n"
   10731             :                 "\n"
   10732             :                 "Parameters\n"
   10733             :                 "----------\n"
   10734             :                 "self: kdb::KeySet const *\n"
   10735             :                 "\n"
   10736             :                 ""},
   10737             :          { (char *)"KeySet_tail", (PyCFunction)_wrap_KeySet_tail, METH_O, (char *)"\n"
   10738             :                 "KeySet_tail(KeySet self) -> Key\n"
   10739             :                 "\n"
   10740             :                 "Parameters\n"
   10741             :                 "----------\n"
   10742             :                 "self: kdb::KeySet const *\n"
   10743             :                 "\n"
   10744             :                 ""},
   10745             :          { (char *)"KeySet_setCursor", _wrap_KeySet_setCursor, METH_VARARGS, (char *)"\n"
   10746             :                 "KeySet_setCursor(KeySet self, cursor_t cursor)\n"
   10747             :                 "\n"
   10748             :                 "Parameters\n"
   10749             :                 "----------\n"
   10750             :                 "self: kdb::KeySet const *\n"
   10751             :                 "cursor: cursor_t\n"
   10752             :                 "\n"
   10753             :                 ""},
   10754             :          { (char *)"KeySet_getCursor", (PyCFunction)_wrap_KeySet_getCursor, METH_O, (char *)"\n"
   10755             :                 "KeySet_getCursor(KeySet self) -> cursor_t\n"
   10756             :                 "\n"
   10757             :                 "Parameters\n"
   10758             :                 "----------\n"
   10759             :                 "self: kdb::KeySet const *\n"
   10760             :                 "\n"
   10761             :                 ""},
   10762             :          { (char *)"KeySet_pop", (PyCFunction)_wrap_KeySet_pop, METH_O, (char *)"\n"
   10763             :                 "KeySet_pop(KeySet self) -> Key\n"
   10764             :                 "\n"
   10765             :                 "Parameters\n"
   10766             :                 "----------\n"
   10767             :                 "self: kdb::KeySet *\n"
   10768             :                 "\n"
   10769             :                 ""},
   10770             :          { (char *)"KeySet_cut", _wrap_KeySet_cut, METH_VARARGS, (char *)"\n"
   10771             :                 "KeySet_cut(KeySet self, Key k) -> KeySet\n"
   10772             :                 "\n"
   10773             :                 "Parameters\n"
   10774             :                 "----------\n"
   10775             :                 "self: kdb::KeySet *\n"
   10776             :                 "k: kdb::Key\n"
   10777             :                 "\n"
   10778             :                 ""},
   10779             :          { (char *)"KeySet__lookup", _wrap_KeySet__lookup, METH_VARARGS, (char *)"\n"
   10780             :                 "_lookup(cursor_t pos) -> Key\n"
   10781             :                 "\n"
   10782             :                 "Parameters\n"
   10783             :                 "----------\n"
   10784             :                 "pos: cursor_t\n"
   10785             :                 "\n"
   10786             :                 "_lookup(Key k, option_t const options=KDB_O_NONE) -> Key\n"
   10787             :                 "\n"
   10788             :                 "Parameters\n"
   10789             :                 "----------\n"
   10790             :                 "k: kdb::Key const &\n"
   10791             :                 "options: option_t const\n"
   10792             :                 "\n"
   10793             :                 "_lookup(Key k) -> Key\n"
   10794             :                 "\n"
   10795             :                 "Parameters\n"
   10796             :                 "----------\n"
   10797             :                 "k: kdb::Key const &\n"
   10798             :                 "\n"
   10799             :                 "_lookup(std::string const & name, option_t const options=KDB_O_NONE) -> Key\n"
   10800             :                 "\n"
   10801             :                 "Parameters\n"
   10802             :                 "----------\n"
   10803             :                 "name: std::string const &\n"
   10804             :                 "options: option_t const\n"
   10805             :                 "\n"
   10806             :                 "KeySet__lookup(KeySet self, std::string const & name) -> Key\n"
   10807             :                 "\n"
   10808             :                 "Parameters\n"
   10809             :                 "----------\n"
   10810             :                 "self: kdb::KeySet const *\n"
   10811             :                 "name: std::string const &\n"
   10812             :                 "\n"
   10813             :                 ""},
   10814             :          { (char *)"new_KeySet", _wrap_new_KeySet, METH_VARARGS, (char *)"\n"
   10815             :                 "KeySet()\n"
   10816             :                 "KeySet(ckdb::KeySet * k)\n"
   10817             :                 "\n"
   10818             :                 "Parameters\n"
   10819             :                 "----------\n"
   10820             :                 "k: ckdb::KeySet *\n"
   10821             :                 "\n"
   10822             :                 "KeySet(KeySet other)\n"
   10823             :                 "\n"
   10824             :                 "Parameters\n"
   10825             :                 "----------\n"
   10826             :                 "other: kdb::KeySet const &\n"
   10827             :                 "\n"
   10828             :                 "new_KeySet(size_t alloc) -> KeySet\n"
   10829             :                 "\n"
   10830             :                 "Parameters\n"
   10831             :                 "----------\n"
   10832             :                 "alloc: size_t\n"
   10833             :                 "\n"
   10834             :                 ""},
   10835             :          { (char *)"KeySet___copy__", (PyCFunction)_wrap_KeySet___copy__, METH_O, (char *)"\n"
   10836             :                 "KeySet___copy__(KeySet self) -> KeySet\n"
   10837             :                 "\n"
   10838             :                 "Parameters\n"
   10839             :                 "----------\n"
   10840             :                 "self: kdb::KeySet *\n"
   10841             :                 "\n"
   10842             :                 ""},
   10843             :          { (char *)"KeySet___deepcopy__", _wrap_KeySet___deepcopy__, METH_VARARGS, (char *)"\n"
   10844             :                 "KeySet___deepcopy__(KeySet self, PyObject * memo) -> KeySet\n"
   10845             :                 "\n"
   10846             :                 "Parameters\n"
   10847             :                 "----------\n"
   10848             :                 "self: kdb::KeySet *\n"
   10849             :                 "memo: PyObject *\n"
   10850             :                 "\n"
   10851             :                 ""},
   10852             :          { (char *)"KeySet___iter__", (PyCFunction)_wrap_KeySet___iter__, METH_O, (char *)"\n"
   10853             :                 "KeySet___iter__(KeySet self) -> SwigPyIterator\n"
   10854             :                 "\n"
   10855             :                 "Parameters\n"
   10856             :                 "----------\n"
   10857             :                 "self: kdb::KeySet *\n"
   10858             :                 "\n"
   10859             :                 ""},
   10860             :          { (char *)"KeySet___reversed__", (PyCFunction)_wrap_KeySet___reversed__, METH_O, (char *)"\n"
   10861             :                 "KeySet___reversed__(KeySet self) -> SwigPyIterator\n"
   10862             :                 "\n"
   10863             :                 "Parameters\n"
   10864             :                 "----------\n"
   10865             :                 "self: kdb::KeySet *\n"
   10866             :                 "\n"
   10867             :                 ""},
   10868             :          { (char *)"KeySet_swigregister", KeySet_swigregister, METH_VARARGS, NULL},
   10869             :          { (char *)"KeySet_swiginit", KeySet_swiginit, METH_VARARGS, NULL},
   10870             :          { (char *)"__eq__", _wrap___eq__, METH_VARARGS, (char *)"\n"
   10871             :                 "__eq__(KeySet lhs, KeySet rhs) -> bool\n"
   10872             :                 "\n"
   10873             :                 "Parameters\n"
   10874             :                 "----------\n"
   10875             :                 "lhs: kdb::KeySet const &\n"
   10876             :                 "rhs: kdb::KeySet const &\n"
   10877             :                 "\n"
   10878             :                 ""},
   10879             :          { (char *)"__ne__", _wrap___ne__, METH_VARARGS, (char *)"\n"
   10880             :                 "__ne__(KeySet lhs, KeySet rhs) -> bool\n"
   10881             :                 "\n"
   10882             :                 "Parameters\n"
   10883             :                 "----------\n"
   10884             :                 "lhs: kdb::KeySet const &\n"
   10885             :                 "rhs: kdb::KeySet const &\n"
   10886             :                 "\n"
   10887             :                 ""},
   10888             :          { (char *)"new_KDB", _wrap_new_KDB, METH_VARARGS, (char *)"\n"
   10889             :                 "KDB()\n"
   10890             :                 "new_KDB(Key errorKey) -> KDB\n"
   10891             :                 "\n"
   10892             :                 "Parameters\n"
   10893             :                 "----------\n"
   10894             :                 "errorKey: kdb::Key &\n"
   10895             :                 "\n"
   10896             :                 ""},
   10897             :          { (char *)"delete_KDB", (PyCFunction)_wrap_delete_KDB, METH_O, (char *)"\n"
   10898             :                 "delete_KDB(KDB self)\n"
   10899             :                 "\n"
   10900             :                 "Parameters\n"
   10901             :                 "----------\n"
   10902             :                 "self: kdb::KDB *\n"
   10903             :                 "\n"
   10904             :                 ""},
   10905             :          { (char *)"KDB_open", _wrap_KDB_open, METH_VARARGS, (char *)"\n"
   10906             :                 "KDB_open(KDB self, Key errorKey)\n"
   10907             :                 "\n"
   10908             :                 "Parameters\n"
   10909             :                 "----------\n"
   10910             :                 "self: kdb::KDB *\n"
   10911             :                 "errorKey: kdb::Key &\n"
   10912             :                 "\n"
   10913             :                 ""},
   10914             :          { (char *)"KDB_close", _wrap_KDB_close, METH_VARARGS, (char *)"\n"
   10915             :                 "close()\n"
   10916             :                 "KDB_close(KDB self, Key errorKey)\n"
   10917             :                 "\n"
   10918             :                 "Parameters\n"
   10919             :                 "----------\n"
   10920             :                 "self: kdb::KDB *\n"
   10921             :                 "errorKey: kdb::Key &\n"
   10922             :                 "\n"
   10923             :                 ""},
   10924             :          { (char *)"KDB_get", _wrap_KDB_get, METH_VARARGS, (char *)"\n"
   10925             :                 "get(KeySet returned, std::string const & keyname) -> int\n"
   10926             :                 "\n"
   10927             :                 "Parameters\n"
   10928             :                 "----------\n"
   10929             :                 "returned: kdb::KeySet &\n"
   10930             :                 "keyname: std::string const &\n"
   10931             :                 "\n"
   10932             :                 "KDB_get(KDB self, KeySet returned, Key parentKey) -> int\n"
   10933             :                 "\n"
   10934             :                 "Parameters\n"
   10935             :                 "----------\n"
   10936             :                 "self: kdb::KDB *\n"
   10937             :                 "returned: kdb::KeySet &\n"
   10938             :                 "parentKey: kdb::Key &\n"
   10939             :                 "\n"
   10940             :                 ""},
   10941             :          { (char *)"KDB_set", _wrap_KDB_set, METH_VARARGS, (char *)"\n"
   10942             :                 "set(KeySet returned, std::string const & keyname) -> int\n"
   10943             :                 "\n"
   10944             :                 "Parameters\n"
   10945             :                 "----------\n"
   10946             :                 "returned: kdb::KeySet &\n"
   10947             :                 "keyname: std::string const &\n"
   10948             :                 "\n"
   10949             :                 "KDB_set(KDB self, KeySet returned, Key parentKey) -> int\n"
   10950             :                 "\n"
   10951             :                 "Parameters\n"
   10952             :                 "----------\n"
   10953             :                 "self: kdb::KDB *\n"
   10954             :                 "returned: kdb::KeySet &\n"
   10955             :                 "parentKey: kdb::Key &\n"
   10956             :                 "\n"
   10957             :                 ""},
   10958             :          { (char *)"KDB_ensure", _wrap_KDB_ensure, METH_VARARGS, (char *)"\n"
   10959             :                 "KDB_ensure(KDB self, KeySet contract, Key parentKey) -> int\n"
   10960             :                 "\n"
   10961             :                 "Parameters\n"
   10962             :                 "----------\n"
   10963             :                 "self: kdb::KDB *\n"
   10964             :                 "contract: kdb::KeySet const &\n"
   10965             :                 "parentKey: kdb::Key &\n"
   10966             :                 "\n"
   10967             :                 ""},
   10968             :          { (char *)"KDB_swigregister", KDB_swigregister, METH_VARARGS, NULL},
   10969             :          { (char *)"KDB_swiginit", KDB_swiginit, METH_VARARGS, NULL},
   10970             :          { NULL, NULL, 0, NULL }
   10971             : };
   10972             : 
   10973             : 
   10974             : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
   10975             : 
   10976           0 : static void *_p_kdb__ExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   10977           0 :     return (void *)((std::exception *)  ((kdb::Exception *) x));
   10978             : }
   10979           0 : static void *_p_kdb__KeyExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   10980           0 :     return (void *)((std::exception *) (kdb::Exception *) ((kdb::KeyException *) x));
   10981             : }
   10982           0 : static void *_p_kdb__KeyNotFoundExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   10983           0 :     return (void *)((std::exception *) (kdb::Exception *) ((kdb::KeyNotFoundException *) x));
   10984             : }
   10985           0 : static void *_p_kdb__KeyTypeMismatchTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   10986           0 :     return (void *)((std::exception *) (kdb::Exception *)(kdb::KeyException *) ((kdb::KeyTypeMismatch *) x));
   10987             : }
   10988           0 : static void *_p_kdb__KDBExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   10989           0 :     return (void *)((std::exception *) (kdb::Exception *) ((kdb::KDBException *) x));
   10990             : }
   10991           0 : static void *_p_kdb__ContractExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   10992           0 :     return (void *)((std::exception *) (kdb::Exception *)(kdb::KDBException *) ((kdb::ContractException *) x));
   10993             : }
   10994           0 : static void *_p_kdb__KeyTypeConversionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   10995           0 :     return (void *)((std::exception *) (kdb::Exception *)(kdb::KeyException *) ((kdb::KeyTypeConversion *) x));
   10996             : }
   10997           0 : static void *_p_kdb__KeyInvalidNameTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   10998           0 :     return (void *)((std::exception *) (kdb::Exception *)(kdb::KeyException *) ((kdb::KeyInvalidName *) x));
   10999             : }
   11000           0 : static void *_p_kdb__KeyExceptionTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   11001           0 :     return (void *)((kdb::Exception *)  ((kdb::KeyException *) x));
   11002             : }
   11003           0 : static void *_p_kdb__KeyNotFoundExceptionTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   11004           0 :     return (void *)((kdb::Exception *)  ((kdb::KeyNotFoundException *) x));
   11005             : }
   11006           0 : static void *_p_kdb__KeyTypeMismatchTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   11007           0 :     return (void *)((kdb::Exception *) (kdb::KeyException *) ((kdb::KeyTypeMismatch *) x));
   11008             : }
   11009           0 : static void *_p_kdb__KDBExceptionTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   11010           0 :     return (void *)((kdb::Exception *)  ((kdb::KDBException *) x));
   11011             : }
   11012           0 : static void *_p_kdb__ContractExceptionTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   11013           0 :     return (void *)((kdb::Exception *) (kdb::KDBException *) ((kdb::ContractException *) x));
   11014             : }
   11015           0 : static void *_p_kdb__KeyTypeConversionTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   11016           0 :     return (void *)((kdb::Exception *) (kdb::KeyException *) ((kdb::KeyTypeConversion *) x));
   11017             : }
   11018           0 : static void *_p_kdb__KeyInvalidNameTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   11019           0 :     return (void *)((kdb::Exception *) (kdb::KeyException *) ((kdb::KeyInvalidName *) x));
   11020             : }
   11021           0 : static void *_p_kdb__KeyTypeMismatchTo_p_kdb__KeyException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   11022           0 :     return (void *)((kdb::KeyException *)  ((kdb::KeyTypeMismatch *) x));
   11023             : }
   11024           0 : static void *_p_kdb__KeyTypeConversionTo_p_kdb__KeyException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   11025           0 :     return (void *)((kdb::KeyException *)  ((kdb::KeyTypeConversion *) x));
   11026             : }
   11027           0 : static void *_p_kdb__KeyInvalidNameTo_p_kdb__KeyException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   11028           0 :     return (void *)((kdb::KeyException *)  ((kdb::KeyInvalidName *) x));
   11029             : }
   11030           0 : static void *_p_kdb__ContractExceptionTo_p_kdb__KDBException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   11031           0 :     return (void *)((kdb::KDBException *)  ((kdb::ContractException *) x));
   11032             : }
   11033             : static swig_type_info _swigt__p_Key = {"_p_Key", "Key *", 0, 0, (void*)0, 0};
   11034             : static swig_type_info _swigt__p__Key = {"_p__Key", "_Key *|ckdb::Key *", 0, 0, (void*)0, 0};
   11035             : static swig_type_info _swigt__p__KeySet = {"_p__KeySet", "_KeySet *|ckdb::KeySet *", 0, 0, (void*)0, 0};
   11036             : static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
   11037             : static swig_type_info _swigt__p_f___void = {"_p_f___void", "void (*)()|kdb::Key::func_t", 0, 0, (void*)0, 0};
   11038             : static swig_type_info _swigt__p_f_p__KeySet_p__Key_p__Key_option_t__p__Key = {"_p_f_p__KeySet_p__Key_p__Key_option_t__p__Key", "_Key *(*)(_KeySet *,_Key *,_Key *,option_t)|kdb::Key::callback_t", 0, 0, (void*)0, 0};
   11039             : static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0};
   11040             : static swig_type_info _swigt__p_kdb__ContractException = {"_p_kdb__ContractException", "kdb::ContractException *", 0, 0, (void*)0, 0};
   11041             : static swig_type_info _swigt__p_kdb__Exception = {"_p_kdb__Exception", "kdb::Exception *", 0, 0, (void*)0, 0};
   11042             : static swig_type_info _swigt__p_kdb__KDB = {"_p_kdb__KDB", "kdb::KDB *", 0, 0, (void*)0, 0};
   11043             : static swig_type_info _swigt__p_kdb__KDBException = {"_p_kdb__KDBException", "kdb::KDBException *", 0, 0, (void*)0, 0};
   11044             : static swig_type_info _swigt__p_kdb__Key = {"_p_kdb__Key", "kdb::Key *", 0, 0, (void*)0, 0};
   11045             : static swig_type_info _swigt__p_kdb__KeyException = {"_p_kdb__KeyException", "kdb::KeyException *", 0, 0, (void*)0, 0};
   11046             : static swig_type_info _swigt__p_kdb__KeyInvalidName = {"_p_kdb__KeyInvalidName", "kdb::KeyInvalidName *", 0, 0, (void*)0, 0};
   11047             : static swig_type_info _swigt__p_kdb__KeyNotFoundException = {"_p_kdb__KeyNotFoundException", "kdb::KeyNotFoundException *", 0, 0, (void*)0, 0};
   11048             : static swig_type_info _swigt__p_kdb__KeySet = {"_p_kdb__KeySet", "kdb::KeySet *", 0, 0, (void*)0, 0};
   11049             : static swig_type_info _swigt__p_kdb__KeyTypeConversion = {"_p_kdb__KeyTypeConversion", "kdb::KeyTypeConversion *", 0, 0, (void*)0, 0};
   11050             : static swig_type_info _swigt__p_kdb__KeyTypeMismatch = {"_p_kdb__KeyTypeMismatch", "kdb::KeyTypeMismatch *", 0, 0, (void*)0, 0};
   11051             : static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
   11052             : static swig_type_info _swigt__p_option_t = {"_p_option_t", "option_t *", 0, 0, (void*)0, 0};
   11053             : static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
   11054             : static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
   11055             : static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
   11056             : static swig_type_info _swigt__p_std__exception = {"_p_std__exception", "std::exception *", 0, 0, (void*)0, 0};
   11057             : static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
   11058             : static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
   11059             : static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
   11060             : static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
   11061             : static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
   11062             : static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
   11063             : static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
   11064             : 
   11065             : static swig_type_info *swig_type_initial[] = {
   11066             :   &_swigt__p_Key,
   11067             :   &_swigt__p__Key,
   11068             :   &_swigt__p__KeySet,
   11069             :   &_swigt__p_char,
   11070             :   &_swigt__p_f___void,
   11071             :   &_swigt__p_f_p__KeySet_p__Key_p__Key_option_t__p__Key,
   11072             :   &_swigt__p_int,
   11073             :   &_swigt__p_kdb__ContractException,
   11074             :   &_swigt__p_kdb__Exception,
   11075             :   &_swigt__p_kdb__KDB,
   11076             :   &_swigt__p_kdb__KDBException,
   11077             :   &_swigt__p_kdb__Key,
   11078             :   &_swigt__p_kdb__KeyException,
   11079             :   &_swigt__p_kdb__KeyInvalidName,
   11080             :   &_swigt__p_kdb__KeyNotFoundException,
   11081             :   &_swigt__p_kdb__KeySet,
   11082             :   &_swigt__p_kdb__KeyTypeConversion,
   11083             :   &_swigt__p_kdb__KeyTypeMismatch,
   11084             :   &_swigt__p_long_long,
   11085             :   &_swigt__p_option_t,
   11086             :   &_swigt__p_p_PyObject,
   11087             :   &_swigt__p_short,
   11088             :   &_swigt__p_signed_char,
   11089             :   &_swigt__p_std__exception,
   11090             :   &_swigt__p_std__invalid_argument,
   11091             :   &_swigt__p_swig__SwigPyIterator,
   11092             :   &_swigt__p_unsigned_char,
   11093             :   &_swigt__p_unsigned_int,
   11094             :   &_swigt__p_unsigned_long_long,
   11095             :   &_swigt__p_unsigned_short,
   11096             :   &_swigt__p_void,
   11097             : };
   11098             : 
   11099             : static swig_cast_info _swigc__p_Key[] = {  {&_swigt__p_Key, 0, 0, 0},{0, 0, 0, 0}};
   11100             : static swig_cast_info _swigc__p__Key[] = {  {&_swigt__p__Key, 0, 0, 0},{0, 0, 0, 0}};
   11101             : static swig_cast_info _swigc__p__KeySet[] = {  {&_swigt__p__KeySet, 0, 0, 0},{0, 0, 0, 0}};
   11102             : static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
   11103             : static swig_cast_info _swigc__p_f___void[] = {  {&_swigt__p_f___void, 0, 0, 0},{0, 0, 0, 0}};
   11104             : static swig_cast_info _swigc__p_f_p__KeySet_p__Key_p__Key_option_t__p__Key[] = {  {&_swigt__p_f_p__KeySet_p__Key_p__Key_option_t__p__Key, 0, 0, 0},{0, 0, 0, 0}};
   11105             : static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
   11106             : static swig_cast_info _swigc__p_kdb__ContractException[] = {  {&_swigt__p_kdb__ContractException, 0, 0, 0},{0, 0, 0, 0}};
   11107             : static swig_cast_info _swigc__p_kdb__Exception[] = {  {&_swigt__p_kdb__Exception, 0, 0, 0},  {&_swigt__p_kdb__KeyException, _p_kdb__KeyExceptionTo_p_kdb__Exception, 0, 0},  {&_swigt__p_kdb__KeyTypeMismatch, _p_kdb__KeyTypeMismatchTo_p_kdb__Exception, 0, 0},  {&_swigt__p_kdb__KeyNotFoundException, _p_kdb__KeyNotFoundExceptionTo_p_kdb__Exception, 0, 0},  {&_swigt__p_kdb__KDBException, _p_kdb__KDBExceptionTo_p_kdb__Exception, 0, 0},  {&_swigt__p_kdb__ContractException, _p_kdb__ContractExceptionTo_p_kdb__Exception, 0, 0},  {&_swigt__p_kdb__KeyTypeConversion, _p_kdb__KeyTypeConversionTo_p_kdb__Exception, 0, 0},  {&_swigt__p_kdb__KeyInvalidName, _p_kdb__KeyInvalidNameTo_p_kdb__Exception, 0, 0},{0, 0, 0, 0}};
   11108             : static swig_cast_info _swigc__p_kdb__KDB[] = {  {&_swigt__p_kdb__KDB, 0, 0, 0},{0, 0, 0, 0}};
   11109             : static swig_cast_info _swigc__p_kdb__KDBException[] = {  {&_swigt__p_kdb__KDBException, 0, 0, 0},  {&_swigt__p_kdb__ContractException, _p_kdb__ContractExceptionTo_p_kdb__KDBException, 0, 0},{0, 0, 0, 0}};
   11110             : static swig_cast_info _swigc__p_kdb__Key[] = {  {&_swigt__p_kdb__Key, 0, 0, 0},{0, 0, 0, 0}};
   11111             : static swig_cast_info _swigc__p_kdb__KeyException[] = {  {&_swigt__p_kdb__KeyException, 0, 0, 0},  {&_swigt__p_kdb__KeyTypeMismatch, _p_kdb__KeyTypeMismatchTo_p_kdb__KeyException, 0, 0},  {&_swigt__p_kdb__KeyTypeConversion, _p_kdb__KeyTypeConversionTo_p_kdb__KeyException, 0, 0},  {&_swigt__p_kdb__KeyInvalidName, _p_kdb__KeyInvalidNameTo_p_kdb__KeyException, 0, 0},{0, 0, 0, 0}};
   11112             : static swig_cast_info _swigc__p_kdb__KeyInvalidName[] = {  {&_swigt__p_kdb__KeyInvalidName, 0, 0, 0},{0, 0, 0, 0}};
   11113             : static swig_cast_info _swigc__p_kdb__KeyNotFoundException[] = {  {&_swigt__p_kdb__KeyNotFoundException, 0, 0, 0},{0, 0, 0, 0}};
   11114             : static swig_cast_info _swigc__p_kdb__KeySet[] = {  {&_swigt__p_kdb__KeySet, 0, 0, 0},{0, 0, 0, 0}};
   11115             : static swig_cast_info _swigc__p_kdb__KeyTypeConversion[] = {  {&_swigt__p_kdb__KeyTypeConversion, 0, 0, 0},{0, 0, 0, 0}};
   11116             : static swig_cast_info _swigc__p_kdb__KeyTypeMismatch[] = {  {&_swigt__p_kdb__KeyTypeMismatch, 0, 0, 0},{0, 0, 0, 0}};
   11117             : static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
   11118             : static swig_cast_info _swigc__p_option_t[] = {  {&_swigt__p_option_t, 0, 0, 0},{0, 0, 0, 0}};
   11119             : static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
   11120             : static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
   11121             : static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
   11122             : static swig_cast_info _swigc__p_std__exception[] = {  {&_swigt__p_std__exception, 0, 0, 0},  {&_swigt__p_kdb__Exception, _p_kdb__ExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_kdb__KeyException, _p_kdb__KeyExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_kdb__KeyTypeMismatch, _p_kdb__KeyTypeMismatchTo_p_std__exception, 0, 0},  {&_swigt__p_kdb__KeyNotFoundException, _p_kdb__KeyNotFoundExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_kdb__KDBException, _p_kdb__KDBExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_kdb__ContractException, _p_kdb__ContractExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_kdb__KeyTypeConversion, _p_kdb__KeyTypeConversionTo_p_std__exception, 0, 0},  {&_swigt__p_kdb__KeyInvalidName, _p_kdb__KeyInvalidNameTo_p_std__exception, 0, 0},{0, 0, 0, 0}};
   11123             : static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
   11124             : static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
   11125             : static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
   11126             : static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
   11127             : static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
   11128             : static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
   11129             : static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
   11130             : 
   11131             : static swig_cast_info *swig_cast_initial[] = {
   11132             :   _swigc__p_Key,
   11133             :   _swigc__p__Key,
   11134             :   _swigc__p__KeySet,
   11135             :   _swigc__p_char,
   11136             :   _swigc__p_f___void,
   11137             :   _swigc__p_f_p__KeySet_p__Key_p__Key_option_t__p__Key,
   11138             :   _swigc__p_int,
   11139             :   _swigc__p_kdb__ContractException,
   11140             :   _swigc__p_kdb__Exception,
   11141             :   _swigc__p_kdb__KDB,
   11142             :   _swigc__p_kdb__KDBException,
   11143             :   _swigc__p_kdb__Key,
   11144             :   _swigc__p_kdb__KeyException,
   11145             :   _swigc__p_kdb__KeyInvalidName,
   11146             :   _swigc__p_kdb__KeyNotFoundException,
   11147             :   _swigc__p_kdb__KeySet,
   11148             :   _swigc__p_kdb__KeyTypeConversion,
   11149             :   _swigc__p_kdb__KeyTypeMismatch,
   11150             :   _swigc__p_long_long,
   11151             :   _swigc__p_option_t,
   11152             :   _swigc__p_p_PyObject,
   11153             :   _swigc__p_short,
   11154             :   _swigc__p_signed_char,
   11155             :   _swigc__p_std__exception,
   11156             :   _swigc__p_std__invalid_argument,
   11157             :   _swigc__p_swig__SwigPyIterator,
   11158             :   _swigc__p_unsigned_char,
   11159             :   _swigc__p_unsigned_int,
   11160             :   _swigc__p_unsigned_long_long,
   11161             :   _swigc__p_unsigned_short,
   11162             :   _swigc__p_void,
   11163             : };
   11164             : 
   11165             : 
   11166             : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
   11167             : 
   11168             : static swig_const_info swig_const_table[] = {
   11169             : {0, 0, 0, 0.0, 0, 0}};
   11170             : 
   11171             : #ifdef __cplusplus
   11172             : }
   11173             : #endif
   11174             : /* -----------------------------------------------------------------------------
   11175             :  * Type initialization:
   11176             :  * This problem is tough by the requirement that no dynamic
   11177             :  * memory is used. Also, since swig_type_info structures store pointers to
   11178             :  * swig_cast_info structures and swig_cast_info structures store pointers back
   11179             :  * to swig_type_info structures, we need some lookup code at initialization.
   11180             :  * The idea is that swig generates all the structures that are needed.
   11181             :  * The runtime then collects these partially filled structures.
   11182             :  * The SWIG_InitializeModule function takes these initial arrays out of
   11183             :  * swig_module, and does all the lookup, filling in the swig_module.types
   11184             :  * array with the correct data and linking the correct swig_cast_info
   11185             :  * structures together.
   11186             :  *
   11187             :  * The generated swig_type_info structures are assigned statically to an initial
   11188             :  * array. We just loop through that array, and handle each type individually.
   11189             :  * First we lookup if this type has been already loaded, and if so, use the
   11190             :  * loaded structure instead of the generated one. Then we have to fill in the
   11191             :  * cast linked list. The cast data is initially stored in something like a
   11192             :  * two-dimensional array. Each row corresponds to a type (there are the same
   11193             :  * number of rows as there are in the swig_type_initial array). Each entry in
   11194             :  * a column is one of the swig_cast_info structures for that type.
   11195             :  * The cast_initial array is actually an array of arrays, because each row has
   11196             :  * a variable number of columns. So to actually build the cast linked list,
   11197             :  * we find the array of casts associated with the type, and loop through it
   11198             :  * adding the casts to the list. The one last trick we need to do is making
   11199             :  * sure the type pointer in the swig_cast_info struct is correct.
   11200             :  *
   11201             :  * First off, we lookup the cast->type name to see if it is already loaded.
   11202             :  * There are three cases to handle:
   11203             :  *  1) If the cast->type has already been loaded AND the type we are adding
   11204             :  *     casting info to has not been loaded (it is in this module), THEN we
   11205             :  *     replace the cast->type pointer with the type pointer that has already
   11206             :  *     been loaded.
   11207             :  *  2) If BOTH types (the one we are adding casting info to, and the
   11208             :  *     cast->type) are loaded, THEN the cast info has already been loaded by
   11209             :  *     the previous module so we just ignore it.
   11210             :  *  3) Finally, if cast->type has not already been loaded, then we add that
   11211             :  *     swig_cast_info to the linked list (because the cast->type) pointer will
   11212             :  *     be correct.
   11213             :  * ----------------------------------------------------------------------------- */
   11214             : 
   11215             : #ifdef __cplusplus
   11216             : extern "C" {
   11217             : #if 0
   11218             : } /* c-mode */
   11219             : #endif
   11220             : #endif
   11221             : 
   11222             : #if 0
   11223             : #define SWIGRUNTIME_DEBUG
   11224             : #endif
   11225             : 
   11226             : 
   11227             : SWIGRUNTIME void
   11228           3 : SWIG_InitializeModule(void *clientdata) {
   11229             :   size_t i;
   11230             :   swig_module_info *module_head, *iter;
   11231             :   int init;
   11232             :   
   11233             :   /* check to see if the circular list has been setup, if not, set it up */
   11234           3 :   if (swig_module.next==0) {
   11235             :     /* Initialize the swig_module */
   11236           3 :     swig_module.type_initial = swig_type_initial;
   11237           3 :     swig_module.cast_initial = swig_cast_initial;
   11238           3 :     swig_module.next = &swig_module;
   11239           3 :     init = 1;
   11240             :   } else {
   11241             :     init = 0;
   11242             :   }
   11243             :   
   11244             :   /* Try and load any already created modules */
   11245           3 :   module_head = SWIG_GetModule(clientdata);
   11246           3 :   if (!module_head) {
   11247             :     /* This is the first module loaded for this interpreter */
   11248             :     /* so set the swig module into the interpreter */
   11249           3 :     SWIG_SetModule(clientdata, &swig_module);
   11250             :   } else {
   11251             :     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
   11252             :     iter=module_head;
   11253             :     do {
   11254           0 :       if (iter==&swig_module) {
   11255             :         /* Our module is already in the list, so there's nothing more to do. */
   11256             :         return;
   11257             :       }
   11258           0 :       iter=iter->next;
   11259           0 :     } while (iter!= module_head);
   11260             :     
   11261             :     /* otherwise we must add our module into the list */
   11262           0 :     swig_module.next = module_head->next;
   11263           0 :     module_head->next = &swig_module;
   11264             :   }
   11265             :   
   11266             :   /* When multiple interpreters are used, a module could have already been initialized in
   11267             :        a different interpreter, but not yet have a pointer in this interpreter.
   11268             :        In this case, we do not want to continue adding types... everything should be
   11269             :        set up already */
   11270           3 :   if (init == 0) return;
   11271             :   
   11272             :   /* Now work on filling in swig_module.types */
   11273             : #ifdef SWIGRUNTIME_DEBUG
   11274             :   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
   11275             : #endif
   11276         189 :   for (i = 0; i < swig_module.size; ++i) {
   11277          93 :     swig_type_info *type = 0;
   11278             :     swig_type_info *ret;
   11279             :     swig_cast_info *cast;
   11280             :     
   11281             : #ifdef SWIGRUNTIME_DEBUG
   11282             :     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
   11283             : #endif
   11284             :     
   11285             :     /* if there is another module already loaded */
   11286          93 :     if (swig_module.next != &swig_module) {
   11287           0 :       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
   11288             :     }
   11289          93 :     if (type) {
   11290             :       /* Overwrite clientdata field */
   11291             : #ifdef SWIGRUNTIME_DEBUG
   11292             :       printf("SWIG_InitializeModule: found type %s\n", type->name);
   11293             : #endif
   11294           0 :       if (swig_module.type_initial[i]->clientdata) {
   11295           0 :         type->clientdata = swig_module.type_initial[i]->clientdata;
   11296             : #ifdef SWIGRUNTIME_DEBUG
   11297             :         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
   11298             : #endif
   11299             :       }
   11300             :     } else {
   11301          93 :       type = swig_module.type_initial[i];
   11302             :     }
   11303             :     
   11304             :     /* Insert casting types */
   11305          93 :     cast = swig_module.cast_initial[i];
   11306         243 :     while (cast->type) {
   11307             :       /* Don't need to add information already in the list */
   11308         150 :       ret = 0;
   11309             : #ifdef SWIGRUNTIME_DEBUG
   11310             :       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
   11311             : #endif
   11312         150 :       if (swig_module.next != &swig_module) {
   11313           0 :         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
   11314             : #ifdef SWIGRUNTIME_DEBUG
   11315             :         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
   11316             : #endif
   11317             :       }
   11318         150 :       if (ret) {
   11319           0 :         if (type == swig_module.type_initial[i]) {
   11320             : #ifdef SWIGRUNTIME_DEBUG
   11321             :           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
   11322             : #endif
   11323           0 :           cast->type = ret;
   11324           0 :           ret = 0;
   11325             :         } else {
   11326             :           /* Check for casting already in the list */
   11327           0 :           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
   11328             : #ifdef SWIGRUNTIME_DEBUG
   11329             :           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
   11330             : #endif
   11331           0 :           if (!ocast) ret = 0;
   11332             :         }
   11333             :       }
   11334             :       
   11335         150 :       if (!ret) {
   11336             : #ifdef SWIGRUNTIME_DEBUG
   11337             :         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
   11338             : #endif
   11339         150 :         if (type->cast) {
   11340          57 :           type->cast->prev = cast;
   11341          57 :           cast->next = type->cast;
   11342             :         }
   11343         150 :         type->cast = cast;
   11344             :       }
   11345         150 :       cast++;
   11346             :     }
   11347             :     /* Set entry in modules->types array equal to the type */
   11348          93 :     swig_module.types[i] = type;
   11349             :   }
   11350           3 :   swig_module.types[i] = 0;
   11351             :   
   11352             : #ifdef SWIGRUNTIME_DEBUG
   11353             :   printf("**** SWIG_InitializeModule: Cast List ******\n");
   11354             :   for (i = 0; i < swig_module.size; ++i) {
   11355             :     int j = 0;
   11356             :     swig_cast_info *cast = swig_module.cast_initial[i];
   11357             :     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
   11358             :     while (cast->type) {
   11359             :       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
   11360             :       cast++;
   11361             :       ++j;
   11362             :     }
   11363             :     printf("---- Total casts: %d\n",j);
   11364             :   }
   11365             :   printf("**** SWIG_InitializeModule: Cast List ******\n");
   11366             : #endif
   11367             : }
   11368             : 
   11369             : /* This function will propagate the clientdata field of type to
   11370             : * any new swig_type_info structures that have been added into the list
   11371             : * of equivalent types.  It is like calling
   11372             : * SWIG_TypeClientData(type, clientdata) a second time.
   11373             : */
   11374             : SWIGRUNTIME void
   11375             : SWIG_PropagateClientData(void) {
   11376             :   size_t i;
   11377             :   swig_cast_info *equiv;
   11378             :   static int init_run = 0;
   11379             :   
   11380             :   if (init_run) return;
   11381             :   init_run = 1;
   11382             :   
   11383             :   for (i = 0; i < swig_module.size; i++) {
   11384             :     if (swig_module.types[i]->clientdata) {
   11385             :       equiv = swig_module.types[i]->cast;
   11386             :       while (equiv) {
   11387             :         if (!equiv->converter) {
   11388             :           if (equiv->type && !equiv->type->clientdata)
   11389             :           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
   11390             :         }
   11391             :         equiv = equiv->next;
   11392             :       }
   11393             :     }
   11394             :   }
   11395             : }
   11396             : 
   11397             : #ifdef __cplusplus
   11398             : #if 0
   11399             : {
   11400             :   /* c-mode */
   11401             : #endif
   11402             : }
   11403             : #endif
   11404             : 
   11405             : 
   11406             : 
   11407             : #ifdef __cplusplus
   11408             : extern "C" {
   11409             : #endif
   11410             :   
   11411             :   /* Python-specific SWIG API */
   11412             : #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
   11413             : #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
   11414             : #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
   11415             :   
   11416             :   /* -----------------------------------------------------------------------------
   11417             :    * global variable support code.
   11418             :    * ----------------------------------------------------------------------------- */
   11419             :   
   11420             :   typedef struct swig_globalvar {
   11421             :     char       *name;                  /* Name of global variable */
   11422             :     PyObject *(*get_attr)(void);       /* Return the current value */
   11423             :     int       (*set_attr)(PyObject *); /* Set the value */
   11424             :     struct swig_globalvar *next;
   11425             :   } swig_globalvar;
   11426             :   
   11427             :   typedef struct swig_varlinkobject {
   11428             :     PyObject_HEAD
   11429             :     swig_globalvar *vars;
   11430             :   } swig_varlinkobject;
   11431             :   
   11432             :   SWIGINTERN PyObject *
   11433             :   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
   11434             : #if PY_VERSION_HEX >= 0x03000000
   11435             :     return PyUnicode_InternFromString("<Swig global variables>");
   11436             : #else
   11437             :     return PyString_FromString("<Swig global variables>");
   11438             : #endif
   11439             :   }
   11440             :   
   11441             :   SWIGINTERN PyObject *
   11442             :   swig_varlink_str(swig_varlinkobject *v) {
   11443             : #if PY_VERSION_HEX >= 0x03000000
   11444             :     PyObject *str = PyUnicode_InternFromString("(");
   11445             :     PyObject *tail;
   11446             :     PyObject *joined;
   11447             :     swig_globalvar *var;
   11448             :     for (var = v->vars; var; var=var->next) {
   11449             :       tail = PyUnicode_FromString(var->name);
   11450             :       joined = PyUnicode_Concat(str, tail);
   11451             :       Py_DecRef(str);
   11452             :       Py_DecRef(tail);
   11453             :       str = joined;
   11454             :       if (var->next) {
   11455             :         tail = PyUnicode_InternFromString(", ");
   11456             :         joined = PyUnicode_Concat(str, tail);
   11457             :         Py_DecRef(str);
   11458             :         Py_DecRef(tail);
   11459             :         str = joined;
   11460             :       }
   11461             :     }
   11462             :     tail = PyUnicode_InternFromString(")");
   11463             :     joined = PyUnicode_Concat(str, tail);
   11464             :     Py_DecRef(str);
   11465             :     Py_DecRef(tail);
   11466             :     str = joined;
   11467             : #else
   11468             :     PyObject *str = PyString_FromString("(");
   11469             :     swig_globalvar *var;
   11470             :     for (var = v->vars; var; var=var->next) {
   11471             :       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
   11472             :       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
   11473             :     }
   11474             :     PyString_ConcatAndDel(&str,PyString_FromString(")"));
   11475             : #endif
   11476             :     return str;
   11477             :   }
   11478             :   
   11479             :   SWIGINTERN int
   11480             :   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
   11481             :     char *tmp;
   11482             :     PyObject *str = swig_varlink_str(v);
   11483             :     fprintf(fp,"Swig global variables ");
   11484             :     fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
   11485             :     SWIG_Python_str_DelForPy3(tmp);
   11486             :     Py_DECREF(str);
   11487             :     return 0;
   11488             :   }
   11489             :   
   11490             :   SWIGINTERN void
   11491             :   swig_varlink_dealloc(swig_varlinkobject *v) {
   11492             :     swig_globalvar *var = v->vars;
   11493             :     while (var) {
   11494             :       swig_globalvar *n = var->next;
   11495             :       free(var->name);
   11496             :       free(var);
   11497             :       var = n;
   11498             :     }
   11499             :   }
   11500             :   
   11501             :   SWIGINTERN PyObject *
   11502             :   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
   11503             :     PyObject *res = NULL;
   11504             :     swig_globalvar *var = v->vars;
   11505             :     while (var) {
   11506             :       if (strcmp(var->name,n) == 0) {
   11507             :         res = (*var->get_attr)();
   11508             :         break;
   11509             :       }
   11510             :       var = var->next;
   11511             :     }
   11512             :     if (res == NULL && !PyErr_Occurred()) {
   11513             :       PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
   11514             :     }
   11515             :     return res;
   11516             :   }
   11517             :   
   11518             :   SWIGINTERN int
   11519             :   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
   11520             :     int res = 1;
   11521             :     swig_globalvar *var = v->vars;
   11522             :     while (var) {
   11523             :       if (strcmp(var->name,n) == 0) {
   11524             :         res = (*var->set_attr)(p);
   11525             :         break;
   11526             :       }
   11527             :       var = var->next;
   11528             :     }
   11529             :     if (res == 1 && !PyErr_Occurred()) {
   11530             :       PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
   11531             :     }
   11532             :     return res;
   11533             :   }
   11534             :   
   11535             :   SWIGINTERN PyTypeObject*
   11536             :   swig_varlink_type(void) {
   11537             :     static char varlink__doc__[] = "Swig var link object";
   11538             :     static PyTypeObject varlink_type;
   11539             :     static int type_init = 0;
   11540             :     if (!type_init) {
   11541             :       const PyTypeObject tmp = {
   11542             :         /* PyObject header changed in Python 3 */
   11543             : #if PY_VERSION_HEX >= 0x03000000
   11544             :         PyVarObject_HEAD_INIT(NULL, 0)
   11545             : #else
   11546             :         PyObject_HEAD_INIT(NULL)
   11547             :         0,                                  /* ob_size */
   11548             : #endif
   11549             :         (char *)"swigvarlink",              /* tp_name */
   11550             :         sizeof(swig_varlinkobject),         /* tp_basicsize */
   11551             :         0,                                  /* tp_itemsize */
   11552             :         (destructor) swig_varlink_dealloc,  /* tp_dealloc */
   11553             :         (printfunc) swig_varlink_print,     /* tp_print */
   11554             :         (getattrfunc) swig_varlink_getattr, /* tp_getattr */
   11555             :         (setattrfunc) swig_varlink_setattr, /* tp_setattr */
   11556             :         0,                                  /* tp_compare */
   11557             :         (reprfunc) swig_varlink_repr,       /* tp_repr */
   11558             :         0,                                  /* tp_as_number */
   11559             :         0,                                  /* tp_as_sequence */
   11560             :         0,                                  /* tp_as_mapping */
   11561             :         0,                                  /* tp_hash */
   11562             :         0,                                  /* tp_call */
   11563             :         (reprfunc) swig_varlink_str,        /* tp_str */
   11564             :         0,                                  /* tp_getattro */
   11565             :         0,                                  /* tp_setattro */
   11566             :         0,                                  /* tp_as_buffer */
   11567             :         0,                                  /* tp_flags */
   11568             :         varlink__doc__,                     /* tp_doc */
   11569             :         0,                                  /* tp_traverse */
   11570             :         0,                                  /* tp_clear */
   11571             :         0,                                  /* tp_richcompare */
   11572             :         0,                                  /* tp_weaklistoffset */
   11573             : #if PY_VERSION_HEX >= 0x02020000
   11574             :         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
   11575             : #endif
   11576             : #if PY_VERSION_HEX >= 0x02030000
   11577             :         0,                                  /* tp_del */
   11578             : #endif
   11579             : #if PY_VERSION_HEX >= 0x02060000
   11580             :         0,                                  /* tp_version_tag */
   11581             : #endif
   11582             : #if PY_VERSION_HEX >= 0x03040000
   11583             :         0,                                  /* tp_finalize */
   11584             : #endif
   11585             : #ifdef COUNT_ALLOCS
   11586             :         0,                                  /* tp_allocs */
   11587             :         0,                                  /* tp_frees */
   11588             :         0,                                  /* tp_maxalloc */
   11589             : #if PY_VERSION_HEX >= 0x02050000
   11590             :         0,                                  /* tp_prev */
   11591             : #endif
   11592             :         0                                   /* tp_next */
   11593             : #endif
   11594             :       };
   11595             :       varlink_type = tmp;
   11596             :       type_init = 1;
   11597             : #if PY_VERSION_HEX < 0x02020000
   11598             :       varlink_type.ob_type = &PyType_Type;
   11599             : #else
   11600             :       if (PyType_Ready(&varlink_type) < 0)
   11601             :       return NULL;
   11602             : #endif
   11603             :     }
   11604             :     return &varlink_type;
   11605             :   }
   11606             :   
   11607             :   /* Create a variable linking object for use later */
   11608             :   SWIGINTERN PyObject *
   11609             :   SWIG_Python_newvarlink(void) {
   11610             :     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
   11611             :     if (result) {
   11612             :       result->vars = 0;
   11613             :     }
   11614             :     return ((PyObject*) result);
   11615             :   }
   11616             :   
   11617             :   SWIGINTERN void 
   11618             :   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
   11619             :     swig_varlinkobject *v = (swig_varlinkobject *) p;
   11620             :     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
   11621             :     if (gv) {
   11622             :       size_t size = strlen(name)+1;
   11623             :       gv->name = (char *)malloc(size);
   11624             :       if (gv->name) {
   11625             :         strncpy(gv->name,name,size);
   11626             :         gv->get_attr = get_attr;
   11627             :         gv->set_attr = set_attr;
   11628             :         gv->next = v->vars;
   11629             :       }
   11630             :     }
   11631             :     v->vars = gv;
   11632             :   }
   11633             :   
   11634             :   SWIGINTERN PyObject *
   11635             :   SWIG_globals(void) {
   11636             :     static PyObject *_SWIG_globals = 0; 
   11637             :     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();  
   11638             :     return _SWIG_globals;
   11639             :   }
   11640             :   
   11641             :   /* -----------------------------------------------------------------------------
   11642             :    * constants/methods manipulation
   11643             :    * ----------------------------------------------------------------------------- */
   11644             :   
   11645             :   /* Install Constants */
   11646             :   SWIGINTERN void
   11647           3 :   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
   11648           3 :     PyObject *obj = 0;
   11649             :     size_t i;
   11650           3 :     for (i = 0; constants[i].type; ++i) {
   11651           0 :       switch(constants[i].type) {
   11652             :       case SWIG_PY_POINTER:
   11653           0 :         obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
   11654           0 :         break;
   11655             :       case SWIG_PY_BINARY:
   11656           0 :         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
   11657             :         break;
   11658             :       default:
   11659             :         obj = 0;
   11660             :         break;
   11661             :       }
   11662           0 :       if (obj) {
   11663           0 :         PyDict_SetItemString(d, constants[i].name, obj);
   11664           0 :         Py_DECREF(obj);
   11665             :       }
   11666             :     }
   11667           3 :   }
   11668             :   
   11669             :   /* -----------------------------------------------------------------------------*/
   11670             :   /* Fix SwigMethods to carry the callback ptrs when needed */
   11671             :   /* -----------------------------------------------------------------------------*/
   11672             :   
   11673             :   SWIGINTERN void
   11674           3 :   SWIG_Python_FixMethods(PyMethodDef *methods,
   11675             :     swig_const_info *const_table,
   11676             :     swig_type_info **types,
   11677             :     swig_type_info **types_initial) {
   11678             :     size_t i;
   11679         471 :     for (i = 0; methods[i].ml_name; ++i) {
   11680         468 :       const char *c = methods[i].ml_doc;
   11681         468 :       if (!c) continue;
   11682         345 :       c = strstr(c, "swig_ptr: ");
   11683         345 :       if (c) {
   11684             :         int j;
   11685           0 :         swig_const_info *ci = 0;
   11686           0 :         const char *name = c + 10;
   11687           0 :         for (j = 0; const_table[j].type; ++j) {
   11688           0 :           if (strncmp(const_table[j].name, name, 
   11689           0 :               strlen(const_table[j].name)) == 0) {
   11690             :             ci = &(const_table[j]);
   11691             :             break;
   11692             :           }
   11693             :         }
   11694           0 :         if (ci) {
   11695           0 :           void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
   11696           0 :           if (ptr) {
   11697           0 :             size_t shift = (ci->ptype) - types;
   11698           0 :             swig_type_info *ty = types_initial[shift];
   11699           0 :             size_t ldoc = (c - methods[i].ml_doc);
   11700           0 :             size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
   11701           0 :             char *ndoc = (char*)malloc(ldoc + lptr + 10);
   11702           0 :             if (ndoc) {
   11703           0 :               char *buff = ndoc;
   11704           0 :               strncpy(buff, methods[i].ml_doc, ldoc);
   11705           0 :               buff += ldoc;
   11706           0 :               strncpy(buff, "swig_ptr: ", 10);
   11707           0 :               buff += 10;
   11708           0 :               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
   11709           0 :               methods[i].ml_doc = ndoc;
   11710             :             }
   11711             :           }
   11712             :         }
   11713             :       }
   11714             :     }
   11715           3 :   } 
   11716             :   
   11717             : #ifdef __cplusplus
   11718             : }
   11719             : #endif
   11720             : 
   11721             : /* -----------------------------------------------------------------------------*
   11722             :  *  Partial Init method
   11723             :  * -----------------------------------------------------------------------------*/
   11724             : 
   11725             : #ifdef __cplusplus
   11726             : extern "C"
   11727             : #endif
   11728             : 
   11729             : SWIGEXPORT 
   11730             : #if PY_VERSION_HEX >= 0x03000000
   11731             : PyObject*
   11732             : #else
   11733             : void
   11734             : #endif
   11735           3 : SWIG_init(void) {
   11736             :   PyObject *m, *d, *md;
   11737             : #if PY_VERSION_HEX >= 0x03000000
   11738             :   static struct PyModuleDef SWIG_module = {
   11739             : # if PY_VERSION_HEX >= 0x03020000
   11740             :     PyModuleDef_HEAD_INIT,
   11741             : # else
   11742             :     {
   11743             :       PyObject_HEAD_INIT(NULL)
   11744             :       NULL, /* m_init */
   11745             :       0,    /* m_index */
   11746             :       NULL, /* m_copy */
   11747             :     },
   11748             : # endif
   11749             :     (char *) SWIG_name,
   11750             :     NULL,
   11751             :     -1,
   11752             :     SwigMethods,
   11753             :     NULL,
   11754             :     NULL,
   11755             :     NULL,
   11756             :     NULL
   11757             :   };
   11758             : #endif
   11759             :   
   11760             : #if defined(SWIGPYTHON_BUILTIN)
   11761             :   static SwigPyClientData SwigPyObject_clientdata = {
   11762             :     0, 0, 0, 0, 0, 0, 0
   11763             :   };
   11764             :   static PyGetSetDef this_getset_def = {
   11765             :     (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
   11766             :   };
   11767             :   static SwigPyGetSet thisown_getset_closure = {
   11768             :     (PyCFunction) SwigPyObject_own,
   11769             :     (PyCFunction) SwigPyObject_own
   11770             :   };
   11771             :   static PyGetSetDef thisown_getset_def = {
   11772             :     (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
   11773             :   };
   11774             :   PyObject *metatype_args;
   11775             :   PyTypeObject *builtin_pytype;
   11776             :   int builtin_base_count;
   11777             :   swig_type_info *builtin_basetype;
   11778             :   PyObject *tuple;
   11779             :   PyGetSetDescrObject *static_getset;
   11780             :   PyTypeObject *metatype;
   11781             :   SwigPyClientData *cd;
   11782             :   PyObject *public_interface, *public_symbol;
   11783             :   PyObject *this_descr;
   11784             :   PyObject *thisown_descr;
   11785             :   PyObject *self = 0;
   11786             :   int i;
   11787             :   
   11788             :   (void)builtin_pytype;
   11789             :   (void)builtin_base_count;
   11790             :   (void)builtin_basetype;
   11791             :   (void)tuple;
   11792             :   (void)static_getset;
   11793             :   (void)self;
   11794             :   
   11795             :   /* metatype is used to implement static member variables. */
   11796             :   metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
   11797             :   assert(metatype_args);
   11798             :   metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
   11799             :   assert(metatype);
   11800             :   Py_DECREF(metatype_args);
   11801             :   metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
   11802             :   assert(PyType_Ready(metatype) >= 0);
   11803             : #endif
   11804             :   
   11805             :   /* Fix SwigMethods to carry the callback ptrs when needed */
   11806           3 :   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
   11807             :   
   11808             : #if PY_VERSION_HEX >= 0x03000000
   11809             :   m = PyModule_Create(&SWIG_module);
   11810             : #else
   11811           3 :   m = Py_InitModule((char *) SWIG_name, SwigMethods);
   11812             : #endif
   11813             :   
   11814           3 :   md = d = PyModule_GetDict(m);
   11815             :   (void)md;
   11816             :   
   11817           3 :   SWIG_InitializeModule(0);
   11818             :   
   11819             : #ifdef SWIGPYTHON_BUILTIN
   11820             :   SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
   11821             :   assert(SwigPyObject_stype);
   11822             :   cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
   11823             :   if (!cd) {
   11824             :     SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
   11825             :     SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
   11826             :   } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
   11827             :     PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
   11828             : # if PY_VERSION_HEX >= 0x03000000
   11829             :     return NULL;
   11830             : # else
   11831             :     return;
   11832             : # endif
   11833             :   }
   11834             :   
   11835             :   /* All objects have a 'this' attribute */
   11836             :   this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
   11837             :   (void)this_descr;
   11838             :   
   11839             :   /* All objects have a 'thisown' attribute */
   11840             :   thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
   11841             :   (void)thisown_descr;
   11842             :   
   11843             :   public_interface = PyList_New(0);
   11844             :   public_symbol = 0;
   11845             :   (void)public_symbol;
   11846             :   
   11847             :   PyDict_SetItemString(md, "__all__", public_interface);
   11848             :   Py_DECREF(public_interface);
   11849             :   for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
   11850             :   SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
   11851             :   for (i = 0; swig_const_table[i].name != 0; ++i)
   11852             :   SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
   11853             : #endif
   11854             :   
   11855           3 :   SWIG_InstallConstants(d,swig_const_table);
   11856             :   
   11857           3 :   SWIG_Python_SetConstant(d, "DB_SYSTEM",SWIG_FromCharPtr(KDB_DB_SYSTEM));
   11858           3 :   SWIG_Python_SetConstant(d, "DB_USER",SWIG_FromCharPtr(KDB_DB_USER));
   11859           3 :   SWIG_Python_SetConstant(d, "DB_HOME",SWIG_FromCharPtr(KDB_DB_HOME));
   11860           3 :   SWIG_Python_SetConstant(d, "DEBUG",SWIG_From_bool(static_cast< bool >(DEBUG)));
   11861           6 :   SWIG_Python_SetConstant(d, "KS_END",SWIG_NewPointerObj(SWIG_as_voidptr(KS_END),SWIGTYPE_p_void, 0 ));
   11862           3 :   SWIG_Python_SetConstant(d, "VERSION",SWIG_FromCharPtr(KDB_VERSION));
   11863           3 :   SWIG_Python_SetConstant(d, "VERSION_MAJOR",SWIG_From_short(static_cast< short >(KDB_VERSION_MAJOR)));
   11864           3 :   SWIG_Python_SetConstant(d, "VERSION_MINOR",SWIG_From_short(static_cast< short >(KDB_VERSION_MINOR)));
   11865           3 :   SWIG_Python_SetConstant(d, "VERSION_MICRO",SWIG_From_short(static_cast< short >(KDB_VERSION_MICRO)));
   11866           3 :   SWIG_Python_SetConstant(d, "KDB_VERSION",SWIG_FromCharPtr("0.9.0"));
   11867           3 :   SWIG_Python_SetConstant(d, "KDB_VERSION_MAJOR",SWIG_From_int(static_cast< int >(0)));
   11868           3 :   SWIG_Python_SetConstant(d, "KDB_VERSION_MINOR",SWIG_From_int(static_cast< int >(9)));
   11869           3 :   SWIG_Python_SetConstant(d, "KDB_VERSION_MICRO",SWIG_From_int(static_cast< int >(0)));
   11870           3 :   SWIG_Python_SetConstant(d, "KEY_NAME",SWIG_From_int(static_cast< int >(KEY_NAME)));
   11871           3 :   SWIG_Python_SetConstant(d, "KEY_VALUE",SWIG_From_int(static_cast< int >(KEY_VALUE)));
   11872           3 :   SWIG_Python_SetConstant(d, "KEY_FLAGS",SWIG_From_int(static_cast< int >(KEY_FLAGS)));
   11873           3 :   SWIG_Python_SetConstant(d, "KEY_OWNER",SWIG_From_int(static_cast< int >(KEY_OWNER)));
   11874           3 :   SWIG_Python_SetConstant(d, "KEY_COMMENT",SWIG_From_int(static_cast< int >(KEY_COMMENT)));
   11875           3 :   SWIG_Python_SetConstant(d, "KEY_BINARY",SWIG_From_int(static_cast< int >(KEY_BINARY)));
   11876           3 :   SWIG_Python_SetConstant(d, "KEY_UID",SWIG_From_int(static_cast< int >(KEY_UID)));
   11877           3 :   SWIG_Python_SetConstant(d, "KEY_GID",SWIG_From_int(static_cast< int >(KEY_GID)));
   11878           3 :   SWIG_Python_SetConstant(d, "KEY_MODE",SWIG_From_int(static_cast< int >(KEY_MODE)));
   11879           3 :   SWIG_Python_SetConstant(d, "KEY_ATIME",SWIG_From_int(static_cast< int >(KEY_ATIME)));
   11880           3 :   SWIG_Python_SetConstant(d, "KEY_MTIME",SWIG_From_int(static_cast< int >(KEY_MTIME)));
   11881           3 :   SWIG_Python_SetConstant(d, "KEY_CTIME",SWIG_From_int(static_cast< int >(KEY_CTIME)));
   11882           3 :   SWIG_Python_SetConstant(d, "KEY_SIZE",SWIG_From_int(static_cast< int >(KEY_SIZE)));
   11883           3 :   SWIG_Python_SetConstant(d, "KEY_FUNC",SWIG_From_int(static_cast< int >(KEY_FUNC)));
   11884           3 :   SWIG_Python_SetConstant(d, "KEY_DIR",SWIG_From_int(static_cast< int >(KEY_DIR)));
   11885           3 :   SWIG_Python_SetConstant(d, "KEY_META",SWIG_From_int(static_cast< int >(KEY_META)));
   11886           3 :   SWIG_Python_SetConstant(d, "KEY_NULL",SWIG_From_int(static_cast< int >(KEY_NULL)));
   11887           3 :   SWIG_Python_SetConstant(d, "KEY_CASCADING_NAME",SWIG_From_int(static_cast< int >(KEY_CASCADING_NAME)));
   11888           3 :   SWIG_Python_SetConstant(d, "KEY_META_NAME",SWIG_From_int(static_cast< int >(KEY_META_NAME)));
   11889           3 :   SWIG_Python_SetConstant(d, "KEY_END",SWIG_From_int(static_cast< int >(KEY_END)));
   11890           3 :   SWIG_Python_SetConstant(d, "KDB_O_NONE",SWIG_From_int(static_cast< int >(KDB_O_NONE)));
   11891           3 :   SWIG_Python_SetConstant(d, "KDB_O_DEL",SWIG_From_int(static_cast< int >(KDB_O_DEL)));
   11892           3 :   SWIG_Python_SetConstant(d, "KDB_O_POP",SWIG_From_int(static_cast< int >(KDB_O_POP)));
   11893           3 :   SWIG_Python_SetConstant(d, "KDB_O_NODIR",SWIG_From_int(static_cast< int >(KDB_O_NODIR)));
   11894           3 :   SWIG_Python_SetConstant(d, "KDB_O_DIRONLY",SWIG_From_int(static_cast< int >(KDB_O_DIRONLY)));
   11895           3 :   SWIG_Python_SetConstant(d, "KDB_O_NOREMOVE",SWIG_From_int(static_cast< int >(KDB_O_NOREMOVE)));
   11896           3 :   SWIG_Python_SetConstant(d, "KDB_O_REMOVEONLY",SWIG_From_int(static_cast< int >(KDB_O_REMOVEONLY)));
   11897           3 :   SWIG_Python_SetConstant(d, "KDB_O_INACTIVE",SWIG_From_int(static_cast< int >(KDB_O_INACTIVE)));
   11898           3 :   SWIG_Python_SetConstant(d, "KDB_O_SYNC",SWIG_From_int(static_cast< int >(KDB_O_SYNC)));
   11899           3 :   SWIG_Python_SetConstant(d, "KDB_O_SORT",SWIG_From_int(static_cast< int >(KDB_O_SORT)));
   11900           3 :   SWIG_Python_SetConstant(d, "KDB_O_NORECURSIVE",SWIG_From_int(static_cast< int >(KDB_O_NORECURSIVE)));
   11901           3 :   SWIG_Python_SetConstant(d, "KDB_O_NOCASE",SWIG_From_int(static_cast< int >(KDB_O_NOCASE)));
   11902           3 :   SWIG_Python_SetConstant(d, "KDB_O_WITHOWNER",SWIG_From_int(static_cast< int >(KDB_O_WITHOWNER)));
   11903           3 :   SWIG_Python_SetConstant(d, "KDB_O_NOALL",SWIG_From_int(static_cast< int >(KDB_O_NOALL)));
   11904           3 :   SWIG_Python_SetConstant(d, "KEY_NS_NONE",SWIG_From_int(static_cast< int >(KEY_NS_NONE)));
   11905           3 :   SWIG_Python_SetConstant(d, "KEY_NS_EMPTY",SWIG_From_int(static_cast< int >(KEY_NS_EMPTY)));
   11906           3 :   SWIG_Python_SetConstant(d, "KEY_NS_META",SWIG_From_int(static_cast< int >(KEY_NS_META)));
   11907           3 :   SWIG_Python_SetConstant(d, "KEY_NS_CASCADING",SWIG_From_int(static_cast< int >(KEY_NS_CASCADING)));
   11908           3 :   SWIG_Python_SetConstant(d, "KEY_NS_FIRST",SWIG_From_int(static_cast< int >(KEY_NS_FIRST)));
   11909           3 :   SWIG_Python_SetConstant(d, "KEY_NS_SPEC",SWIG_From_int(static_cast< int >(KEY_NS_SPEC)));
   11910           3 :   SWIG_Python_SetConstant(d, "KEY_NS_PROC",SWIG_From_int(static_cast< int >(KEY_NS_PROC)));
   11911           3 :   SWIG_Python_SetConstant(d, "KEY_NS_DIR",SWIG_From_int(static_cast< int >(KEY_NS_DIR)));
   11912           3 :   SWIG_Python_SetConstant(d, "KEY_NS_USER",SWIG_From_int(static_cast< int >(KEY_NS_USER)));
   11913           3 :   SWIG_Python_SetConstant(d, "KEY_NS_SYSTEM",SWIG_From_int(static_cast< int >(KEY_NS_SYSTEM)));
   11914           3 :   SWIG_Python_SetConstant(d, "KEY_NS_LAST",SWIG_From_int(static_cast< int >(KEY_NS_LAST)));
   11915             : #if PY_VERSION_HEX >= 0x03000000
   11916             :   return m;
   11917             : #else
   11918           3 :   return;
   11919             : #endif
   11920           6 : }
   11921             : 

Generated by: LCOV version 1.13