LCOV - code coverage report
Current view: top level - build directory/src/bindings/swig/ruby - kdbtoolsRUBY_wrap.cxx (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 1941 11356 17.1 %
Date: 2019-09-12 12:28:41 Functions: 106 1029 10.3 %

          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 SWIGRUBY
      13             : #define SWIGRUBY
      14             : #endif
      15             : 
      16             : 
      17             : 
      18             : #ifdef __cplusplus
      19             : /* SwigValueWrapper is described in swig.swg */
      20           1 : template<typename T> class SwigValueWrapper {
      21             :   struct SwigMovePointer {
      22             :     T *ptr;
      23           2 :     SwigMovePointer(T *p) : ptr(p) { }
      24           3 :     ~SwigMovePointer() { delete ptr; }
      25           1 :     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
      26             :   } pointer;
      27             :   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
      28             :   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
      29             : public:
      30           2 :   SwigValueWrapper() : pointer(0) { }
      31           3 :   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
      32           0 :   operator T&() const { return *pointer.ptr; }
      33           1 :   T *operator&() { return pointer.ptr; }
      34             : };
      35             : 
      36             : template <typename T> T SwigValueInit() {
      37             :   return T();
      38             : }
      39             : #endif
      40             : 
      41             : /* -----------------------------------------------------------------------------
      42             :  *  This section contains generic SWIG labels for method/variable
      43             :  *  declarations/attributes, and other compiler dependent labels.
      44             :  * ----------------------------------------------------------------------------- */
      45             : 
      46             : /* template workaround for compilers that cannot correctly implement the C++ standard */
      47             : #ifndef SWIGTEMPLATEDISAMBIGUATOR
      48             : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
      49             : #  define SWIGTEMPLATEDISAMBIGUATOR template
      50             : # elif defined(__HP_aCC)
      51             : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
      52             : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
      53             : #  define SWIGTEMPLATEDISAMBIGUATOR template
      54             : # else
      55             : #  define SWIGTEMPLATEDISAMBIGUATOR
      56             : # endif
      57             : #endif
      58             : 
      59             : /* inline attribute */
      60             : #ifndef SWIGINLINE
      61             : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
      62             : #   define SWIGINLINE inline
      63             : # else
      64             : #   define SWIGINLINE
      65             : # endif
      66             : #endif
      67             : 
      68             : /* attribute recognised by some compilers to avoid 'unused' warnings */
      69             : #ifndef SWIGUNUSED
      70             : # if defined(__GNUC__)
      71             : #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
      72             : #     define SWIGUNUSED __attribute__ ((__unused__))
      73             : #   else
      74             : #     define SWIGUNUSED
      75             : #   endif
      76             : # elif defined(__ICC)
      77             : #   define SWIGUNUSED __attribute__ ((__unused__))
      78             : # else
      79             : #   define SWIGUNUSED
      80             : # endif
      81             : #endif
      82             : 
      83             : #ifndef SWIG_MSC_UNSUPPRESS_4505
      84             : # if defined(_MSC_VER)
      85             : #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
      86             : # endif
      87             : #endif
      88             : 
      89             : #ifndef SWIGUNUSEDPARM
      90             : # ifdef __cplusplus
      91             : #   define SWIGUNUSEDPARM(p)
      92             : # else
      93             : #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
      94             : # endif
      95             : #endif
      96             : 
      97             : /* internal SWIG method */
      98             : #ifndef SWIGINTERN
      99             : # define SWIGINTERN static SWIGUNUSED
     100             : #endif
     101             : 
     102             : /* internal inline SWIG method */
     103             : #ifndef SWIGINTERNINLINE
     104             : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
     105             : #endif
     106             : 
     107             : /* exporting methods */
     108             : #if defined(__GNUC__)
     109             : #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
     110             : #    ifndef GCC_HASCLASSVISIBILITY
     111             : #      define GCC_HASCLASSVISIBILITY
     112             : #    endif
     113             : #  endif
     114             : #endif
     115             : 
     116             : #ifndef SWIGEXPORT
     117             : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
     118             : #   if defined(STATIC_LINKED)
     119             : #     define SWIGEXPORT
     120             : #   else
     121             : #     define SWIGEXPORT __declspec(dllexport)
     122             : #   endif
     123             : # else
     124             : #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
     125             : #     define SWIGEXPORT __attribute__ ((visibility("default")))
     126             : #   else
     127             : #     define SWIGEXPORT
     128             : #   endif
     129             : # endif
     130             : #endif
     131             : 
     132             : /* calling conventions for Windows */
     133             : #ifndef SWIGSTDCALL
     134             : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
     135             : #   define SWIGSTDCALL __stdcall
     136             : # else
     137             : #   define SWIGSTDCALL
     138             : # endif
     139             : #endif
     140             : 
     141             : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
     142             : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
     143             : # define _CRT_SECURE_NO_DEPRECATE
     144             : #endif
     145             : 
     146             : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
     147             : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
     148             : # define _SCL_SECURE_NO_DEPRECATE
     149             : #endif
     150             : 
     151             : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
     152             : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
     153             : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
     154             : #endif
     155             : 
     156             : /* Intel's compiler complains if a variable which was never initialised is
     157             :  * cast to void, which is a common idiom which we use to indicate that we
     158             :  * are aware a variable isn't used.  So we just silence that warning.
     159             :  * See: https://github.com/swig/swig/issues/192 for more discussion.
     160             :  */
     161             : #ifdef __INTEL_COMPILER
     162             : # pragma warning disable 592
     163             : #endif
     164             : 
     165             : /* -----------------------------------------------------------------------------
     166             :  *  This section contains generic SWIG labels for method/variable
     167             :  *  declarations/attributes, and other compiler dependent labels.
     168             :  * ----------------------------------------------------------------------------- */
     169             : 
     170             : /* template workaround for compilers that cannot correctly implement the C++ standard */
     171             : #ifndef SWIGTEMPLATEDISAMBIGUATOR
     172             : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
     173             : #  define SWIGTEMPLATEDISAMBIGUATOR template
     174             : # elif defined(__HP_aCC)
     175             : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
     176             : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
     177             : #  define SWIGTEMPLATEDISAMBIGUATOR template
     178             : # else
     179             : #  define SWIGTEMPLATEDISAMBIGUATOR
     180             : # endif
     181             : #endif
     182             : 
     183             : /* inline attribute */
     184             : #ifndef SWIGINLINE
     185             : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
     186             : #   define SWIGINLINE inline
     187             : # else
     188             : #   define SWIGINLINE
     189             : # endif
     190             : #endif
     191             : 
     192             : /* attribute recognised by some compilers to avoid 'unused' warnings */
     193             : #ifndef SWIGUNUSED
     194             : # if defined(__GNUC__)
     195             : #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
     196             : #     define SWIGUNUSED __attribute__ ((__unused__))
     197             : #   else
     198             : #     define SWIGUNUSED
     199             : #   endif
     200             : # elif defined(__ICC)
     201             : #   define SWIGUNUSED __attribute__ ((__unused__))
     202             : # else
     203             : #   define SWIGUNUSED
     204             : # endif
     205             : #endif
     206             : 
     207             : #ifndef SWIG_MSC_UNSUPPRESS_4505
     208             : # if defined(_MSC_VER)
     209             : #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
     210             : # endif
     211             : #endif
     212             : 
     213             : #ifndef SWIGUNUSEDPARM
     214             : # ifdef __cplusplus
     215             : #   define SWIGUNUSEDPARM(p)
     216             : # else
     217             : #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
     218             : # endif
     219             : #endif
     220             : 
     221             : /* internal SWIG method */
     222             : #ifndef SWIGINTERN
     223             : # define SWIGINTERN static SWIGUNUSED
     224             : #endif
     225             : 
     226             : /* internal inline SWIG method */
     227             : #ifndef SWIGINTERNINLINE
     228             : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
     229             : #endif
     230             : 
     231             : /* exporting methods */
     232             : #if defined(__GNUC__)
     233             : #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
     234             : #    ifndef GCC_HASCLASSVISIBILITY
     235             : #      define GCC_HASCLASSVISIBILITY
     236             : #    endif
     237             : #  endif
     238             : #endif
     239             : 
     240             : #ifndef SWIGEXPORT
     241             : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
     242             : #   if defined(STATIC_LINKED)
     243             : #     define SWIGEXPORT
     244             : #   else
     245             : #     define SWIGEXPORT __declspec(dllexport)
     246             : #   endif
     247             : # else
     248             : #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
     249             : #     define SWIGEXPORT __attribute__ ((visibility("default")))
     250             : #   else
     251             : #     define SWIGEXPORT
     252             : #   endif
     253             : # endif
     254             : #endif
     255             : 
     256             : /* calling conventions for Windows */
     257             : #ifndef SWIGSTDCALL
     258             : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
     259             : #   define SWIGSTDCALL __stdcall
     260             : # else
     261             : #   define SWIGSTDCALL
     262             : # endif
     263             : #endif
     264             : 
     265             : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
     266             : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
     267             : # define _CRT_SECURE_NO_DEPRECATE
     268             : #endif
     269             : 
     270             : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
     271             : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
     272             : # define _SCL_SECURE_NO_DEPRECATE
     273             : #endif
     274             : 
     275             : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
     276             : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
     277             : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
     278             : #endif
     279             : 
     280             : /* Intel's compiler complains if a variable which was never initialised is
     281             :  * cast to void, which is a common idiom which we use to indicate that we
     282             :  * are aware a variable isn't used.  So we just silence that warning.
     283             :  * See: https://github.com/swig/swig/issues/192 for more discussion.
     284             :  */
     285             : #ifdef __INTEL_COMPILER
     286             : # pragma warning disable 592
     287             : #endif
     288             : 
     289             : /* -----------------------------------------------------------------------------
     290             :  * swigrun.swg
     291             :  *
     292             :  * This file contains generic C API SWIG runtime support for pointer
     293             :  * type checking.
     294             :  * ----------------------------------------------------------------------------- */
     295             : 
     296             : /* This should only be incremented when either the layout of swig_type_info changes,
     297             :    or for whatever reason, the runtime changes incompatibly */
     298             : #define SWIG_RUNTIME_VERSION "4"
     299             : 
     300             : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
     301             : #ifdef SWIG_TYPE_TABLE
     302             : # define SWIG_QUOTE_STRING(x) #x
     303             : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
     304             : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
     305             : #else
     306             : # define SWIG_TYPE_TABLE_NAME
     307             : #endif
     308             : 
     309             : /*
     310             :   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
     311             :   creating a static or dynamic library from the SWIG runtime code.
     312             :   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
     313             : 
     314             :   But only do this if strictly necessary, ie, if you have problems
     315             :   with your compiler or suchlike.
     316             : */
     317             : 
     318             : #ifndef SWIGRUNTIME
     319             : # define SWIGRUNTIME SWIGINTERN
     320             : #endif
     321             : 
     322             : #ifndef SWIGRUNTIMEINLINE
     323             : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
     324             : #endif
     325             : 
     326             : /*  Generic buffer size */
     327             : #ifndef SWIG_BUFFER_SIZE
     328             : # define SWIG_BUFFER_SIZE 1024
     329             : #endif
     330             : 
     331             : /* Flags for pointer conversions */
     332             : #define SWIG_POINTER_DISOWN        0x1
     333             : #define SWIG_CAST_NEW_MEMORY       0x2
     334             : 
     335             : /* Flags for new pointer objects */
     336             : #define SWIG_POINTER_OWN           0x1
     337             : 
     338             : 
     339             : /*
     340             :    Flags/methods for returning states.
     341             : 
     342             :    The SWIG conversion methods, as ConvertPtr, return an integer
     343             :    that tells if the conversion was successful or not. And if not,
     344             :    an error code can be returned (see swigerrors.swg for the codes).
     345             : 
     346             :    Use the following macros/flags to set or process the returning
     347             :    states.
     348             : 
     349             :    In old versions of SWIG, code such as the following was usually written:
     350             : 
     351             :      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
     352             :        // success code
     353             :      } else {
     354             :        //fail code
     355             :      }
     356             : 
     357             :    Now you can be more explicit:
     358             : 
     359             :     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
     360             :     if (SWIG_IsOK(res)) {
     361             :       // success code
     362             :     } else {
     363             :       // fail code
     364             :     }
     365             : 
     366             :    which is the same really, but now you can also do
     367             : 
     368             :     Type *ptr;
     369             :     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
     370             :     if (SWIG_IsOK(res)) {
     371             :       // success code
     372             :       if (SWIG_IsNewObj(res) {
     373             :         ...
     374             :         delete *ptr;
     375             :       } else {
     376             :         ...
     377             :       }
     378             :     } else {
     379             :       // fail code
     380             :     }
     381             : 
     382             :    I.e., now SWIG_ConvertPtr can return new objects and you can
     383             :    identify the case and take care of the deallocation. Of course that
     384             :    also requires SWIG_ConvertPtr to return new result values, such as
     385             : 
     386             :       int SWIG_ConvertPtr(obj, ptr,...) {
     387             :         if (<obj is ok>) {
     388             :           if (<need new object>) {
     389             :             *ptr = <ptr to new allocated object>;
     390             :             return SWIG_NEWOBJ;
     391             :           } else {
     392             :             *ptr = <ptr to old object>;
     393             :             return SWIG_OLDOBJ;
     394             :           }
     395             :         } else {
     396             :           return SWIG_BADOBJ;
     397             :         }
     398             :       }
     399             : 
     400             :    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
     401             :    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
     402             :    SWIG errors code.
     403             : 
     404             :    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
     405             :    allows to return the 'cast rank', for example, if you have this
     406             : 
     407             :        int food(double)
     408             :        int fooi(int);
     409             : 
     410             :    and you call
     411             : 
     412             :       food(1)   // cast rank '1'  (1 -> 1.0)
     413             :       fooi(1)   // cast rank '0'
     414             : 
     415             :    just use the SWIG_AddCast()/SWIG_CheckState()
     416             : */
     417             : 
     418             : #define SWIG_OK                    (0)
     419             : #define SWIG_ERROR                 (-1)
     420             : #define SWIG_IsOK(r)               (r >= 0)
     421             : #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
     422             : 
     423             : /* The CastRankLimit says how many bits are used for the cast rank */
     424             : #define SWIG_CASTRANKLIMIT         (1 << 8)
     425             : /* The NewMask denotes the object was created (using new/malloc) */
     426             : #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
     427             : /* The TmpMask is for in/out typemaps that use temporal objects */
     428             : #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
     429             : /* Simple returning values */
     430             : #define SWIG_BADOBJ                (SWIG_ERROR)
     431             : #define SWIG_OLDOBJ                (SWIG_OK)
     432             : #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
     433             : #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
     434             : /* Check, add and del mask methods */
     435             : #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
     436             : #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
     437             : #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
     438             : #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
     439             : #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
     440             : #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
     441             : 
     442             : /* Cast-Rank Mode */
     443             : #if defined(SWIG_CASTRANK_MODE)
     444             : #  ifndef SWIG_TypeRank
     445             : #    define SWIG_TypeRank             unsigned long
     446             : #  endif
     447             : #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
     448             : #    define SWIG_MAXCASTRANK          (2)
     449             : #  endif
     450             : #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
     451             : #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
     452             : SWIGINTERNINLINE int SWIG_AddCast(int r) {
     453             :   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
     454             : }
     455             : SWIGINTERNINLINE int SWIG_CheckState(int r) {
     456             :   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
     457             : }
     458             : #else /* no cast-rank mode */
     459             : #  define SWIG_AddCast(r) (r)
     460             : #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
     461             : #endif
     462             : 
     463             : 
     464             : #include <string.h>
     465             : 
     466             : #ifdef __cplusplus
     467             : extern "C" {
     468             : #endif
     469             : 
     470             : typedef void *(*swig_converter_func)(void *, int *);
     471             : typedef struct swig_type_info *(*swig_dycast_func)(void **);
     472             : 
     473             : /* Structure to store information on one type */
     474             : typedef struct swig_type_info {
     475             :   const char             *name;                 /* mangled name of this type */
     476             :   const char             *str;                  /* human readable name of this type */
     477             :   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
     478             :   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
     479             :   void                   *clientdata;           /* language specific type data */
     480             :   int                    owndata;               /* flag if the structure owns the clientdata */
     481             : } swig_type_info;
     482             : 
     483             : /* Structure to store a type and conversion function used for casting */
     484             : typedef struct swig_cast_info {
     485             :   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
     486             :   swig_converter_func     converter;            /* function to cast the void pointers */
     487             :   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
     488             :   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
     489             : } swig_cast_info;
     490             : 
     491             : /* Structure used to store module information
     492             :  * Each module generates one structure like this, and the runtime collects
     493             :  * all of these structures and stores them in a circularly linked list.*/
     494             : typedef struct swig_module_info {
     495             :   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
     496             :   size_t                 size;                  /* Number of types in this module */
     497             :   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
     498             :   swig_type_info         **type_initial;        /* Array of initially generated type structures */
     499             :   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
     500             :   void                    *clientdata;          /* Language specific module data */
     501             : } swig_module_info;
     502             : 
     503             : /*
     504             :   Compare two type names skipping the space characters, therefore
     505             :   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
     506             : 
     507             :   Return 0 when the two name types are equivalent, as in
     508             :   strncmp, but skipping ' '.
     509             : */
     510             : SWIGRUNTIME int
     511         425 : SWIG_TypeNameComp(const char *f1, const char *l1,
     512             :                   const char *f2, const char *l2) {
     513        5197 :   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
     514        2841 :     while ((*f1 == ' ') && (f1 != l1)) ++f1;
     515        2838 :     while ((*f2 == ' ') && (f2 != l2)) ++f2;
     516        2806 :     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
     517             :   }
     518           5 :   return (int)((l1 - f1) - (l2 - f2));
     519             : }
     520             : 
     521             : /*
     522             :   Check type equivalence in a name list like <name1>|<name2>|...
     523             :   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
     524             : */
     525             : SWIGRUNTIME int
     526         340 : SWIG_TypeCmp(const char *nb, const char *tb) {
     527         340 :   int equiv = 1;
     528         340 :   const char* te = tb + strlen(tb);
     529         340 :   const char* ne = nb;
     530         765 :   while (equiv != 0 && *ne) {
     531       23805 :     for (nb = ne; *ne; ++ne) {
     532       11779 :       if (*ne == '|') break;
     533             :     }
     534         425 :     equiv = SWIG_TypeNameComp(nb, ne, tb, te);
     535         425 :     if (*ne) ++ne;
     536             :   }
     537         340 :   return equiv;
     538             : }
     539             : 
     540             : /*
     541             :   Check type equivalence in a name list like <name1>|<name2>|...
     542             :   Return 0 if not equal, 1 if equal
     543             : */
     544             : SWIGRUNTIME int
     545             : SWIG_TypeEquiv(const char *nb, const char *tb) {
     546         340 :   return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
     547             : }
     548             : 
     549             : /*
     550             :   Check the typename
     551             : */
     552             : SWIGRUNTIME swig_cast_info *
     553          61 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
     554          61 :   if (ty) {
     555          61 :     swig_cast_info *iter = ty->cast;
     556          71 :     while (iter) {
     557          66 :       if (strcmp(iter->type->name, c) == 0) {
     558          61 :         if (iter == ty->cast)
     559             :           return iter;
     560             :         /* Move iter to the top of the linked list */
     561           2 :         iter->prev->next = iter->next;
     562           2 :         if (iter->next)
     563           1 :           iter->next->prev = iter->prev;
     564           2 :         iter->next = ty->cast;
     565           2 :         iter->prev = 0;
     566           2 :         if (ty->cast) ty->cast->prev = iter;
     567           2 :         ty->cast = iter;
     568           2 :         return iter;
     569             :       }
     570           5 :       iter = iter->next;
     571             :     }
     572             :   }
     573             :   return 0;
     574             : }
     575             : 
     576             : /*
     577             :   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
     578             : */
     579             : SWIGRUNTIME swig_cast_info *
     580             : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
     581             :   if (ty) {
     582             :     swig_cast_info *iter = ty->cast;
     583             :     while (iter) {
     584             :       if (iter->type == from) {
     585             :         if (iter == ty->cast)
     586             :           return iter;
     587             :         /* Move iter to the top of the linked list */
     588             :         iter->prev->next = iter->next;
     589             :         if (iter->next)
     590             :           iter->next->prev = iter->prev;
     591             :         iter->next = ty->cast;
     592             :         iter->prev = 0;
     593             :         if (ty->cast) ty->cast->prev = iter;
     594             :         ty->cast = iter;
     595             :         return iter;
     596             :       }
     597             :       iter = iter->next;
     598             :     }
     599             :   }
     600             :   return 0;
     601             : }
     602             : 
     603             : /*
     604             :   Cast a pointer up an inheritance hierarchy
     605             : */
     606             : SWIGRUNTIMEINLINE void *
     607             : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
     608           6 :   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
     609             : }
     610             : 
     611             : /*
     612             :    Dynamic pointer casting. Down an inheritance hierarchy
     613             : */
     614             : SWIGRUNTIME swig_type_info *
     615             : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
     616             :   swig_type_info *lastty = ty;
     617             :   if (!ty || !ty->dcast) return ty;
     618             :   while (ty && (ty->dcast)) {
     619             :     ty = (*ty->dcast)(ptr);
     620             :     if (ty) lastty = ty;
     621             :   }
     622             :   return lastty;
     623             : }
     624             : 
     625             : /*
     626             :   Return the name associated with this type
     627             : */
     628             : SWIGRUNTIMEINLINE const char *
     629             : SWIG_TypeName(const swig_type_info *ty) {
     630             :   return ty->name;
     631             : }
     632             : 
     633             : /*
     634             :   Return the pretty name associated with this type,
     635             :   that is an unmangled type name in a form presentable to the user.
     636             : */
     637             : SWIGRUNTIME const char *
     638             : SWIG_TypePrettyName(const swig_type_info *type) {
     639             :   /* The "str" field contains the equivalent pretty names of the
     640             :      type, separated by vertical-bar characters.  We choose
     641             :      to print the last name, as it is often (?) the most
     642             :      specific. */
     643             :   if (!type) return NULL;
     644             :   if (type->str != NULL) {
     645             :     const char *last_name = type->str;
     646             :     const char *s;
     647             :     for (s = type->str; *s; s++)
     648             :       if (*s == '|') last_name = s+1;
     649             :     return last_name;
     650             :   }
     651             :   else
     652             :     return type->name;
     653             : }
     654             : 
     655             : /*
     656             :    Set the clientdata field for a type
     657             : */
     658             : SWIGRUNTIME void
     659         402 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
     660         402 :   swig_cast_info *cast = ti->cast;
     661             :   /* if (ti->clientdata == clientdata) return; */
     662         402 :   ti->clientdata = clientdata;
     663             : 
     664        1308 :   while (cast) {
     665         906 :     if (!cast->converter) {
     666         402 :       swig_type_info *tc = cast->type;
     667         402 :       if (!tc->clientdata) {
     668           0 :         SWIG_TypeClientData(tc, clientdata);
     669             :       }
     670             :     }
     671         906 :     cast = cast->next;
     672             :   }
     673         402 : }
     674             : SWIGRUNTIME void
     675             : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
     676             :   SWIG_TypeClientData(ti, clientdata);
     677             :   ti->owndata = 1;
     678             : }
     679             : 
     680             : /*
     681             :   Search for a swig_type_info structure only by mangled name
     682             :   Search is a O(log #types)
     683             : 
     684             :   We start searching at module start, and finish searching when start == end.
     685             :   Note: if start == end at the beginning of the function, we go all the way around
     686             :   the circular list.
     687             : */
     688             : SWIGRUNTIME swig_type_info *
     689           5 : SWIG_MangledTypeQueryModule(swig_module_info *start,
     690             :                             swig_module_info *end,
     691             :                             const char *name) {
     692           5 :   swig_module_info *iter = start;
     693             :   do {
     694          10 :     if (iter->size) {
     695          10 :       size_t l = 0;
     696          10 :       size_t r = iter->size - 1;
     697             :       do {
     698             :         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
     699          60 :         size_t i = (l + r) >> 1;
     700          60 :         const char *iname = iter->types[i]->name;
     701          60 :         if (iname) {
     702          60 :           int compare = strcmp(name, iname);
     703          60 :           if (compare == 0) {
     704             :             return iter->types[i];
     705          60 :           } else if (compare < 0) {
     706           0 :             if (i) {
     707           0 :               r = i - 1;
     708             :             } else {
     709             :               break;
     710             :             }
     711          60 :           } else if (compare > 0) {
     712          60 :             l = i + 1;
     713             :           }
     714             :         } else {
     715             :           break; /* should never happen */
     716             :         }
     717          60 :       } while (l <= r);
     718             :     }
     719          10 :     iter = iter->next;
     720          10 :   } while (iter != end);
     721             :   return 0;
     722             : }
     723             : 
     724             : /*
     725             :   Search for a swig_type_info structure for either a mangled name or a human readable name.
     726             :   It first searches the mangled names of the types, which is a O(log #types)
     727             :   If a type is not found it then searches the human readable names, which is O(#types).
     728             : 
     729             :   We start searching at module start, and finish searching when start == end.
     730             :   Note: if start == end at the beginning of the function, we go all the way around
     731             :   the circular list.
     732             : */
     733             : SWIGRUNTIME swig_type_info *
     734           5 : SWIG_TypeQueryModule(swig_module_info *start,
     735             :                      swig_module_info *end,
     736             :                      const char *name) {
     737             :   /* STEP 1: Search the name field using binary search */
     738           5 :   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
     739           5 :   if (ret) {
     740             :     return ret;
     741             :   } else {
     742             :     /* STEP 2: If the type hasn't been found, do a complete search
     743             :        of the str field (the human readable name) */
     744             :     swig_module_info *iter = start;
     745             :     do {
     746           5 :       size_t i = 0;
     747         675 :       for (; i < iter->size; ++i) {
     748         680 :         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
     749             :           return iter->types[i];
     750             :       }
     751           0 :       iter = iter->next;
     752           0 :     } while (iter != end);
     753             :   }
     754             : 
     755             :   /* neither found a match */
     756             :   return 0;
     757             : }
     758             : 
     759             : /*
     760             :    Pack binary data into a string
     761             : */
     762             : SWIGRUNTIME char *
     763             : SWIG_PackData(char *c, void *ptr, size_t sz) {
     764             :   static const char hex[17] = "0123456789abcdef";
     765             :   const unsigned char *u = (unsigned char *) ptr;
     766             :   const unsigned char *eu =  u + sz;
     767             :   for (; u != eu; ++u) {
     768             :     unsigned char uu = *u;
     769             :     *(c++) = hex[(uu & 0xf0) >> 4];
     770             :     *(c++) = hex[uu & 0xf];
     771             :   }
     772             :   return c;
     773             : }
     774             : 
     775             : /*
     776             :    Unpack binary data from a string
     777             : */
     778             : SWIGRUNTIME const char *
     779             : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
     780             :   unsigned char *u = (unsigned char *) ptr;
     781             :   const unsigned char *eu = u + sz;
     782             :   for (; u != eu; ++u) {
     783             :     char d = *(c++);
     784             :     unsigned char uu;
     785             :     if ((d >= '0') && (d <= '9'))
     786             :       uu = (unsigned char)((d - '0') << 4);
     787             :     else if ((d >= 'a') && (d <= 'f'))
     788             :       uu = (unsigned char)((d - ('a'-10)) << 4);
     789             :     else
     790             :       return (char *) 0;
     791             :     d = *(c++);
     792             :     if ((d >= '0') && (d <= '9'))
     793             :       uu |= (unsigned char)(d - '0');
     794             :     else if ((d >= 'a') && (d <= 'f'))
     795             :       uu |= (unsigned char)(d - ('a'-10));
     796             :     else
     797             :       return (char *) 0;
     798             :     *u = uu;
     799             :   }
     800             :   return c;
     801             : }
     802             : 
     803             : /*
     804             :    Pack 'void *' into a string buffer.
     805             : */
     806             : SWIGRUNTIME char *
     807             : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
     808             :   char *r = buff;
     809             :   if ((2*sizeof(void *) + 2) > bsz) return 0;
     810             :   *(r++) = '_';
     811             :   r = SWIG_PackData(r,&ptr,sizeof(void *));
     812             :   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
     813             :   strcpy(r,name);
     814             :   return buff;
     815             : }
     816             : 
     817             : SWIGRUNTIME const char *
     818             : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
     819             :   if (*c != '_') {
     820             :     if (strcmp(c,"NULL") == 0) {
     821             :       *ptr = (void *) 0;
     822             :       return name;
     823             :     } else {
     824             :       return 0;
     825             :     }
     826             :   }
     827             :   return SWIG_UnpackData(++c,ptr,sizeof(void *));
     828             : }
     829             : 
     830             : SWIGRUNTIME char *
     831             : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
     832             :   char *r = buff;
     833             :   size_t lname = (name ? strlen(name) : 0);
     834             :   if ((2*sz + 2 + lname) > bsz) return 0;
     835             :   *(r++) = '_';
     836             :   r = SWIG_PackData(r,ptr,sz);
     837             :   if (lname) {
     838             :     strncpy(r,name,lname+1);
     839             :   } else {
     840             :     *r = 0;
     841             :   }
     842             :   return buff;
     843             : }
     844             : 
     845             : SWIGRUNTIME const char *
     846             : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
     847             :   if (*c != '_') {
     848             :     if (strcmp(c,"NULL") == 0) {
     849             :       memset(ptr,0,sz);
     850             :       return name;
     851             :     } else {
     852             :       return 0;
     853             :     }
     854             :   }
     855             :   return SWIG_UnpackData(++c,ptr,sz);
     856             : }
     857             : 
     858             : #ifdef __cplusplus
     859             : }
     860             : #endif
     861             : 
     862             : /*  Errors in SWIG */
     863             : #define  SWIG_UnknownError         -1
     864             : #define  SWIG_IOError              -2
     865             : #define  SWIG_RuntimeError         -3
     866             : #define  SWIG_IndexError           -4
     867             : #define  SWIG_TypeError            -5
     868             : #define  SWIG_DivisionByZero       -6
     869             : #define  SWIG_OverflowError        -7
     870             : #define  SWIG_SyntaxError          -8
     871             : #define  SWIG_ValueError           -9
     872             : #define  SWIG_SystemError          -10
     873             : #define  SWIG_AttributeError       -11
     874             : #define  SWIG_MemoryError          -12
     875             : #define  SWIG_NullReferenceError   -13
     876             : 
     877             : 
     878             : 
     879             : #include <ruby.h>
     880             : 
     881             : /* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
     882             :  * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
     883             :  * issue for now by disabling this.
     884             :  * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
     885             :  */
     886             : #ifdef rb_intern
     887             : # undef rb_intern
     888             : #endif
     889             : 
     890             : /* Remove global macros defined in Ruby's win32.h */
     891             : #ifdef write
     892             : # undef write
     893             : #endif
     894             : #ifdef read
     895             : # undef read
     896             : #endif
     897             : #ifdef bind
     898             : # undef bind
     899             : #endif
     900             : #ifdef close
     901             : # undef close
     902             : #endif
     903             : #ifdef connect
     904             : # undef connect
     905             : #endif
     906             : 
     907             : 
     908             : /* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
     909             : #ifndef NUM2LL
     910             : #define NUM2LL(x) NUM2LONG((x))
     911             : #endif
     912             : #ifndef LL2NUM
     913             : #define LL2NUM(x) INT2NUM((long) (x))
     914             : #endif
     915             : #ifndef ULL2NUM
     916             : #define ULL2NUM(x) UINT2NUM((unsigned long) (x))
     917             : #endif
     918             : 
     919             : /* Ruby 1.7 doesn't (yet) define NUM2ULL() */
     920             : #ifndef NUM2ULL
     921             : #ifdef HAVE_LONG_LONG
     922             : #define NUM2ULL(x) rb_num2ull((x))
     923             : #else
     924             : #define NUM2ULL(x) NUM2ULONG(x)
     925             : #endif
     926             : #endif
     927             : 
     928             : /* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
     929             : /* Define these for older versions so we can just write code the new way */
     930             : #ifndef RSTRING_LEN
     931             : # define RSTRING_LEN(x) RSTRING(x)->len
     932             : #endif
     933             : #ifndef RSTRING_PTR
     934             : # define RSTRING_PTR(x) RSTRING(x)->ptr
     935             : #endif
     936             : #ifndef RSTRING_END
     937             : # define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
     938             : #endif
     939             : #ifndef RARRAY_LEN
     940             : # define RARRAY_LEN(x) RARRAY(x)->len
     941             : #endif
     942             : #ifndef RARRAY_PTR
     943             : # define RARRAY_PTR(x) RARRAY(x)->ptr
     944             : #endif
     945             : #ifndef RFLOAT_VALUE
     946             : # define RFLOAT_VALUE(x) RFLOAT(x)->value
     947             : #endif
     948             : #ifndef DOUBLE2NUM
     949             : # define DOUBLE2NUM(x) rb_float_new(x)
     950             : #endif
     951             : #ifndef RHASH_TBL
     952             : # define RHASH_TBL(x) (RHASH(x)->tbl)
     953             : #endif
     954             : #ifndef RHASH_ITER_LEV
     955             : # define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
     956             : #endif
     957             : #ifndef RHASH_IFNONE
     958             : # define RHASH_IFNONE(x) (RHASH(x)->ifnone)
     959             : #endif
     960             : #ifndef RHASH_SIZE
     961             : # define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
     962             : #endif
     963             : #ifndef RHASH_EMPTY_P
     964             : # define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
     965             : #endif
     966             : #ifndef RSTRUCT_LEN
     967             : # define RSTRUCT_LEN(x) RSTRUCT(x)->len
     968             : #endif
     969             : #ifndef RSTRUCT_PTR
     970             : # define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
     971             : #endif
     972             : 
     973             : 
     974             : 
     975             : /*
     976             :  * Need to be very careful about how these macros are defined, especially
     977             :  * when compiling C++ code or C code with an ANSI C compiler.
     978             :  *
     979             :  * VALUEFUNC(f) is a macro used to typecast a C function that implements
     980             :  * a Ruby method so that it can be passed as an argument to API functions
     981             :  * like rb_define_method() and rb_define_singleton_method().
     982             :  *
     983             :  * VOIDFUNC(f) is a macro used to typecast a C function that implements
     984             :  * either the "mark" or "free" stuff for a Ruby Data object, so that it
     985             :  * can be passed as an argument to API functions like Data_Wrap_Struct()
     986             :  * and Data_Make_Struct().
     987             :  */
     988             :  
     989             : #ifdef __cplusplus
     990             : #  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
     991             : #    define PROTECTFUNC(f) ((VALUE (*)()) f)
     992             : #    define VALUEFUNC(f) ((VALUE (*)()) f)
     993             : #    define VOIDFUNC(f)  ((void (*)()) f)
     994             : #  else
     995             : #    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
     996             : #      define PROTECTFUNC(f) ((VALUE (*)()) f)
     997             : #      define VALUEFUNC(f) ((VALUE (*)()) f)
     998             : #      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
     999             : #    else /* These definitions should work for Ruby 1.7+ */
    1000             : #      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
    1001             : #      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
    1002             : #      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
    1003             : #    endif
    1004             : #  endif
    1005             : #else
    1006             : #  define VALUEFUNC(f) (f)
    1007             : #  define VOIDFUNC(f) (f)
    1008             : #endif
    1009             : 
    1010             : /* Don't use for expressions have side effect */
    1011             : #ifndef RB_STRING_VALUE
    1012             : #define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
    1013             : #endif
    1014             : #ifndef StringValue
    1015             : #define StringValue(s) RB_STRING_VALUE(s)
    1016             : #endif
    1017             : #ifndef StringValuePtr
    1018             : #define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
    1019             : #endif
    1020             : #ifndef StringValueLen
    1021             : #define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
    1022             : #endif
    1023             : #ifndef SafeStringValue
    1024             : #define SafeStringValue(v) do {\
    1025             :     StringValue(v);\
    1026             :     rb_check_safe_str(v);\
    1027             : } while (0)
    1028             : #endif
    1029             : 
    1030             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    1031             : #define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
    1032             : #define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
    1033             : #endif
    1034             : 
    1035             : static VALUE _mSWIG = Qnil;
    1036             : 
    1037             : /* -----------------------------------------------------------------------------
    1038             :  * error manipulation
    1039             :  * ----------------------------------------------------------------------------- */
    1040             : 
    1041             : 
    1042             : /* Define some additional error types */
    1043             : #define SWIG_ObjectPreviouslyDeletedError  -100
    1044             : 
    1045             : 
    1046             : /* Define custom exceptions for errors that do not map to existing Ruby
    1047             :    exceptions.  Note this only works for C++ since a global cannot be
    1048             :    initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
    1049             : 
    1050             : SWIGINTERN VALUE 
    1051           0 : getNullReferenceError(void) {
    1052             :   static int init = 0;
    1053             :   static VALUE rb_eNullReferenceError ;
    1054           0 :   if (!init) {
    1055           0 :     init = 1;
    1056           0 :     rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
    1057             :   }
    1058           0 :   return rb_eNullReferenceError;
    1059             : } 
    1060             : 
    1061             : SWIGINTERN VALUE 
    1062           0 : getObjectPreviouslyDeletedError(void) {
    1063             :   static int init = 0;
    1064             :   static VALUE rb_eObjectPreviouslyDeleted ;
    1065           0 :   if (!init) {
    1066           0 :     init = 1;
    1067           0 :     rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
    1068             :   }
    1069           0 :   return rb_eObjectPreviouslyDeleted;
    1070             : } 
    1071             : 
    1072             : 
    1073             : SWIGINTERN VALUE
    1074           0 : SWIG_Ruby_ErrorType(int SWIG_code) {
    1075             :   VALUE type;
    1076           0 :   switch (SWIG_code) {
    1077             :   case SWIG_MemoryError:
    1078           0 :     type = rb_eNoMemError;
    1079           0 :     break;
    1080             :   case SWIG_IOError:
    1081           0 :     type = rb_eIOError;
    1082           0 :     break;
    1083             :   case SWIG_RuntimeError:
    1084           0 :     type = rb_eRuntimeError;
    1085           0 :     break;
    1086             :   case SWIG_IndexError:
    1087           0 :     type = rb_eIndexError;
    1088           0 :     break;
    1089             :   case SWIG_TypeError:
    1090           0 :     type = rb_eTypeError;
    1091           0 :     break;
    1092             :   case SWIG_DivisionByZero:
    1093           0 :     type = rb_eZeroDivError;
    1094           0 :     break;
    1095             :   case SWIG_OverflowError:
    1096           0 :     type = rb_eRangeError;
    1097           0 :     break;
    1098             :   case SWIG_SyntaxError:
    1099           0 :     type = rb_eSyntaxError;
    1100           0 :     break;
    1101             :   case SWIG_ValueError:
    1102           0 :     type = rb_eArgError;
    1103           0 :     break;
    1104             :   case SWIG_SystemError:
    1105           0 :     type = rb_eFatal;
    1106           0 :     break;
    1107             :   case SWIG_AttributeError:
    1108           0 :     type = rb_eRuntimeError;
    1109           0 :     break;
    1110             :   case SWIG_NullReferenceError:
    1111           0 :     type = getNullReferenceError();
    1112           0 :     break;
    1113             :   case SWIG_ObjectPreviouslyDeletedError:
    1114           0 :     type = getObjectPreviouslyDeletedError();
    1115           0 :     break;
    1116             :   case SWIG_UnknownError:
    1117           0 :     type = rb_eRuntimeError;
    1118           0 :     break;
    1119             :   default:
    1120           0 :     type = rb_eRuntimeError;
    1121             :   }
    1122           0 :   return type;
    1123             : }
    1124             : 
    1125             : 
    1126             : /* This function is called when a user inputs a wrong argument to
    1127             :    a method.
    1128             :  */
    1129             : SWIGINTERN 
    1130           0 : const char* Ruby_Format_TypeError( const char* msg,
    1131             :                                    const char* type, 
    1132             :                                    const char* name, 
    1133             :                                    const int argn,
    1134             :                                    VALUE input )
    1135             : {
    1136             :   char buf[128];
    1137             :   VALUE str;
    1138             :   VALUE asStr;
    1139           0 :   if ( msg && *msg )
    1140             :     {
    1141           0 :       str = rb_str_new2(msg);
    1142             :     }
    1143             :   else
    1144             :     {
    1145           0 :       str = rb_str_new(NULL, 0);
    1146             :     }
    1147             : 
    1148           0 :   str = rb_str_cat2( str, "Expected argument " );
    1149           0 :   sprintf( buf, "%d of type ", argn-1 );
    1150           0 :   str = rb_str_cat2( str, buf );
    1151           0 :   str = rb_str_cat2( str, type );
    1152           0 :   str = rb_str_cat2( str, ", but got " );
    1153           0 :   str = rb_str_cat2( str, rb_obj_classname(input) );
    1154           0 :   str = rb_str_cat2( str, " " );
    1155           0 :   asStr = rb_inspect(input);
    1156           0 :   if ( RSTRING_LEN(asStr) > 30 )
    1157             :     {
    1158           0 :       str = rb_str_cat( str, StringValuePtr(asStr), 30 );
    1159           0 :       str = rb_str_cat2( str, "..." );
    1160             :     }
    1161             :   else
    1162             :     {
    1163           0 :       str = rb_str_append( str, asStr );
    1164             :     }
    1165             : 
    1166           0 :   if ( name )
    1167             :     {
    1168           0 :       str = rb_str_cat2( str, "\n\tin SWIG method '" );
    1169           0 :       str = rb_str_cat2( str, name );
    1170           0 :       str = rb_str_cat2( str, "'" );
    1171             :     }
    1172             : 
    1173           0 :   return StringValuePtr( str );
    1174             : }
    1175             : 
    1176             : /* This function is called when an overloaded method fails */
    1177             : SWIGINTERN 
    1178           0 : void Ruby_Format_OverloadedError(
    1179             :                                  const int argc,
    1180             :                                  const int maxargs,
    1181             :                                  const char* method, 
    1182             :                                  const char* prototypes 
    1183             :                                  )
    1184             : {
    1185           0 :   const char* msg = "Wrong # of arguments";
    1186           0 :   if ( argc <= maxargs ) msg = "Wrong arguments";
    1187             :   rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
    1188             :            "Possible C/C++ prototypes are:\n%s",
    1189           0 :            msg, method, prototypes);
    1190             : }
    1191             : 
    1192             : /* -----------------------------------------------------------------------------
    1193             :  * rubytracking.swg
    1194             :  *
    1195             :  * This file contains support for tracking mappings from 
    1196             :  * Ruby objects to C++ objects.  This functionality is needed
    1197             :  * to implement mark functions for Ruby's mark and sweep
    1198             :  * garbage collector.
    1199             :  * ----------------------------------------------------------------------------- */
    1200             : 
    1201             : #ifdef __cplusplus
    1202             : extern "C" {
    1203             : #endif
    1204             : 
    1205             : #if !defined(ST_DATA_T_DEFINED)
    1206             : /* Needs to be explicitly included for Ruby 1.8 and earlier */
    1207             : #include <st.h>
    1208             : #endif
    1209             : 
    1210             : /* Ruby 1.8 actually assumes the first case. */
    1211             : #if SIZEOF_VOIDP == SIZEOF_LONG
    1212             : #  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
    1213             : #  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
    1214             : #elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
    1215             : #  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
    1216             : #  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
    1217             : #else
    1218             : #  error sizeof(void*) is not the same as long or long long
    1219             : #endif
    1220             : 
    1221             : /* Global hash table to store Trackings from C/C++
    1222             :    structs to Ruby Objects. 
    1223             : */
    1224             : static st_table* swig_ruby_trackings = NULL;
    1225             : 
    1226           0 : static VALUE swig_ruby_trackings_count(ANYARGS) {
    1227           0 :   return SWIG2NUM(swig_ruby_trackings->num_entries);
    1228             : }
    1229             : 
    1230             : 
    1231             : /* Setup a hash table to store Trackings */
    1232           6 : SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
    1233             :   /* Create a hash table to store Trackings from C++
    1234             :      objects to Ruby objects. */
    1235             : 
    1236             :   /* Try to see if some other .so has already created a 
    1237             :      tracking hash table, which we keep hidden in an instance var
    1238             :      in the SWIG module.
    1239             :      This is done to allow multiple DSOs to share the same
    1240             :      tracking table.
    1241             :   */
    1242           6 :   VALUE trackings_value = Qnil;
    1243             :   /* change the variable name so that we can mix modules
    1244             :      compiled with older SWIG's - this used to be called "@__trackings__" */
    1245           6 :   ID trackings_id = rb_intern( "@__safetrackings__" );
    1246           6 :   VALUE verbose = rb_gv_get("VERBOSE");
    1247           6 :   rb_gv_set("VERBOSE", Qfalse);
    1248           6 :   trackings_value = rb_ivar_get( _mSWIG, trackings_id );
    1249           6 :   rb_gv_set("VERBOSE", verbose);
    1250             : 
    1251             :   /* The trick here is that we have to store the hash table
    1252             :   pointer in a Ruby variable. We do not want Ruby's GC to
    1253             :   treat this pointer as a Ruby object, so we convert it to
    1254             :   a Ruby numeric value. */
    1255           6 :   if (trackings_value == Qnil) {
    1256             :     /* No, it hasn't.  Create one ourselves */
    1257           6 :     swig_ruby_trackings = st_init_numtable();
    1258          12 :     rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
    1259             :   } else {
    1260           0 :     swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
    1261             :   }
    1262             : 
    1263           6 :   rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", swig_ruby_trackings_count, NULL);
    1264           6 : }
    1265             : 
    1266             : /* Add a Tracking from a C/C++ struct to a Ruby object */
    1267             : SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
    1268             :   /* Store the mapping to the global hash table. */
    1269           0 :   st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
    1270             : }
    1271             : 
    1272             : /* Get the Ruby object that owns the specified C/C++ struct */
    1273             : SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
    1274             :   /* Now lookup the value stored in the global hash table */
    1275             :   VALUE value;
    1276             : 
    1277           0 :   if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
    1278           0 :     return value;
    1279             :   } else {
    1280             :     return Qnil;
    1281             :   }
    1282             : }
    1283             : 
    1284             : /* Remove a Tracking from a C/C++ struct to a Ruby object.  It
    1285             :    is very important to remove objects once they are destroyed
    1286             :    since the same memory address may be reused later to create
    1287             :    a new object. */
    1288           0 : SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
    1289             :   /* Delete the object from the hash table */
    1290           0 :   st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
    1291           0 : }
    1292             : 
    1293             : /* This is a helper method that unlinks a Ruby object from its
    1294             :    underlying C++ object.  This is needed if the lifetime of the
    1295             :    Ruby object is longer than the C++ object */
    1296             : SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
    1297             :   VALUE object = SWIG_RubyInstanceFor(ptr);
    1298             : 
    1299             :   if (object != Qnil) {
    1300             :     if (TYPE(object) != T_DATA)
    1301             :       abort();
    1302             :     DATA_PTR(object) = 0;
    1303             :   }
    1304             : }
    1305             : 
    1306             : /* This is a helper method that iterates over all the trackings
    1307             :    passing the C++ object pointer and its related Ruby object
    1308             :    to the passed callback function. */
    1309             : 
    1310             : /* Proxy method to abstract the internal trackings datatype */
    1311             : static int swig_ruby_internal_iterate_callback(void* ptr, VALUE obj, void(*meth)(void* ptr, VALUE obj)) {
    1312             :   (*meth)(ptr, obj);
    1313             :   return ST_CONTINUE;
    1314             : }
    1315             : 
    1316             : SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
    1317             :   st_foreach(swig_ruby_trackings, (int (*)(ANYARGS))&swig_ruby_internal_iterate_callback, (st_data_t)meth);
    1318             : }
    1319             : 
    1320             : #ifdef __cplusplus
    1321             : }
    1322             : #endif
    1323             : 
    1324             : /* -----------------------------------------------------------------------------
    1325             :  * Ruby API portion that goes into the runtime
    1326             :  * ----------------------------------------------------------------------------- */
    1327             : 
    1328             : #ifdef __cplusplus
    1329             : extern "C" {
    1330             : #endif
    1331             : 
    1332             : SWIGINTERN VALUE
    1333             : SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
    1334             :   if (NIL_P(target)) {
    1335             :     target = o;
    1336             :   } else {
    1337             :     if (TYPE(target) != T_ARRAY) {
    1338             :       VALUE o2 = target;
    1339             :       target = rb_ary_new();
    1340             :       rb_ary_push(target, o2);
    1341             :     }
    1342             :     rb_ary_push(target, o);
    1343             :   }
    1344             :   return target;
    1345             : }
    1346             : 
    1347             : /* For ruby1.8.4 and earlier. */
    1348             : #ifndef RUBY_INIT_STACK
    1349             :    RUBY_EXTERN void Init_stack(VALUE* addr);
    1350             : #  define RUBY_INIT_STACK \
    1351             :    VALUE variable_in_this_stack_frame; \
    1352             :    Init_stack(&variable_in_this_stack_frame);
    1353             : #endif
    1354             : 
    1355             : 
    1356             : #ifdef __cplusplus
    1357             : }
    1358             : #endif
    1359             : 
    1360             : 
    1361             : /* -----------------------------------------------------------------------------
    1362             :  * rubyrun.swg
    1363             :  *
    1364             :  * This file contains the runtime support for Ruby modules
    1365             :  * and includes code for managing global variables and pointer
    1366             :  * type checking.
    1367             :  * ----------------------------------------------------------------------------- */
    1368             : 
    1369             : /* For backward compatibility only */
    1370             : #define SWIG_POINTER_EXCEPTION  0
    1371             : 
    1372             : /* for raw pointers */
    1373             : #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
    1374             : #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
    1375             : #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
    1376             : #define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
    1377             : #define swig_owntype                                    swig_ruby_owntype
    1378             : 
    1379             : /* for raw packed data */
    1380             : #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
    1381             : #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
    1382             : 
    1383             : /* for class or struct pointers */
    1384             : #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
    1385             : #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
    1386             : 
    1387             : /* for C or C++ function pointers */
    1388             : #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
    1389             : #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
    1390             : 
    1391             : /* for C++ member pointers, ie, member methods */
    1392             : #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
    1393             : #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
    1394             : 
    1395             : 
    1396             : /* Runtime API */
    1397             : 
    1398             : #define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
    1399             : #define SWIG_SetModule(clientdata, pointer)             SWIG_Ruby_SetModule(pointer)
    1400             : 
    1401             : 
    1402             : /* Error manipulation */
    1403             : 
    1404             : #define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
    1405             : #define SWIG_Error(code, msg)                           rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
    1406             : #define SWIG_fail                                       goto fail                                
    1407             : 
    1408             : 
    1409             : /* Ruby-specific SWIG API */
    1410             : 
    1411             : #define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
    1412             : #define SWIG_define_class(ty)                           SWIG_Ruby_define_class(ty)
    1413             : #define SWIG_NewClassInstance(value, ty)                SWIG_Ruby_NewClassInstance(value, ty)
    1414             : #define SWIG_MangleStr(value)                           SWIG_Ruby_MangleStr(value)                
    1415             : #define SWIG_CheckConvert(value, ty)                    SWIG_Ruby_CheckConvert(value, ty)         
    1416             : 
    1417             : #include "assert.h"
    1418             : 
    1419             : /* -----------------------------------------------------------------------------
    1420             :  * pointers/data manipulation
    1421             :  * ----------------------------------------------------------------------------- */
    1422             : 
    1423             : #ifdef __cplusplus
    1424             : extern "C" {
    1425             : #endif
    1426             : 
    1427             : typedef struct {
    1428             :   VALUE klass;
    1429             :   VALUE mImpl;
    1430             :   void  (*mark)(void *);
    1431             :   void  (*destroy)(void *);
    1432             :   int trackObjects;
    1433             : } swig_class;
    1434             : 
    1435             : 
    1436             : /* Global pointer used to keep some internal SWIG stuff */
    1437             : static VALUE _cSWIG_Pointer = Qnil;
    1438             : static VALUE swig_runtime_data_type_pointer = Qnil;
    1439             : 
    1440             : /* Global IDs used to keep some internal SWIG stuff */
    1441             : static ID swig_arity_id = 0;
    1442             : static ID swig_call_id  = 0;
    1443             : 
    1444             : /*
    1445             :   If your swig extension is to be run within an embedded ruby and has
    1446             :   director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
    1447             :   This will reset ruby's stack frame on each entry point from the main 
    1448             :   program the first time a virtual director function is invoked (in a 
    1449             :   non-recursive way).
    1450             :   If this is not done, you run the risk of Ruby trashing the stack.
    1451             : */
    1452             : 
    1453             : #ifdef RUBY_EMBEDDED
    1454             : 
    1455             : #  define SWIG_INIT_STACK                            \
    1456             :       if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
    1457             :       ++swig_virtual_calls;
    1458             : #  define SWIG_RELEASE_STACK --swig_virtual_calls;
    1459             : #  define Ruby_DirectorTypeMismatchException(x) \
    1460             :           rb_raise( rb_eTypeError, "%s", x ); return c_result;
    1461             : 
    1462             :       static unsigned int swig_virtual_calls = 0;
    1463             : 
    1464             : #else  /* normal non-embedded extension */
    1465             : 
    1466             : #  define SWIG_INIT_STACK
    1467             : #  define SWIG_RELEASE_STACK
    1468             : #  define Ruby_DirectorTypeMismatchException(x) \
    1469             :           throw Swig::DirectorTypeMismatchException( x );
    1470             : 
    1471             : #endif  /* RUBY_EMBEDDED */
    1472             : 
    1473             : 
    1474             : SWIGRUNTIME VALUE 
    1475           4 : getExceptionClass(void) {
    1476             :   static int init = 0;
    1477             :   static VALUE rubyExceptionClass ;
    1478           4 :   if (!init) {
    1479           3 :     init = 1;
    1480           3 :     rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
    1481             :   }
    1482           4 :   return rubyExceptionClass;
    1483             : } 
    1484             : 
    1485             : /* This code checks to see if the Ruby object being raised as part
    1486             :    of an exception inherits from the Ruby class Exception.  If so,
    1487             :    the object is simply returned.  If not, then a new Ruby exception
    1488             :    object is created and that will be returned to Ruby.*/
    1489             : SWIGRUNTIME VALUE
    1490           4 : SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
    1491           4 :   VALUE exceptionClass = getExceptionClass();
    1492           4 :   if (rb_obj_is_kind_of(obj, exceptionClass)) {
    1493             :     return obj;
    1494             :   }  else {
    1495           0 :     return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
    1496             :   }
    1497             : }
    1498             : 
    1499             : /* Initialize Ruby runtime support */
    1500             : SWIGRUNTIME void
    1501           6 : SWIG_Ruby_InitRuntime(void)
    1502             : {
    1503           6 :   if (_mSWIG == Qnil) {
    1504           6 :     _mSWIG = rb_define_module("SWIG");
    1505           6 :     swig_call_id  = rb_intern("call");
    1506           6 :     swig_arity_id = rb_intern("arity");
    1507             :   }
    1508           6 : }
    1509             : 
    1510             : /* Define Ruby class for C type */
    1511             : SWIGRUNTIME void
    1512         660 : SWIG_Ruby_define_class(swig_type_info *type)
    1513             : {
    1514         660 :   char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
    1515         660 :   sprintf(klass_name, "TYPE%s", type->name);
    1516         660 :   if (NIL_P(_cSWIG_Pointer)) {
    1517           6 :     _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
    1518           6 :     rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
    1519             :   }
    1520         660 :   rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
    1521         660 :   free((void *) klass_name);
    1522         660 : }
    1523             : 
    1524             : /* Create a new pointer object */
    1525             : SWIGRUNTIME VALUE
    1526          30 : SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
    1527             : {
    1528          30 :   int own =  flags & SWIG_POINTER_OWN; 
    1529             :   int track;
    1530             :   char *klass_name;
    1531             :   swig_class *sklass;
    1532             :   VALUE klass;
    1533             :   VALUE obj;
    1534             :   
    1535          30 :   if (!ptr)
    1536             :     return Qnil;
    1537             :   
    1538          30 :   if (type->clientdata) {
    1539          30 :     sklass = (swig_class *) type->clientdata;
    1540             :                 
    1541             :     /* Are we tracking this class and have we already returned this Ruby object? */
    1542          30 :     track = sklass->trackObjects;
    1543          30 :     if (track) {
    1544           0 :       obj = SWIG_RubyInstanceFor(ptr);
    1545             :       
    1546             :       /* Check the object's type and make sure it has the correct type.
    1547             :         It might not in cases where methods do things like 
    1548             :         downcast methods. */
    1549           0 :       if (obj != Qnil) {
    1550           0 :         VALUE value = rb_iv_get(obj, "@__swigtype__");
    1551           0 :         const char* type_name = RSTRING_PTR(value);
    1552             :                                 
    1553           0 :         if (strcmp(type->name, type_name) == 0) {
    1554             :           return obj;
    1555             :         }
    1556             :       }
    1557             :     }
    1558             : 
    1559             :     /* Create a new Ruby object */
    1560          30 :     obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
    1561             :                            ( own ? VOIDFUNC(sklass->destroy) : 
    1562             :                              (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
    1563          30 :                              ), ptr);
    1564             : 
    1565             :     /* If tracking is on for this class then track this object. */
    1566          30 :     if (track) {
    1567             :       SWIG_RubyAddTracking(ptr, obj);
    1568             :     }
    1569             :   } else {
    1570           0 :     klass_name = (char *) malloc(4 + strlen(type->name) + 1);
    1571           0 :     sprintf(klass_name, "TYPE%s", type->name);
    1572           0 :     klass = rb_const_get(_mSWIG, rb_intern(klass_name));
    1573           0 :     free((void *) klass_name);
    1574           0 :     obj = Data_Wrap_Struct(klass, 0, 0, ptr);
    1575             :   }
    1576          30 :   rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
    1577             :   
    1578             :   return obj;
    1579             : }
    1580             : 
    1581             : /* Create a new class instance (always owned) */
    1582             : SWIGRUNTIME VALUE
    1583          19 : SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
    1584             : {
    1585             :   VALUE obj;
    1586          19 :   swig_class *sklass = (swig_class *) type->clientdata;
    1587          19 :   obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
    1588          19 :   rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
    1589          19 :   return obj;
    1590             : }
    1591             : 
    1592             : /* Get type mangle from class name */
    1593             : SWIGRUNTIMEINLINE char *
    1594          61 : SWIG_Ruby_MangleStr(VALUE obj)
    1595             : {
    1596          61 :   VALUE stype = rb_iv_get(obj, "@__swigtype__");
    1597          61 :   return StringValuePtr(stype);
    1598             : }
    1599             : 
    1600             : /* Acquire a pointer value */
    1601             : typedef struct {
    1602             :   void (*datafree)(void *);
    1603             :   int own;
    1604             : } swig_ruby_owntype;
    1605             : 
    1606             : SWIGRUNTIME swig_ruby_owntype
    1607             : SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
    1608             :   swig_ruby_owntype oldown = {0, 0};
    1609             :   if (obj) {
    1610             :     oldown.datafree = RDATA(obj)->dfree;
    1611             :     RDATA(obj)->dfree = own.datafree;
    1612             :   }
    1613             :   return oldown;
    1614             : }
    1615             : 
    1616             : /* Convert a pointer value */
    1617             : SWIGRUNTIME int
    1618          64 : SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
    1619             : {
    1620             :   char *c;
    1621             :   swig_cast_info *tc;
    1622          64 :   void *vptr = 0;
    1623             : 
    1624             :   /* Grab the pointer */
    1625          64 :   if (NIL_P(obj)) {
    1626           0 :     if (ptr)
    1627           0 :       *ptr = 0;
    1628             :     return SWIG_OK;
    1629             :   } else {
    1630          64 :     if (TYPE(obj) != T_DATA) {
    1631             :       return SWIG_ERROR;
    1632             :     }
    1633          61 :     Data_Get_Struct(obj, void, vptr);
    1634             :   }
    1635             :   
    1636          61 :   if (own) {
    1637           7 :     own->datafree = RDATA(obj)->dfree;
    1638           7 :     own->own = 0;
    1639             :   }
    1640             :     
    1641             :   /* Check to see if the input object is giving up ownership
    1642             :      of the underlying C struct or C++ object.  If so then we
    1643             :      need to reset the destructor since the Ruby object no 
    1644             :      longer owns the underlying C++ object.*/ 
    1645          61 :   if (flags & SWIG_POINTER_DISOWN) {
    1646             :     /* Is tracking on for this class? */
    1647           0 :     int track = 0;
    1648           0 :     if (ty && ty->clientdata) {
    1649           0 :       swig_class *sklass = (swig_class *) ty->clientdata;
    1650           0 :       track = sklass->trackObjects;
    1651             :     }
    1652             :                 
    1653           0 :     if (track) {
    1654             :       /* We are tracking objects for this class.  Thus we change the destructor
    1655             :        * to SWIG_RubyRemoveTracking.  This allows us to
    1656             :        * remove the mapping from the C++ to Ruby object
    1657             :        * when the Ruby object is garbage collected.  If we don't
    1658             :        * do this, then it is possible we will return a reference 
    1659             :        * to a Ruby object that no longer exists thereby crashing Ruby. */
    1660           0 :       RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
    1661             :     } else {    
    1662           0 :       RDATA(obj)->dfree = 0;
    1663             :     }
    1664             :   }
    1665             : 
    1666             :   /* Do type-checking if type info was provided */
    1667          61 :   if (ty) {
    1668          61 :     if (ty->clientdata) {
    1669          61 :       if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
    1670          55 :         if (vptr == 0) {
    1671             :           /* The object has already been deleted */
    1672             :           return SWIG_ObjectPreviouslyDeletedError;
    1673             :         }
    1674             :       }
    1675             :     }
    1676          61 :     if ((c = SWIG_MangleStr(obj)) == NULL) {
    1677             :       return SWIG_ERROR;
    1678             :     }
    1679          61 :     tc = SWIG_TypeCheck(c, ty);
    1680          61 :     if (!tc) {
    1681             :       return SWIG_ERROR;
    1682             :     } else {
    1683          61 :       if (ptr) {
    1684          61 :         if (tc->type == ty) {
    1685          55 :           *ptr = vptr;
    1686             :         } else {
    1687           6 :           int newmemory = 0;
    1688           6 :           *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
    1689           6 :           if (newmemory == SWIG_CAST_NEW_MEMORY) {
    1690             :             assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
    1691           6 :             if (own)
    1692           6 :               own->own = own->own | SWIG_CAST_NEW_MEMORY;
    1693             :           }
    1694             :         }
    1695             :       }
    1696             :     }
    1697             :   } else {
    1698           0 :     if (ptr)
    1699           0 :       *ptr = vptr;
    1700             :   }
    1701             :   
    1702             :   return SWIG_OK;
    1703             : }
    1704             : 
    1705             : /* Check convert */
    1706             : SWIGRUNTIMEINLINE int
    1707             : SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
    1708             : {
    1709             :   char *c = SWIG_MangleStr(obj);
    1710             :   if (!c) return 0;
    1711             :   return SWIG_TypeCheck(c,ty) != 0;
    1712             : }
    1713             : 
    1714             : SWIGRUNTIME VALUE
    1715             : SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
    1716             :   char result[1024];
    1717             :   char *r = result;
    1718             :   if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
    1719             :   *(r++) = '_';
    1720             :   r = SWIG_PackData(r, ptr, sz);
    1721             :   strcpy(r, type->name);
    1722             :   return rb_str_new2(result);
    1723             : }
    1724             : 
    1725             : /* Convert a packed value value */
    1726             : SWIGRUNTIME int
    1727             : SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
    1728             :   swig_cast_info *tc;
    1729             :   const char  *c;
    1730             : 
    1731             :   if (TYPE(obj) != T_STRING) goto type_error;
    1732             :   c = StringValuePtr(obj);
    1733             :   /* Pointer values must start with leading underscore */
    1734             :   if (*c != '_') goto type_error;
    1735             :   c++;
    1736             :   c = SWIG_UnpackData(c, ptr, sz);
    1737             :   if (ty) {
    1738             :     tc = SWIG_TypeCheck(c, ty);
    1739             :     if (!tc) goto type_error;
    1740             :   }
    1741             :   return SWIG_OK;
    1742             : 
    1743             :  type_error:
    1744             :   return SWIG_ERROR;
    1745             : }
    1746             : 
    1747             : SWIGRUNTIME swig_module_info *
    1748           6 : SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
    1749             : {
    1750             :   VALUE pointer;
    1751           6 :   swig_module_info *ret = 0;
    1752           6 :   VALUE verbose = rb_gv_get("VERBOSE");
    1753             : 
    1754             :  /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
    1755           6 :   rb_gv_set("VERBOSE", Qfalse);
    1756             :   
    1757             :   /* first check if pointer already created */
    1758           6 :   pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
    1759           6 :   if (pointer != Qnil) {
    1760           0 :     Data_Get_Struct(pointer, swig_module_info, ret);
    1761             :   }
    1762             : 
    1763             :   /* reinstate warnings */
    1764           6 :   rb_gv_set("VERBOSE", verbose);
    1765           6 :   return ret;
    1766             : }
    1767             : 
    1768             : SWIGRUNTIME void 
    1769           6 : SWIG_Ruby_SetModule(swig_module_info *pointer)
    1770             : {
    1771             :   /* register a new class */
    1772           6 :   VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
    1773             :   /* create and store the structure pointer to a global variable */
    1774           6 :   swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
    1775           6 :   rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
    1776           6 : }
    1777             : 
    1778             : /* This function can be used to check whether a proc or method or similarly
    1779             :    callable function has been passed.  Usually used in a %typecheck, like:
    1780             : 
    1781             :    %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
    1782             :         $result = SWIG_Ruby_isCallable( $input );
    1783             :    }
    1784             :  */
    1785             : SWIGINTERN
    1786             : int SWIG_Ruby_isCallable( VALUE proc )
    1787             : {
    1788             :   if ( rb_respond_to( proc, swig_call_id ) )
    1789             :     return 1;
    1790             :   return 0;
    1791             : }
    1792             : 
    1793             : /* This function can be used to check the arity (number of arguments)
    1794             :    a proc or method can take.  Usually used in a %typecheck.
    1795             :    Valid arities will be that equal to minimal or those < 0
    1796             :    which indicate a variable number of parameters at the end.
    1797             :  */
    1798             : SWIGINTERN
    1799             : int SWIG_Ruby_arity( VALUE proc, int minimal )
    1800             : {
    1801             :   if ( rb_respond_to( proc, swig_arity_id ) )
    1802             :     {
    1803             :       VALUE num = rb_funcall( proc, swig_arity_id, 0 );
    1804             :       int arity = NUM2INT(num);
    1805             :       if ( arity < 0 && (arity+1) < -minimal ) return 1;
    1806             :       if ( arity == minimal ) return 1;
    1807             :       return 1;
    1808             :     }
    1809             :   return 0;
    1810             : }
    1811             : 
    1812             : 
    1813             : #ifdef __cplusplus
    1814             : }
    1815             : #endif
    1816             : 
    1817             : 
    1818             : 
    1819             : #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
    1820             : 
    1821             : #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
    1822             : 
    1823             : 
    1824             : 
    1825             :   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
    1826             : 
    1827             : 
    1828             : /* -------- TYPES TABLE (BEGIN) -------- */
    1829             : 
    1830             : #define SWIGTYPE_p_BackendInfoVector swig_types[0]
    1831             : #define SWIGTYPE_p_Backends swig_types[1]
    1832             : #define SWIGTYPE_p__Plugin swig_types[2]
    1833             : #define SWIGTYPE_p_allocator_type swig_types[3]
    1834             : #define SWIGTYPE_p_char swig_types[4]
    1835             : #define SWIGTYPE_p_const_iterator swig_types[5]
    1836             : #define SWIGTYPE_p_difference_type swig_types[6]
    1837             : #define SWIGTYPE_p_f_p__Key_p__KeySet__int swig_types[7]
    1838             : #define SWIGTYPE_p_int swig_types[8]
    1839             : #define SWIGTYPE_p_kdb__Key swig_types[9]
    1840             : #define SWIGTYPE_p_kdb__KeySet swig_types[10]
    1841             : #define SWIGTYPE_p_kdb__tools__Backend swig_types[11]
    1842             : #define SWIGTYPE_p_kdb__tools__BackendBuilder swig_types[12]
    1843             : #define SWIGTYPE_p_kdb__tools__BackendBuilderInit swig_types[13]
    1844             : #define SWIGTYPE_p_kdb__tools__BackendCheckException swig_types[14]
    1845             : #define SWIGTYPE_p_kdb__tools__BackendFactory swig_types[15]
    1846             : #define SWIGTYPE_p_kdb__tools__BackendInfo swig_types[16]
    1847             : #define SWIGTYPE_p_kdb__tools__BackendInterface swig_types[17]
    1848             : #define SWIGTYPE_p_kdb__tools__Backends swig_types[18]
    1849             : #define SWIGTYPE_p_kdb__tools__BadPluginName swig_types[19]
    1850             : #define SWIGTYPE_p_kdb__tools__ConflictViolation swig_types[20]
    1851             : #define SWIGTYPE_p_kdb__tools__CyclicOrderingViolation swig_types[21]
    1852             : #define SWIGTYPE_p_kdb__tools__ErrorPlugins swig_types[22]
    1853             : #define SWIGTYPE_p_kdb__tools__FileNotValidException swig_types[23]
    1854             : #define SWIGTYPE_p_kdb__tools__GetPlugins swig_types[24]
    1855             : #define SWIGTYPE_p_kdb__tools__GlobalPlugins swig_types[25]
    1856             : #define SWIGTYPE_p_kdb__tools__GlobalPluginsBuilder swig_types[26]
    1857             : #define SWIGTYPE_p_kdb__tools__ImportExportBackend swig_types[27]
    1858             : #define SWIGTYPE_p_kdb__tools__MissingNeeded swig_types[28]
    1859             : #define SWIGTYPE_p_kdb__tools__MissingSymbol swig_types[29]
    1860             : #define SWIGTYPE_p_kdb__tools__MockPluginDatabase swig_types[30]
    1861             : #define SWIGTYPE_p_kdb__tools__Modules swig_types[31]
    1862             : #define SWIGTYPE_p_kdb__tools__ModulesPluginDatabase swig_types[32]
    1863             : #define SWIGTYPE_p_kdb__tools__MountBackendBuilder swig_types[33]
    1864             : #define SWIGTYPE_p_kdb__tools__MountBackendInterface swig_types[34]
    1865             : #define SWIGTYPE_p_kdb__tools__MountpointAlreadyInUseException swig_types[35]
    1866             : #define SWIGTYPE_p_kdb__tools__MountpointInvalidException swig_types[36]
    1867             : #define SWIGTYPE_p_kdb__tools__NoGlobalPlugin swig_types[37]
    1868             : #define SWIGTYPE_p_kdb__tools__NoPlugin swig_types[38]
    1869             : #define SWIGTYPE_p_kdb__tools__NoSuchBackend swig_types[39]
    1870             : #define SWIGTYPE_p_kdb__tools__OrderingViolation swig_types[40]
    1871             : #define SWIGTYPE_p_kdb__tools__ParseException swig_types[41]
    1872             : #define SWIGTYPE_p_kdb__tools__Place swig_types[42]
    1873             : #define SWIGTYPE_p_kdb__tools__Plugin swig_types[43]
    1874             : #define SWIGTYPE_p_kdb__tools__PluginAdder swig_types[44]
    1875             : #define SWIGTYPE_p_kdb__tools__PluginAlreadyInserted swig_types[45]
    1876             : #define SWIGTYPE_p_kdb__tools__PluginCheckException swig_types[46]
    1877             : #define SWIGTYPE_p_kdb__tools__PluginConfigInvalid swig_types[47]
    1878             : #define SWIGTYPE_p_kdb__tools__PluginDatabase swig_types[48]
    1879             : #define SWIGTYPE_p_kdb__tools__PluginNoContract swig_types[49]
    1880             : #define SWIGTYPE_p_kdb__tools__PluginNoInfo swig_types[50]
    1881             : #define SWIGTYPE_p_kdb__tools__PluginSpec swig_types[51]
    1882             : #define SWIGTYPE_p_kdb__tools__PluginSpecFullName swig_types[52]
    1883             : #define SWIGTYPE_p_kdb__tools__PluginSpecHash swig_types[53]
    1884             : #define SWIGTYPE_p_kdb__tools__PluginSpecName swig_types[54]
    1885             : #define SWIGTYPE_p_kdb__tools__PluginSpecRefName swig_types[55]
    1886             : #define SWIGTYPE_p_kdb__tools__PluginVariantDatabase swig_types[56]
    1887             : #define SWIGTYPE_p_kdb__tools__Plugins swig_types[57]
    1888             : #define SWIGTYPE_p_kdb__tools__ReferenceNotFound swig_types[58]
    1889             : #define SWIGTYPE_p_kdb__tools__ResolverPlugin swig_types[59]
    1890             : #define SWIGTYPE_p_kdb__tools__SerializeInterface swig_types[60]
    1891             : #define SWIGTYPE_p_kdb__tools__SetPlugins swig_types[61]
    1892             : #define SWIGTYPE_p_kdb__tools__SpecBackendBuilder swig_types[62]
    1893             : #define SWIGTYPE_p_kdb__tools__SpecReader swig_types[63]
    1894             : #define SWIGTYPE_p_kdb__tools__StoragePlugin swig_types[64]
    1895             : #define SWIGTYPE_p_kdb__tools__SymbolDuplicate swig_types[65]
    1896             : #define SWIGTYPE_p_kdb__tools__SymbolMismatch swig_types[66]
    1897             : #define SWIGTYPE_p_kdb__tools__TooManyPlugins swig_types[67]
    1898             : #define SWIGTYPE_p_kdb__tools__ToolException swig_types[68]
    1899             : #define SWIGTYPE_p_kdb__tools__VersionInfoMismatch swig_types[69]
    1900             : #define SWIGTYPE_p_kdb__tools__WrongStatus swig_types[70]
    1901             : #define SWIGTYPE_p_key_type swig_types[71]
    1902             : #define SWIGTYPE_p_long_long swig_types[72]
    1903             : #define SWIGTYPE_p_mapped_type swig_types[73]
    1904             : #define SWIGTYPE_p_p_void swig_types[74]
    1905             : #define SWIGTYPE_p_short swig_types[75]
    1906             : #define SWIGTYPE_p_signed_char swig_types[76]
    1907             : #define SWIGTYPE_p_size_type swig_types[77]
    1908             : #define SWIGTYPE_p_std__allocatorT_kdb__tools__BackendInfo_t swig_types[78]
    1909             : #define SWIGTYPE_p_std__allocatorT_kdb__tools__PluginSpec_t swig_types[79]
    1910             : #define SWIGTYPE_p_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t swig_types[80]
    1911             : #define SWIGTYPE_p_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t swig_types[81]
    1912             : #define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[82]
    1913             : #define SWIGTYPE_p_std__lessT_int_t swig_types[83]
    1914             : #define SWIGTYPE_p_std__lessT_kdb__Key_t swig_types[84]
    1915             : #define SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t swig_types[85]
    1916             : #define SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t swig_types[86]
    1917             : #define SWIGTYPE_p_std__mapT_std__string_int_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_int_t_t_t swig_types[87]
    1918             : #define SWIGTYPE_p_std__ostream swig_types[88]
    1919             : #define SWIGTYPE_p_std__runtime_error swig_types[89]
    1920             : #define SWIGTYPE_p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t swig_types[90]
    1921             : #define SWIGTYPE_p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t swig_types[91]
    1922             : #define SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginDatabase_t swig_types[92]
    1923             : #define SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t swig_types[93]
    1924             : #define SWIGTYPE_p_std__unique_ptrT_kdb__tools__BackendInterface_t swig_types[94]
    1925             : #define SWIGTYPE_p_std__unique_ptrT_kdb__tools__MountBackendInterface_t swig_types[95]
    1926             : #define SWIGTYPE_p_std__unique_ptrT_kdb__tools__Plugin_t swig_types[96]
    1927             : #define SWIGTYPE_p_std__unordered_mapT_kdb__tools__PluginSpec_std__unordered_mapT_std__string_std__string_t_kdb__tools__PluginSpecHash_kdb__tools__PluginSpecName_t swig_types[97]
    1928             : #define SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t swig_types[98]
    1929             : #define SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t swig_types[99]
    1930             : #define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[100]
    1931             : #define SWIGTYPE_p_swig__ConstIterator swig_types[101]
    1932             : #define SWIGTYPE_p_swig__GC_VALUE swig_types[102]
    1933             : #define SWIGTYPE_p_swig__Iterator swig_types[103]
    1934             : #define SWIGTYPE_p_unsigned_char swig_types[104]
    1935             : #define SWIGTYPE_p_unsigned_int swig_types[105]
    1936             : #define SWIGTYPE_p_unsigned_long_long swig_types[106]
    1937             : #define SWIGTYPE_p_unsigned_short swig_types[107]
    1938             : #define SWIGTYPE_p_value_type swig_types[108]
    1939             : #define SWIGTYPE_p_void swig_types[109]
    1940             : static swig_type_info *swig_types[111];
    1941             : static swig_module_info swig_module = {swig_types, 110, 0, 0, 0, 0};
    1942             : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
    1943             : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
    1944             : 
    1945             : /* -------- TYPES TABLE (END) -------- */
    1946             : 
    1947             : #define SWIG_init    Init__kdbtools
    1948             : #define SWIG_name    "Kdbtools"
    1949             : 
    1950             : static VALUE mKdbtools;
    1951             : 
    1952             : #define SWIG_RUBY_THREAD_BEGIN_BLOCK
    1953             : #define SWIG_RUBY_THREAD_END_BLOCK
    1954             : 
    1955             : 
    1956             : #define SWIGVERSION 0x030010 
    1957             : #define SWIG_VERSION SWIGVERSION
    1958             : 
    1959             : 
    1960             : #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
    1961             : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
    1962             : 
    1963             : 
    1964             : #include <stdexcept>
    1965             : 
    1966             : 
    1967             : #include <iostream>
    1968             : 
    1969             : 
    1970             : #include <stdexcept>
    1971             : 
    1972             : 
    1973             : namespace swig {
    1974             :   class SwigGCReferences {
    1975             :     VALUE _hash;
    1976             : 
    1977           6 :     SwigGCReferences() : _hash(Qnil) {
    1978             :     }
    1979          12 :     ~SwigGCReferences() {
    1980           6 :       if (_hash != Qnil)
    1981           0 :         rb_gc_unregister_address(&_hash);
    1982           6 :     }
    1983           6 :     static void EndProcHandler(VALUE) {
    1984             :       // Ruby interpreter ending - _hash can no longer be accessed.
    1985           6 :       SwigGCReferences &s_references = instance();
    1986           6 :       s_references._hash = Qnil;
    1987           6 :     }
    1988             :   public:
    1989          12 :     static SwigGCReferences& instance() {
    1990             :       // Hash of all GC_VALUE's currently in use
    1991          18 :       static SwigGCReferences s_references;
    1992             : 
    1993          12 :       return s_references;
    1994             :     }
    1995           6 :     static void initialize() {
    1996           6 :       SwigGCReferences &s_references = instance();
    1997           6 :       if (s_references._hash == Qnil) {
    1998           6 :         rb_set_end_proc(&EndProcHandler, Qnil);
    1999           6 :         s_references._hash = rb_hash_new();
    2000           6 :         rb_gc_register_address(&s_references._hash);
    2001             :       }
    2002           6 :     }
    2003           0 :     void GC_register(VALUE& obj) {
    2004           0 :       if (FIXNUM_P(obj) || SPECIAL_CONST_P(obj) || SYMBOL_P(obj))
    2005             :         return;
    2006           0 :       if (_hash != Qnil) {
    2007           0 :         VALUE val = rb_hash_aref(_hash, obj);
    2008           0 :         unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 0;
    2009           0 :         ++n;
    2010           0 :         rb_hash_aset(_hash, obj, INT2NUM(n));
    2011             :       }
    2012             :     }
    2013           0 :     void GC_unregister(const VALUE& obj) {
    2014           0 :       if (FIXNUM_P(obj) || SPECIAL_CONST_P(obj) || SYMBOL_P(obj))
    2015             :         return;
    2016             :       // this test should not be needed but I've noticed some very erratic
    2017             :       // behavior of none being unregistered in some very rare situations.
    2018           0 :       if (BUILTIN_TYPE(obj) == T_NONE)
    2019             :         return;
    2020           0 :       if (_hash != Qnil) {
    2021           0 :         VALUE val = rb_hash_aref(_hash, obj);
    2022           0 :         unsigned n = FIXNUM_P(val) ? NUM2UINT(val) : 1;
    2023           0 :         --n;
    2024           0 :         if (n)
    2025           0 :           rb_hash_aset(_hash, obj, INT2NUM(n));
    2026             :         else
    2027           0 :           rb_hash_delete(_hash, obj);
    2028             :       }
    2029             :     }
    2030             :   };
    2031             : 
    2032             :   class GC_VALUE {
    2033             :   protected:
    2034             :     VALUE  _obj;
    2035             : 
    2036             :     static ID hash_id;
    2037             :     static ID   lt_id;
    2038             :     static ID   gt_id;
    2039             :     static ID   eq_id;
    2040             :     static ID   le_id;
    2041             :     static ID   ge_id;
    2042             : 
    2043             :     static ID  pos_id;
    2044             :     static ID  neg_id;
    2045             :     static ID  inv_id;
    2046             : 
    2047             :     static ID  add_id;
    2048             :     static ID  sub_id;
    2049             :     static ID  mul_id;
    2050             :     static ID  div_id;
    2051             :     static ID  mod_id;
    2052             : 
    2053             :     static ID  and_id;
    2054             :     static ID   or_id;
    2055             :     static ID  xor_id;
    2056             : 
    2057             :     static ID  lshift_id;
    2058             :     static ID  rshift_id;
    2059             : 
    2060             :     struct OpArgs
    2061             :     {
    2062             :       VALUE src;
    2063             :       ID    id;
    2064             :       int   nargs;
    2065             :       VALUE target;
    2066             :     };
    2067             : 
    2068             : 
    2069             :   public:
    2070           0 :     GC_VALUE() : _obj(Qnil)
    2071             :     {
    2072             :     }
    2073             : 
    2074           0 :     GC_VALUE(const GC_VALUE& item) : _obj(item._obj)
    2075             :     {
    2076           0 :       SwigGCReferences::instance().GC_register(_obj);
    2077             :     }
    2078             :     
    2079           0 :     GC_VALUE(VALUE obj) :_obj(obj)
    2080             :     {
    2081           0 :       SwigGCReferences::instance().GC_register(_obj);
    2082             :     }
    2083             :     
    2084             :     ~GC_VALUE() 
    2085             :     {
    2086           0 :       SwigGCReferences::instance().GC_unregister(_obj);
    2087             :     }
    2088             :     
    2089           0 :     GC_VALUE & operator=(const GC_VALUE& item) 
    2090             :     {
    2091           0 :       SwigGCReferences::instance().GC_unregister(_obj);
    2092           0 :       _obj = item._obj;
    2093           0 :       SwigGCReferences::instance().GC_register(_obj);
    2094           0 :       return *this;
    2095             :     }
    2096             : 
    2097             :     operator VALUE() const
    2098             :     {
    2099           0 :       return _obj;
    2100             :     }
    2101             : 
    2102             :     VALUE inspect() const
    2103             :     {
    2104           0 :       return rb_inspect(_obj);
    2105             :     }
    2106             : 
    2107             :     VALUE to_s() const
    2108             :     {
    2109           0 :       return rb_inspect(_obj);
    2110             :     }
    2111             : 
    2112             :     static VALUE swig_rescue_swallow(VALUE)
    2113             :     {
    2114             :       /*
    2115             :       VALUE errstr = rb_obj_as_string(rb_errinfo());
    2116             :       printf("Swallowing error: '%s'\n", RSTRING_PTR(StringValue(errstr)));
    2117             :       */
    2118             :       return Qnil; /* Swallow Ruby exception */
    2119             :     }
    2120             : 
    2121             :     static VALUE swig_rescue_funcall(VALUE p)
    2122             :     {
    2123             :       OpArgs* args = (OpArgs*) p;
    2124             :       return rb_funcall(args->src, args->id, args->nargs, args->target);
    2125             :     }
    2126             : 
    2127             :     bool relational_equal_op(const GC_VALUE& other, const ID& op_id, bool (*op_func)(const VALUE& a, const VALUE& b)) const
    2128             :     {
    2129             :       if (FIXNUM_P(_obj) && FIXNUM_P(other._obj)) {
    2130             :         return op_func(_obj, other._obj);
    2131             :       }
    2132             :       bool res = false;
    2133             :       VALUE ret = Qnil;
    2134             :       SWIG_RUBY_THREAD_BEGIN_BLOCK;
    2135             :       if (rb_respond_to(_obj, op_id)) {
    2136             :         OpArgs  args;
    2137             :         args.src    = _obj;
    2138             :         args.id     = op_id;
    2139             :         args.nargs  = 1;
    2140             :         args.target = VALUE(other);
    2141             :         ret = rb_rescue(RUBY_METHOD_FUNC(swig_rescue_funcall), VALUE(&args),
    2142             :                        (RUBY_METHOD_FUNC(swig_rescue_swallow)), Qnil);
    2143             :       }
    2144             :       if (ret == Qnil) {
    2145             :         VALUE a = rb_funcall(         _obj, hash_id, 0 );
    2146             :         VALUE b = rb_funcall( VALUE(other), hash_id, 0 );
    2147             :         res = op_func(a, b);
    2148             :       } else {
    2149             :         res = RTEST(ret);
    2150             :       }
    2151             :       SWIG_RUBY_THREAD_END_BLOCK;
    2152             :       return res;
    2153             :     }
    2154             : 
    2155             :     static bool operator_eq(const VALUE& a, const VALUE& b) { return a == b; }
    2156             :     static bool operator_lt(const VALUE& a, const VALUE& b) { return a < b; }
    2157             :     static bool operator_le(const VALUE& a, const VALUE& b) { return a <= b; }
    2158             :     static bool operator_gt(const VALUE& a, const VALUE& b) { return a > b; }
    2159             :     static bool operator_ge(const VALUE& a, const VALUE& b) { return a >= b; }
    2160             : 
    2161             :     bool operator==(const GC_VALUE& other) const { return relational_equal_op(other, eq_id, operator_eq); }
    2162             :     bool operator<(const GC_VALUE& other) const { return relational_equal_op(other, lt_id, operator_lt); }
    2163             :     bool operator<=(const GC_VALUE& other) const { return relational_equal_op(other, le_id, operator_le); }
    2164             :     bool operator>(const GC_VALUE& other) const { return relational_equal_op(other, gt_id, operator_gt); }
    2165             :     bool operator>=(const GC_VALUE& other) const { return relational_equal_op(other, ge_id, operator_ge); }
    2166             : 
    2167             :     bool operator!=(const GC_VALUE& other) const
    2168             :     {
    2169             :       return !(this->operator==(other));
    2170             :     }
    2171             : 
    2172             :     GC_VALUE unary_op(const ID& op_id) const
    2173             :     {
    2174             :       VALUE ret = Qnil;
    2175             :       SWIG_RUBY_THREAD_BEGIN_BLOCK;
    2176             :       OpArgs  args;
    2177             :       args.src    = _obj;
    2178             :       args.id     = op_id;
    2179             :       args.nargs  = 0;
    2180             :       args.target = Qnil;
    2181             :       ret = rb_rescue(RUBY_METHOD_FUNC(swig_rescue_funcall), VALUE(&args),
    2182             :                      (RUBY_METHOD_FUNC(swig_rescue_swallow)), Qnil);
    2183             :       SWIG_RUBY_THREAD_END_BLOCK;
    2184             :       return ret;
    2185             :     }
    2186             : 
    2187             :     GC_VALUE operator+() const { return unary_op(pos_id); }
    2188             :     GC_VALUE operator-() const { return unary_op(neg_id); }
    2189             :     GC_VALUE operator~() const { return unary_op(inv_id); }
    2190             : 
    2191             :     GC_VALUE binary_op(const GC_VALUE& other, const ID& op_id) const
    2192             :     {
    2193             :       VALUE ret = Qnil;
    2194             :       SWIG_RUBY_THREAD_BEGIN_BLOCK;
    2195             :       OpArgs  args;
    2196             :       args.src    = _obj;
    2197             :       args.id     = op_id;
    2198             :       args.nargs  = 1;
    2199             :       args.target = VALUE(other);
    2200             :       ret = rb_rescue(RUBY_METHOD_FUNC(swig_rescue_funcall), VALUE(&args),
    2201             :                      (RUBY_METHOD_FUNC(swig_rescue_swallow)), Qnil);
    2202             :       SWIG_RUBY_THREAD_END_BLOCK;
    2203             :       return GC_VALUE(ret);
    2204             :     }
    2205             : 
    2206             :     GC_VALUE operator+(const GC_VALUE& other) const { return binary_op(other, add_id); }
    2207             :     GC_VALUE operator-(const GC_VALUE& other) const { return binary_op(other, sub_id); }
    2208             :     GC_VALUE operator*(const GC_VALUE& other) const { return binary_op(other, mul_id); }
    2209             :     GC_VALUE operator/(const GC_VALUE& other) const { return binary_op(other, div_id); }
    2210             :     GC_VALUE operator%(const GC_VALUE& other) const { return binary_op(other, mod_id); }
    2211             :     GC_VALUE operator&(const GC_VALUE& other) const { return binary_op(other, and_id); }
    2212             :     GC_VALUE operator^(const GC_VALUE& other) const { return binary_op(other, xor_id); }
    2213             :     GC_VALUE operator|(const GC_VALUE& other) const { return binary_op(other, or_id); }
    2214             :     GC_VALUE operator<<(const GC_VALUE& other) const { return binary_op(other, lshift_id); }
    2215             :     GC_VALUE operator>>(const GC_VALUE& other) const { return binary_op(other, rshift_id); }
    2216             :   };
    2217             : 
    2218           6 :   ID  GC_VALUE::hash_id = rb_intern("hash");
    2219           6 :   ID  GC_VALUE::lt_id = rb_intern("<");
    2220           6 :   ID  GC_VALUE::gt_id = rb_intern(">");
    2221           6 :   ID  GC_VALUE::eq_id = rb_intern("==");
    2222           6 :   ID  GC_VALUE::le_id = rb_intern("<=");
    2223           6 :   ID  GC_VALUE::ge_id = rb_intern(">=");
    2224             : 
    2225           6 :   ID  GC_VALUE::pos_id = rb_intern("+@");
    2226           6 :   ID  GC_VALUE::neg_id = rb_intern("-@");
    2227           6 :   ID  GC_VALUE::inv_id = rb_intern("~");
    2228             : 
    2229           6 :   ID  GC_VALUE::add_id = rb_intern("+");
    2230           6 :   ID  GC_VALUE::sub_id = rb_intern("-");
    2231           6 :   ID  GC_VALUE::mul_id = rb_intern("*");
    2232           6 :   ID  GC_VALUE::div_id = rb_intern("/");
    2233           6 :   ID  GC_VALUE::mod_id = rb_intern("%");
    2234             : 
    2235           6 :   ID  GC_VALUE::and_id = rb_intern("&");
    2236           6 :   ID  GC_VALUE::or_id  = rb_intern("|");
    2237           6 :   ID  GC_VALUE::xor_id = rb_intern("^");
    2238             : 
    2239           6 :   ID  GC_VALUE::lshift_id = rb_intern("<<");
    2240           6 :   ID  GC_VALUE::rshift_id = rb_intern(">>");
    2241             : 
    2242             :   typedef GC_VALUE LANGUAGE_OBJ;
    2243             : 
    2244             : } // namespace swig
    2245             : 
    2246             : 
    2247             : 
    2248             : #if defined(__GNUC__)
    2249             : #  if __GNUC__ == 2 && __GNUC_MINOR <= 96
    2250             : #     define SWIG_STD_NOMODERN_STL
    2251             : #  endif
    2252             : #endif
    2253             : 
    2254             : 
    2255             : #include <string>
    2256             : 
    2257             : 
    2258             : #include <stddef.h>
    2259             : 
    2260             : 
    2261             : namespace swig {
    2262             :   struct stop_iteration {
    2263             :   };
    2264             : 
    2265             :   /** 
    2266             :    * Abstract base class used to represent all iterators of STL containers.
    2267             :    */
    2268             :   struct ConstIterator {
    2269             :   public:
    2270             :     typedef ConstIterator self_type;
    2271             : 
    2272             :   protected:
    2273             :     GC_VALUE _seq;
    2274             : 
    2275             :   protected:
    2276           0 :     ConstIterator(VALUE seq) : _seq(seq)
    2277             :     {
    2278             :     }
    2279             : 
    2280             :     // Random access iterator methods, but not required in Ruby
    2281           0 :     virtual ptrdiff_t distance(const ConstIterator &x) const
    2282             :     {
    2283           0 :       throw std::invalid_argument("distance not supported");
    2284             :     }
    2285             : 
    2286           0 :     virtual bool equal (const ConstIterator &x) const
    2287             :     {
    2288           0 :       throw std::invalid_argument("equal not supported");
    2289             :     }
    2290             : 
    2291           0 :     virtual self_type* advance(ptrdiff_t n)
    2292             :     {
    2293           0 :       throw std::invalid_argument("advance not supported");
    2294             :     }
    2295             :       
    2296             :   public:
    2297           0 :     virtual ~ConstIterator() {}
    2298             : 
    2299             :     // Access iterator method, required by Ruby
    2300           0 :     virtual VALUE value() const {
    2301           0 :       throw std::invalid_argument("value not supported");
    2302             :       return Qnil;
    2303             :     };
    2304             : 
    2305           0 :     virtual VALUE setValue( const VALUE& v ) {
    2306           0 :       throw std::invalid_argument("value= not supported");
    2307             :       return Qnil;
    2308             :     }
    2309             : 
    2310           0 :     virtual self_type* next( size_t n = 1 )
    2311             :     {
    2312           0 :       return this->advance( n );
    2313             :     }
    2314             : 
    2315           0 :     virtual self_type* previous( size_t n = 1 )
    2316             :     {
    2317           0 :       ptrdiff_t nn = n;
    2318           0 :       return this->advance( -nn );
    2319             :     }
    2320             : 
    2321           0 :     virtual VALUE to_s() const {
    2322           0 :       throw std::invalid_argument("to_s not supported");
    2323             :       return Qnil;
    2324             :     }
    2325             : 
    2326           0 :     virtual VALUE inspect() const {
    2327           0 :       throw std::invalid_argument("inspect not supported");
    2328             :       return Qnil;
    2329             :     }
    2330             :     
    2331           0 :     virtual ConstIterator *dup() const
    2332             :     {
    2333           0 :       throw std::invalid_argument("dup not supported");
    2334             :       return NULL;
    2335             :     }
    2336             : 
    2337             :     //
    2338             :     // C++ common/needed methods.  We emulate a bidirectional
    2339             :     // operator, to be compatible with all the STL.
    2340             :     // The iterator traits will then tell the STL what type of
    2341             :     // iterator we really are.
    2342             :     //
    2343             :     ConstIterator() : _seq( Qnil )
    2344             :     {
    2345             :     }
    2346             : 
    2347           0 :     ConstIterator( const self_type& b ) : _seq( b._seq )
    2348             :     {
    2349             :     }
    2350             : 
    2351             :     self_type& operator=( const self_type& b )
    2352             :     {
    2353             :       _seq = b._seq;
    2354             :       return *this;
    2355             :     }
    2356             : 
    2357             :     bool operator == (const ConstIterator& x)  const
    2358             :     {
    2359           0 :       return equal(x);
    2360             :     }
    2361             :       
    2362             :     bool operator != (const ConstIterator& x) const
    2363             :     {
    2364             :       return ! operator==(x);
    2365             :     }
    2366             :       
    2367             :     // Pre-decrement operator
    2368             :     self_type& operator--()
    2369             :     {
    2370             :       return *previous();
    2371             :     }
    2372             : 
    2373             :     // Pre-increment operator
    2374             :     self_type& operator++()
    2375             :     {
    2376             :       return *next();
    2377             :     }
    2378             : 
    2379             :     // Post-decrement operator
    2380             :     self_type operator--(int)
    2381             :     {
    2382             :       self_type r = *this;
    2383             :       previous();
    2384             :       return r;
    2385             :     }
    2386             : 
    2387             :     // Post-increment operator
    2388             :     self_type operator++(int)
    2389             :     {
    2390             :       self_type r = *this;
    2391             :       next();
    2392             :       return r;
    2393             :     }
    2394             : 
    2395             :     ConstIterator& operator += (ptrdiff_t n)
    2396             :     {
    2397             :       return *advance(n);
    2398             :     }
    2399             : 
    2400             :     ConstIterator& operator -= (ptrdiff_t n)
    2401             :     {
    2402             :       return *advance(-n);
    2403             :     }
    2404             : 
    2405             :     ConstIterator* operator + (ptrdiff_t n) const
    2406             :     {
    2407           0 :       return dup()->advance(n);
    2408             :     }
    2409             : 
    2410             :     ConstIterator* operator - (ptrdiff_t n) const
    2411             :     {
    2412           0 :       return dup()->advance(-n);
    2413             :     }
    2414             :       
    2415             :     ptrdiff_t operator - (const ConstIterator& x) const
    2416             :     {
    2417           0 :       return x.distance(*this);
    2418             :     }
    2419             :       
    2420             :     static swig_type_info* descriptor() {
    2421             :       static int init = 0;
    2422             :       static swig_type_info* desc = 0;
    2423             :       if (!init) {
    2424             :         desc = SWIG_TypeQuery("swig::ConstIterator *");
    2425             :         init = 1;
    2426             :       } 
    2427             :       return desc;
    2428             :     }
    2429             :   };
    2430             : 
    2431             : 
    2432             :   /**
    2433             :    * Abstract base class used to represent all non-const iterators of STL containers.
    2434             :    * 
    2435             :    */
    2436           0 :   struct Iterator : public ConstIterator {
    2437             :   public:
    2438             :     typedef Iterator self_type;
    2439             : 
    2440             :   protected:
    2441             :     Iterator(VALUE seq) : ConstIterator(seq)
    2442             :     {
    2443             :     }
    2444             : 
    2445           0 :     virtual self_type* advance(ptrdiff_t n)
    2446             :     {
    2447           0 :       throw std::invalid_argument("operation not supported");
    2448             :     }
    2449             : 
    2450             :   public:
    2451             :     static swig_type_info* descriptor() {
    2452             :       static int init = 0;
    2453             :       static swig_type_info* desc = 0;
    2454             :       if (!init) {
    2455             :         desc = SWIG_TypeQuery("swig::Iterator *");
    2456             :         init = 1;
    2457             :       } 
    2458             :       return desc;
    2459             :     }
    2460             :     
    2461           0 :     virtual Iterator *dup() const
    2462             :     {
    2463           0 :       throw std::invalid_argument("dup not supported");
    2464             :       return NULL;
    2465             :     }
    2466             :       
    2467           0 :     virtual self_type* next( size_t n = 1 )
    2468             :     {
    2469           0 :       return this->advance( n );
    2470             :     }
    2471             : 
    2472           0 :     virtual self_type* previous( size_t n = 1 )
    2473             :     {
    2474           0 :       ptrdiff_t nn = n;
    2475           0 :       return this->advance( -nn );
    2476             :     }
    2477             : 
    2478             :     bool operator == (const ConstIterator& x)  const
    2479             :     {
    2480           0 :       return equal(x);
    2481             :     }
    2482             :       
    2483             :     bool operator != (const Iterator& x) const
    2484             :     {
    2485             :       return ! operator==(x);
    2486             :     }
    2487             :       
    2488             :     Iterator& operator += (ptrdiff_t n)
    2489             :     {
    2490             :       return *advance(n);
    2491             :     }
    2492             : 
    2493             :     Iterator& operator -= (ptrdiff_t n)
    2494             :     {
    2495             :       return *advance(-n);
    2496             :     }
    2497             :       
    2498             :     Iterator* operator + (ptrdiff_t n) const
    2499             :     {
    2500           0 :       return dup()->advance(n);
    2501             :     }
    2502             : 
    2503             :     Iterator* operator - (ptrdiff_t n) const
    2504             :     {
    2505           0 :       return dup()->advance(-n);
    2506             :     }
    2507             :       
    2508             :     ptrdiff_t operator - (const Iterator& x) const
    2509             :     {
    2510           0 :       return x.distance(*this);
    2511             :     }
    2512             :   };
    2513             : 
    2514             : }
    2515             : 
    2516             : 
    2517             : SWIGINTERN VALUE
    2518           0 : SWIG_ruby_failed(void)
    2519             : {
    2520           0 :   return Qnil;
    2521             : } 
    2522             : 
    2523             : 
    2524             : /*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
    2525           1 : SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
    2526             : {
    2527           1 :   VALUE obj = args[0];
    2528           1 :   VALUE type = TYPE(obj);
    2529           1 :   unsigned long *res = (unsigned long *)(args[1]);
    2530           1 :   *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
    2531           1 :   return obj;
    2532             : }
    2533             : /*@SWIG@*/
    2534             : 
    2535             : SWIGINTERN int
    2536           1 : SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
    2537             : {
    2538           1 :   VALUE type = TYPE(obj);
    2539           1 :   if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    2540             :     unsigned long v;
    2541             :     VALUE a[2];
    2542           1 :     a[0] = obj;
    2543           1 :     a[1] = (VALUE)(&v);
    2544           1 :     if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
    2545           1 :       if (val) *val = v;
    2546           1 :       return SWIG_OK;
    2547             :     }
    2548             :   }
    2549             :   return SWIG_TypeError;
    2550             : }
    2551             : 
    2552             : 
    2553             : #include <limits.h>
    2554             : #if !defined(SWIG_NO_LLONG_MAX)
    2555             : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
    2556             : #   define LLONG_MAX __LONG_LONG_MAX__
    2557             : #   define LLONG_MIN (-LLONG_MAX - 1LL)
    2558             : #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
    2559             : # endif
    2560             : #endif
    2561             : 
    2562             : 
    2563             : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
    2564             : #  define SWIG_LONG_LONG_AVAILABLE
    2565             : #endif
    2566             : 
    2567             : 
    2568             : #ifdef SWIG_LONG_LONG_AVAILABLE
    2569             : /*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
    2570             : SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE *args)
    2571             : {
    2572             :   VALUE obj = args[0];
    2573             :   VALUE type = TYPE(obj);
    2574             :   long long *res = (long long *)(args[1]);
    2575             :   *res = type == T_FIXNUM ? NUM2ULL(obj) : rb_big2ull(obj);
    2576             :   return obj;
    2577             : }
    2578             : /*@SWIG@*/
    2579             : 
    2580             : SWIGINTERN int
    2581             : SWIG_AsVal_unsigned_SS_long_SS_long (VALUE obj, unsigned long long *val)
    2582             : { 
    2583             :   VALUE type = TYPE(obj);
    2584             :   if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    2585             :     unsigned long long v;
    2586             :     VALUE a[2];
    2587             :     a[0] = obj;
    2588             :     a[1] = (VALUE)(&v);
    2589             :     if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
    2590             :       if (val) *val = v;
    2591             :       return SWIG_OK;
    2592             :     }
    2593             :   }
    2594             :   return SWIG_TypeError;
    2595             : }
    2596             : #endif
    2597             : 
    2598             : 
    2599             : SWIGINTERNINLINE int
    2600             : SWIG_AsVal_size_t (VALUE obj, size_t *val)
    2601             : {
    2602           1 :   int res = SWIG_TypeError;
    2603             : #ifdef SWIG_LONG_LONG_AVAILABLE
    2604             :   if (sizeof(size_t) <= sizeof(unsigned long)) {
    2605             : #endif
    2606             :     unsigned long v;
    2607           1 :     res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    2608           1 :     if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
    2609             : #ifdef SWIG_LONG_LONG_AVAILABLE
    2610             :   } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    2611             :     unsigned long long v;
    2612             :     res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    2613             :     if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
    2614             :   }
    2615             : #endif
    2616             :   return res;
    2617             : }
    2618             : 
    2619             : 
    2620             : SWIGINTERNINLINE VALUE
    2621             : SWIG_From_bool  (bool value)
    2622             : {
    2623           2 :   return value ? Qtrue : Qfalse;
    2624             : }
    2625             : 
    2626             : 
    2627             : /*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
    2628           0 : SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
    2629             : {
    2630           0 :   VALUE obj = args[0];
    2631           0 :   VALUE type = TYPE(obj);
    2632           0 :   long *res = (long *)(args[1]);
    2633           0 :   *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
    2634           0 :   return obj;
    2635             : }
    2636             : /*@SWIG@*/
    2637             : 
    2638             : SWIGINTERN int
    2639           0 : SWIG_AsVal_long (VALUE obj, long* val)
    2640             : {
    2641           0 :   VALUE type = TYPE(obj);
    2642           0 :   if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    2643             :     long v;
    2644             :     VALUE a[2];
    2645           0 :     a[0] = obj;
    2646           0 :     a[1] = (VALUE)(&v);
    2647           0 :     if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
    2648           0 :       if (val) *val = v;
    2649           0 :       return SWIG_OK;
    2650             :     }
    2651             :   }
    2652             :   return SWIG_TypeError;
    2653             : }
    2654             : 
    2655             : 
    2656             : #ifdef SWIG_LONG_LONG_AVAILABLE
    2657             : /*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
    2658             : SWIGINTERN VALUE SWIG_AUX_NUM2LL(VALUE *args)
    2659             : {
    2660             :   VALUE obj = args[0];
    2661             :   VALUE type = TYPE(obj);
    2662             :   long long *res = (long long *)(args[1]);
    2663             :   *res = type == T_FIXNUM ? NUM2LL(obj) : rb_big2ll(obj);
    2664             :   return obj;
    2665             : }
    2666             : /*@SWIG@*/
    2667             : 
    2668             : SWIGINTERN int
    2669             : SWIG_AsVal_long_SS_long (VALUE obj, long long *val)
    2670             : {
    2671             :   VALUE type = TYPE(obj);
    2672             :   if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
    2673             :     long long v;
    2674             :     VALUE a[2];
    2675             :     a[0] = obj;
    2676             :     a[1] = (VALUE)(&v);
    2677             :     if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
    2678             :       if (val) *val = v;
    2679             :       return SWIG_OK;
    2680             :     }
    2681             :   }
    2682             :   return SWIG_TypeError;
    2683             : }
    2684             : #endif
    2685             : 
    2686             : 
    2687             : SWIGINTERNINLINE int
    2688             : SWIG_AsVal_ptrdiff_t (VALUE obj, ptrdiff_t *val)
    2689             : {
    2690           0 :   int res = SWIG_TypeError;
    2691             : #ifdef SWIG_LONG_LONG_AVAILABLE
    2692             :   if (sizeof(ptrdiff_t) <= sizeof(long)) {
    2693             : #endif
    2694             :     long v;
    2695           0 :     res = SWIG_AsVal_long (obj, val ? &v : 0);
    2696           0 :     if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
    2697             : #ifdef SWIG_LONG_LONG_AVAILABLE
    2698             :   } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
    2699             :     long long v;
    2700             :     res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
    2701             :     if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
    2702             :   }
    2703             : #endif
    2704             :   return res;
    2705             : }
    2706             : 
    2707             : 
    2708             :   #define SWIG_From_long   LONG2NUM 
    2709             : 
    2710             : 
    2711             : #ifdef SWIG_LONG_LONG_AVAILABLE
    2712             : SWIGINTERNINLINE VALUE 
    2713             : SWIG_From_long_SS_long  (long long value)
    2714             : {
    2715             :   return LL2NUM(value);
    2716             : }
    2717             : #endif
    2718             : 
    2719             : 
    2720             : SWIGINTERNINLINE VALUE
    2721             : SWIG_From_ptrdiff_t  (ptrdiff_t value)
    2722             : {    
    2723             : #ifdef SWIG_LONG_LONG_AVAILABLE
    2724             :   if (sizeof(ptrdiff_t) <= sizeof(long)) {
    2725             : #endif
    2726           0 :     return SWIG_From_long  (static_cast< long >(value));
    2727             : #ifdef SWIG_LONG_LONG_AVAILABLE
    2728             :   } else {
    2729             :     /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
    2730             :     return SWIG_From_long_SS_long  (static_cast< long long >(value));
    2731             :   }
    2732             : #endif
    2733             : }
    2734             : 
    2735             : 
    2736             : #include <algorithm>
    2737             : 
    2738             : 
    2739             : #include <vector>
    2740             : 
    2741             : 
    2742             : #include <utility>
    2743             : 
    2744             : 
    2745             : #include <map>
    2746             : 
    2747             : 
    2748             : #include <algorithm>
    2749             : 
    2750             : 
    2751             : #include <stdint.h>               // Use the C99 official header
    2752             : 
    2753             : 
    2754             : SWIGINTERNINLINE VALUE
    2755             : SWIG_From_int  (int value)
    2756             : {    
    2757          50 :   return SWIG_From_long  (value);
    2758             : }
    2759             : 
    2760             : 
    2761             : SWIGINTERN swig_type_info*
    2762           0 : SWIG_pchar_descriptor(void)
    2763             : {
    2764             :   static int init = 0;
    2765             :   static swig_type_info* info = 0;
    2766           0 :   if (!init) {
    2767           0 :     info = SWIG_TypeQuery("_p_char");
    2768           0 :     init = 1;
    2769             :   }
    2770           0 :   return info;
    2771             : }
    2772             : 
    2773             : 
    2774             : SWIGINTERN int
    2775          21 : SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
    2776             : {
    2777          21 :   if (TYPE(obj) == T_STRING) {
    2778          21 :     char *cstr = StringValuePtr(obj); 
    2779          21 :     size_t size = RSTRING_LEN(obj) + 1;
    2780          21 :     if (cptr)  {
    2781          21 :       if (alloc) {
    2782          21 :         if (*alloc == SWIG_NEWOBJ) {
    2783           0 :           *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size)));
    2784             :         } else {
    2785          21 :           *cptr = cstr;
    2786          21 :           *alloc = SWIG_OLDOBJ;
    2787             :         }
    2788             :       }
    2789             :     }
    2790          21 :     if (psize) *psize = size;
    2791             :     return SWIG_OK;
    2792             :   } else {
    2793           0 :     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    2794           0 :     if (pchar_descriptor) {
    2795           0 :       void* vptr = 0;
    2796           0 :       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
    2797           0 :         if (cptr) *cptr = (char *)vptr;
    2798           0 :         if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
    2799           0 :         if (alloc) *alloc = SWIG_OLDOBJ;
    2800           0 :         return SWIG_OK;
    2801             :       }
    2802             :     }
    2803             :   }  
    2804             :   return SWIG_TypeError;
    2805             : }
    2806             : 
    2807             : 
    2808             : SWIGINTERN int
    2809          21 : SWIG_AsPtr_std_string (VALUE obj, std::string **val) 
    2810             : {
    2811          21 :   char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
    2812          21 :   if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
    2813          21 :     if (buf) {
    2814          84 :       if (val) *val = new std::string(buf, size - 1);
    2815          21 :       if (alloc == SWIG_NEWOBJ) delete[] buf;
    2816             :       return SWIG_NEWOBJ;
    2817             :     } else {
    2818           0 :       if (val) *val = 0;
    2819             :       return SWIG_OLDOBJ;
    2820             :     }
    2821             :   } else {
    2822             :     static int init = 0;
    2823             :     static swig_type_info* descriptor = 0;
    2824           0 :     if (!init) {
    2825           0 :       descriptor = SWIG_TypeQuery("std::string" " *");
    2826           0 :       init = 1;
    2827             :     }
    2828           0 :     if (descriptor) {
    2829             :       std::string *vptr;
    2830           0 :       int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
    2831           0 :       if (SWIG_IsOK(res) && val) *val = vptr;
    2832             :       return res;
    2833             :     }
    2834             :   }
    2835             :   return SWIG_ERROR;
    2836             : }
    2837             : 
    2838             : 
    2839             : SWIGINTERN int
    2840           0 : SWIG_AsVal_std_string (VALUE obj, std::string *val)
    2841             : {
    2842           0 :   std::string* v = (std::string *) 0;
    2843           0 :   int res = SWIG_AsPtr_std_string (obj, &v);
    2844           0 :   if (!SWIG_IsOK(res)) return res;
    2845           0 :   if (v) {
    2846           0 :     if (val) *val = *v;
    2847           0 :     if (SWIG_IsNewObj(res)) {
    2848           0 :       delete v;
    2849           0 :       res = SWIG_DelNewMask(res);
    2850             :     }
    2851             :     return res;
    2852             :   }
    2853             :   return SWIG_ERROR;
    2854             : }
    2855             : 
    2856             : 
    2857             : SWIGINTERNINLINE VALUE 
    2858         352 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
    2859             : {
    2860         352 :   if (carray) {
    2861         352 :     if (size > LONG_MAX) {
    2862           0 :       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    2863           0 :       return pchar_descriptor ? 
    2864             :         SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
    2865             :     } else {
    2866         352 :       return rb_str_new(carray, static_cast< long >(size));
    2867             :     }
    2868             :   } else {
    2869             :     return Qnil;
    2870             :   }
    2871             : }
    2872             : 
    2873             : 
    2874             : SWIGINTERNINLINE VALUE
    2875             : SWIG_From_std_string  (const std::string& s)
    2876             : {
    2877         359 :   return SWIG_FromCharPtrAndSize(s.data(), s.size());
    2878             : }
    2879             : 
    2880             : 
    2881             : namespace swig {
    2882             :   template <class Type>
    2883             :   struct noconst_traits {
    2884             :     typedef Type noconst_type;
    2885             :   };
    2886             : 
    2887             :   template <class Type>
    2888             :   struct noconst_traits<const Type> {
    2889             :     typedef Type noconst_type;
    2890             :   };
    2891             : 
    2892             :   /*
    2893             :     type categories
    2894             :   */
    2895             :   struct pointer_category { };
    2896             :   struct value_category { };
    2897             : 
    2898             :   /*
    2899             :     General traits that provides type_name and type_info
    2900             :   */
    2901             :   template <class Type> struct traits { };
    2902             : 
    2903             :   template <class Type>
    2904             :   inline const char* type_name() {
    2905             :     return traits<typename noconst_traits<Type >::noconst_type >::type_name();
    2906             :   }
    2907             : 
    2908             :   template <class Type>
    2909             :   struct traits_info {
    2910           4 :     static swig_type_info *type_query(std::string name) {
    2911           4 :       name += " *";
    2912           4 :       return SWIG_TypeQuery(name.c_str());
    2913             :     }
    2914          11 :     static swig_type_info *type_info() {
    2915          23 :       static swig_type_info *info = type_query(type_name<Type>());
    2916          11 :       return info;
    2917             :     }
    2918             :   };
    2919             : 
    2920             :   template <class Type>
    2921             :   inline swig_type_info *type_info() {
    2922          11 :     return traits_info<Type>::type_info();
    2923             :   }
    2924             : 
    2925             :   /*
    2926             :     Partial specialization for pointers
    2927             :   */
    2928             :   template <class Type> struct traits <Type *> {
    2929             :     typedef pointer_category category;
    2930             :     static std::string make_ptr_name(const char* name) {
    2931             :       std::string ptrname = name;
    2932             :       ptrname += " *";
    2933             :       return ptrname;
    2934             :     }
    2935             :     static const char* type_name() {
    2936             :       static std::string name = make_ptr_name(swig::type_name<Type>());
    2937             :       return name.c_str();
    2938             :     }
    2939             :   };
    2940             : 
    2941             :   template <class Type, class Category>
    2942             :   struct traits_as { };
    2943             : 
    2944             :   template <class Type, class Category>
    2945             :   struct traits_check { };
    2946             : 
    2947             : }
    2948             : 
    2949             : 
    2950             : 
    2951             : namespace swig {  
    2952             :   /*
    2953             :     Traits that provides the from method
    2954             :   */
    2955             :   template <class Type> struct traits_from_ptr {
    2956             :     static VALUE from(Type *val, int owner = 0) {
    2957          10 :       return SWIG_NewPointerObj(val, type_info<Type>(), owner);
    2958             :     }
    2959             :   };
    2960             : 
    2961             :   template <class Type> struct traits_from {
    2962          10 :     static VALUE from(const Type& val) {
    2963          21 :       return traits_from_ptr<Type>::from(new Type(val), 1);
    2964             :     }
    2965             :   };
    2966             : 
    2967             :   template <class Type> struct traits_from<Type *> {
    2968           0 :     static VALUE from(Type* val) {
    2969           0 :       return traits_from_ptr<Type>::from(val, 0);
    2970             :     }
    2971             :   };
    2972             : 
    2973             :   template <class Type> struct traits_from<const Type *> {
    2974           0 :     static VALUE from(const Type* val) {
    2975           0 :       return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
    2976             :     }
    2977             :   };
    2978             : 
    2979             : 
    2980             :   template <class Type>
    2981             :   inline VALUE from(const Type& val) {
    2982         341 :     return traits_from<Type>::from(val);
    2983             :   }
    2984             : 
    2985             :   template <class Type>
    2986             :   inline VALUE from_ptr(Type* val, int owner) {
    2987             :     return traits_from_ptr<Type>::from(val, owner);
    2988             :   }
    2989             : 
    2990             :   /*
    2991             :     Traits that provides the asval/as/check method
    2992             :   */
    2993             :   template <class Type>
    2994             :   struct traits_asptr {   
    2995           0 :     static int asptr(VALUE obj, Type **val) {
    2996             :       Type *p;
    2997           0 :       int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
    2998           0 :       if (SWIG_IsOK(res)) {
    2999           0 :         if (val) *val = p;
    3000             :       }
    3001           0 :       return res;
    3002             :     }
    3003             :   }; 
    3004             : 
    3005             :   template <class Type>
    3006             :   inline int asptr(VALUE obj, Type **vptr) {
    3007           0 :     return traits_asptr<Type>::asptr(obj, vptr);
    3008             :   }
    3009             : 
    3010             :   template <class Type> 
    3011             :   struct traits_asval {
    3012           0 :     static int asval(VALUE obj, Type *val) {
    3013           0 :       if (val) {
    3014           0 :         Type *p = 0;
    3015           0 :         int res = traits_asptr<Type>::asptr(obj, &p);
    3016           0 :         if (!SWIG_IsOK(res)) return res;        
    3017           0 :         if (p) {
    3018             :           typedef typename noconst_traits<Type>::noconst_type noconst_type;
    3019           0 :           *(const_cast<noconst_type*>(val)) = *p;
    3020           0 :           if (SWIG_IsNewObj(res)){
    3021           0 :             delete p;
    3022           0 :             res = SWIG_DelNewMask(res);
    3023             :           }
    3024             :           return res;
    3025             :         } else {
    3026             :           return SWIG_ERROR;
    3027             :         }
    3028             :       } else {
    3029           0 :         return traits_asptr<Type>::asptr(obj, (Type **)(0));
    3030             :       }
    3031             :     }
    3032             :   };
    3033             : 
    3034             :   template <class Type> struct traits_asval<Type*> {
    3035             :     static int asval(VALUE obj, Type **val) {
    3036             :       if (val) {
    3037             :         typedef typename noconst_traits<Type>::noconst_type noconst_type;
    3038             :         noconst_type *p = 0;
    3039             :         int res = traits_asptr<noconst_type>::asptr(obj,  &p);
    3040             :         if (SWIG_IsOK(res)) {
    3041             :           *(const_cast<noconst_type**>(val)) = p;
    3042             :         }
    3043             :         return res;
    3044             :       } else {
    3045             :         return traits_asptr<Type>::asptr(obj, (Type **)(0));
    3046             :       }
    3047             :     }
    3048             :   };
    3049             :   
    3050             :   template <class Type>
    3051             :   inline int asval(VALUE obj, Type *val) {
    3052           0 :     return traits_asval<Type>::asval(obj, val);
    3053             :   }
    3054             : 
    3055             :   template <class Type> 
    3056             :   struct traits_as<Type, value_category> {
    3057           0 :     static Type as(VALUE obj, bool throw_error) {
    3058           0 :       Type v;
    3059           0 :       int res = asval(obj, &v);
    3060           0 :       if (!obj || !SWIG_IsOK(res)) {
    3061           0 :         if (throw_error) throw std::invalid_argument("bad type");
    3062           0 :         VALUE lastErr = rb_gv_get("$!");
    3063           0 :         if (lastErr == Qnil) {
    3064           0 :           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
    3065             :         }
    3066             :       }
    3067           0 :       return v;
    3068             :     }
    3069             :   };
    3070             : 
    3071             :   template <class Type> 
    3072             :   struct traits_as<Type, pointer_category> {
    3073           0 :     static Type as(VALUE obj, bool throw_error) {
    3074           0 :       Type *v = 0;      
    3075           0 :       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
    3076           0 :       if (SWIG_IsOK(res) && v) {
    3077           0 :         if (SWIG_IsNewObj(res)) {
    3078           0 :           Type r(*v);
    3079           0 :           delete v;
    3080           0 :           return r;
    3081             :         } else {
    3082           0 :           return *v;
    3083             :         }
    3084             :       } else {
    3085             :         // Uninitialized return value, no Type() constructor required.
    3086           0 :         if (throw_error) throw std::invalid_argument("bad type");
    3087           0 :         VALUE lastErr = rb_gv_get("$!");
    3088           0 :         if (lastErr == Qnil) {
    3089           0 :           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
    3090             :         }
    3091           0 :         static Type *v_def = (Type*) malloc(sizeof(Type));
    3092           0 :         memset(v_def,0,sizeof(Type));
    3093           0 :         return *v_def;
    3094             :       }
    3095             :     }
    3096             :   };
    3097             : 
    3098             :   template <class Type> 
    3099             :   struct traits_as<Type*, pointer_category> {
    3100             :     static Type* as(VALUE obj, bool throw_error) {
    3101             :       Type *v = 0;      
    3102             :       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
    3103             :       if (SWIG_IsOK(res)) {
    3104             :         return v;
    3105             :       } else {
    3106             :         if (throw_error) throw std::invalid_argument("bad type");
    3107             :         VALUE lastErr = rb_gv_get("$!");
    3108             :         if (lastErr == Qnil) {
    3109             :           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
    3110             :         }
    3111             :         return 0;
    3112             :       }
    3113             :     }
    3114             :   };
    3115             : 
    3116             :   template <class Type>
    3117             :   inline Type as(VALUE obj, bool te = false) {
    3118           0 :     return traits_as< Type, typename traits< Type >::category >::as(obj, te);
    3119             :   }
    3120             : 
    3121             :   template <class Type> 
    3122             :   struct traits_check<Type, value_category> {
    3123             :     static bool check(VALUE obj) {
    3124           0 :       int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
    3125             :       return SWIG_IsOK(res) ? true : false;
    3126             :     }
    3127             :   };
    3128             : 
    3129             :   template <class Type> 
    3130             :   struct traits_check<Type, pointer_category> {
    3131             :     static bool check(VALUE obj) {
    3132           0 :       int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
    3133             :       return SWIG_IsOK(res) ? true : false;
    3134             :     }
    3135             :   };
    3136             : 
    3137             :   template <class Type>
    3138             :   inline bool check(VALUE obj) {
    3139           0 :     return traits_check<Type, typename traits<Type>::category>::check(obj);
    3140             :   }
    3141             : }
    3142             : 
    3143             : 
    3144             : namespace swig {
    3145             :   template <> struct traits< std::string > {
    3146             :     typedef value_category category;
    3147             :     static const char* type_name() { return"std::string"; }
    3148             :   };
    3149             :   template <>  struct traits_asval< std::string > {
    3150             :     typedef std::string value_type;
    3151             :     static int asval(VALUE obj, value_type *val) {
    3152           0 :       return SWIG_AsVal_std_string (obj, val);
    3153             :     }
    3154             :   };
    3155             :   template <>  struct traits_from< std::string > {
    3156             :     typedef std::string value_type;
    3157             :     static VALUE from(const value_type& val) {
    3158         321 :       return SWIG_From_std_string  (val);
    3159             :     }
    3160             :   };
    3161             : }
    3162             : 
    3163             : 
    3164             : #include <functional>
    3165             : 
    3166             : 
    3167             : namespace swig {
    3168             :   template < class T >
    3169             :   struct yield : public std::unary_function< T, bool >
    3170             :   {
    3171             :     bool
    3172           0 :     operator()( const T& v ) const
    3173             :     { 
    3174           0 :       return RTEST( rb_yield( swig::from< T >(v) ) );
    3175             :     }
    3176             :   };
    3177             : 
    3178             : 
    3179             :   inline size_t
    3180           0 :   check_index(ptrdiff_t i, size_t size, bool insert = false) {
    3181           0 :     if ( i < 0 ) {
    3182           0 :       if ((size_t) (-i) <= size)
    3183           0 :         return (size_t) (i + size);
    3184           0 :     } else if ( (size_t) i < size ) {
    3185             :       return (size_t) i;
    3186           0 :     } else if (insert && ((size_t) i == size)) {
    3187             :       return size;
    3188             :     }
    3189             :     
    3190           0 :     throw std::out_of_range("index out of range");
    3191             :   }
    3192             : 
    3193             :   inline size_t
    3194           0 :   slice_index(ptrdiff_t i, size_t size) {
    3195           0 :     if ( i < 0 ) {
    3196           0 :       if ((size_t) (-i) <= size) {
    3197           0 :         return (size_t) (i + size);
    3198             :       } else {
    3199           0 :         throw std::out_of_range("index out of range");
    3200             :       }
    3201             :     } else {
    3202           0 :       return ( (size_t) i < size ) ? ((size_t) i) : size;
    3203             :     }
    3204             :   }
    3205             : 
    3206             :   template <class Sequence, class Difference>
    3207             :   inline typename Sequence::iterator
    3208             :   getpos(Sequence* self, Difference i)  {
    3209           0 :     typename Sequence::iterator pos = self->begin();
    3210           0 :     std::advance(pos, check_index(i,self->size()));
    3211             :     return pos;
    3212             :   }
    3213             : 
    3214             :   template <class Sequence, class Difference>
    3215             :   inline typename Sequence::const_iterator
    3216             :   cgetpos(const Sequence* self, Difference i)  {
    3217           0 :     typename Sequence::const_iterator pos = self->begin();
    3218           0 :     std::advance(pos, check_index(i,self->size()));
    3219             :     return pos;
    3220             :   }
    3221             : 
    3222             :   template <class Sequence>
    3223             :   inline void
    3224             :   resize(Sequence *seq, typename Sequence::size_type n, typename Sequence::value_type x) {
    3225           0 :     seq->resize(n, x);
    3226             :   }
    3227             : 
    3228             :   template <class Sequence, class Difference>
    3229             :   inline Sequence*
    3230           0 :   getslice(const Sequence* self, Difference i, Difference j) {
    3231           0 :     typename Sequence::size_type size = self->size();
    3232           0 :     typename Sequence::size_type ii = swig::check_index(i, size, (i == size && j == size));
    3233           0 :     typename Sequence::size_type jj = swig::slice_index(j, size);
    3234             : 
    3235           0 :     if (jj > ii) {
    3236           0 :       typename Sequence::const_iterator vb = self->begin();
    3237           0 :       typename Sequence::const_iterator ve = self->begin();
    3238           0 :       std::advance(vb,ii);
    3239           0 :       std::advance(ve,jj);
    3240           0 :       return new Sequence(vb, ve);
    3241             :     } else {
    3242           0 :       return new Sequence();
    3243             :     }
    3244             :   }
    3245             : 
    3246             :   template <class Sequence, class Difference, class InputSeq>
    3247             :   inline void
    3248           0 :   setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
    3249           0 :     typename Sequence::size_type size = self->size();
    3250           0 :     typename Sequence::size_type ii = swig::check_index(i, size, true);
    3251           0 :     typename Sequence::size_type jj = swig::slice_index(j, size);
    3252           0 :     if (jj < ii) jj = ii;
    3253           0 :     size_t ssize = jj - ii;
    3254           0 :     if (ssize <= v.size()) {
    3255           0 :       typename Sequence::iterator sb = self->begin();
    3256           0 :       typename InputSeq::const_iterator vmid = v.begin();
    3257           0 :       std::advance(sb,ii);
    3258           0 :       std::advance(vmid, jj - ii);
    3259           0 :       self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
    3260             :     } else {
    3261           0 :       typename Sequence::iterator sb = self->begin();
    3262           0 :       typename Sequence::iterator se = self->begin();
    3263           0 :       std::advance(sb,ii);
    3264           0 :       std::advance(se,jj);
    3265           0 :       self->erase(sb,se);
    3266           0 :       self->insert(sb, v.begin(), v.end());
    3267             :     }
    3268           0 :   }
    3269             : 
    3270             :   template <class Sequence, class Difference>
    3271             :   inline void
    3272             :   delslice(Sequence* self, Difference i, Difference j) {
    3273             :     typename Sequence::size_type size = self->size();
    3274             :     typename Sequence::size_type ii = swig::check_index(i, size, true);
    3275             :     typename Sequence::size_type jj = swig::slice_index(j, size);
    3276             :     if (jj > ii) {
    3277             :       typename Sequence::iterator sb = self->begin();
    3278             :       typename Sequence::iterator se = self->begin();
    3279             :       std::advance(sb,ii);
    3280             :       std::advance(se,jj);
    3281             :       self->erase(sb,se);
    3282             :     }
    3283             :   }
    3284             : }
    3285             : 
    3286             : 
    3287             : #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
    3288             : #  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
    3289             : #    define SWIG_STD_NOITERATOR_TRAITS_STL
    3290             : #  endif
    3291             : #endif
    3292             : 
    3293             : #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
    3294             : #include <iterator>
    3295             : #else
    3296             : namespace std {
    3297             :   template <class Iterator>
    3298             :   struct iterator_traits {
    3299             :     typedef ptrdiff_t difference_type;
    3300             :     typedef typename Iterator::value_type value_type;
    3301             :   };
    3302             : 
    3303             :   template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
    3304             :   struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
    3305             :     typedef Distance difference_type;
    3306             :     typedef T value_type;
    3307             :   };
    3308             : 
    3309             :   template <class T>
    3310             :   struct iterator_traits<T*> {
    3311             :     typedef T value_type;
    3312             :     typedef ptrdiff_t difference_type;
    3313             :   };
    3314             : 
    3315             :   template<typename _InputIterator>
    3316             :   inline typename iterator_traits<_InputIterator>::difference_type
    3317             :   distance(_InputIterator __first, _InputIterator __last)
    3318             :   {
    3319             :     typename iterator_traits<_InputIterator>::difference_type __n = 0;
    3320             :     while (__first != __last) {
    3321             :       ++__first; ++__n;
    3322             :     }
    3323             :     return __n;
    3324             :   }
    3325             : }
    3326             : #endif
    3327             : 
    3328             : 
    3329             : namespace swig {
    3330             : 
    3331             :   /** 
    3332             :    * Templated base classes for all custom const_iterators.
    3333             :    *
    3334             :    */
    3335             :   template<typename OutConstIterator>
    3336           0 :   class ConstIterator_T :  public ConstIterator
    3337             :   {
    3338             :   public:
    3339             :     typedef OutConstIterator const_iter;
    3340             :     typedef typename std::iterator_traits<const_iter>::value_type value_type;    
    3341             :     typedef ConstIterator_T<const_iter> self_type;
    3342             : 
    3343             :   protected:
    3344             : 
    3345             :     
    3346           0 :     virtual bool equal (const ConstIterator &iter) const
    3347             :     {
    3348           0 :       const self_type *iters = dynamic_cast<const self_type *>(&iter);
    3349           0 :       if (iters) {
    3350           0 :         return (current == iters->get_current());
    3351             :       } else {
    3352           0 :         throw std::invalid_argument("bad iterator type");
    3353             :       }
    3354             :     }
    3355             :     
    3356           0 :     virtual ptrdiff_t distance(const ConstIterator &iter) const
    3357             :     {
    3358           0 :       const self_type *iters = dynamic_cast<const self_type *>(&iter);
    3359           0 :       if (iters) {
    3360           0 :         return std::distance(current, iters->get_current());
    3361             :       } else {
    3362           0 :         throw std::invalid_argument("bad iterator type");
    3363             :       }
    3364             :     }
    3365             : 
    3366           0 :     virtual ConstIterator* advance(ptrdiff_t n)
    3367             :     {
    3368           0 :       std::advance( current, n );
    3369           0 :       return this;
    3370             :     }
    3371             : 
    3372             :   public:
    3373             :     ConstIterator_T() : ConstIterator(Qnil)
    3374             :     {
    3375             :     }
    3376             : 
    3377           0 :     ConstIterator_T(const_iter curr, VALUE seq = Qnil)
    3378           0 :       : ConstIterator(seq), current(curr)
    3379             :     {
    3380             :     }
    3381             : 
    3382             :     const const_iter& get_current() const
    3383             :     {
    3384             :       return current;
    3385             :     }
    3386             : 
    3387             :     const value_type& operator*() const
    3388             :     {
    3389             :       return *current;
    3390             :     }
    3391             : 
    3392           0 :     virtual VALUE inspect() const
    3393             :     {
    3394           0 :       VALUE ret = rb_str_new2("#<");
    3395           0 :       ret = rb_str_cat2( ret, rb_obj_classname(_seq) );
    3396           0 :       ret = rb_str_cat2( ret, "::const_iterator " );
    3397           0 :       VALUE cur = value();
    3398           0 :       ret = rb_str_concat( ret, rb_inspect(cur) );
    3399           0 :       ret = rb_str_cat2( ret, ">" );
    3400           0 :       return ret;
    3401             :     }
    3402             : 
    3403           0 :     virtual VALUE to_s()    const
    3404             :     {
    3405           0 :       VALUE ret = rb_str_new2( rb_obj_classname(_seq) );
    3406           0 :       ret = rb_str_cat2( ret, "::const_iterator " );
    3407           0 :       VALUE cur = value();
    3408           0 :       ret = rb_str_concat( ret, rb_obj_as_string(cur) );
    3409           0 :       return ret;
    3410             :     }
    3411             : 
    3412             :   protected:
    3413             :     const_iter current;
    3414             :   };
    3415             : 
    3416             : 
    3417             :   /** 
    3418             :    * Templated base classes for all custom non-const iterators.
    3419             :    *
    3420             :    */
    3421             :   template<typename InOutIterator>
    3422             :   class Iterator_T :  public Iterator
    3423             :   {
    3424             :   public:
    3425             :     typedef InOutIterator nonconst_iter;
    3426             : 
    3427             :     // Make this class iterator STL compatible, by using iterator_traits
    3428             :     typedef typename std::iterator_traits<nonconst_iter >::iterator_category iterator_category;
    3429             :     typedef typename std::iterator_traits<nonconst_iter >::value_type        value_type;
    3430             :     typedef typename std::iterator_traits<nonconst_iter >::difference_type   difference_type;
    3431             :     typedef typename std::iterator_traits<nonconst_iter >::pointer           pointer;
    3432             :     typedef typename std::iterator_traits<nonconst_iter >::reference         reference;
    3433             : 
    3434             :     typedef Iterator                         base;
    3435             :     typedef Iterator_T< nonconst_iter > self_type;
    3436             : 
    3437             :   protected:
    3438             : 
    3439             :     virtual bool equal (const ConstIterator &iter) const
    3440             :     {
    3441             :       const self_type *iters = dynamic_cast<const self_type *>(&iter);
    3442             :       if (iters) {
    3443             :         return (current == iters->get_current());
    3444             :       } else {
    3445             :         throw std::invalid_argument("bad iterator type");
    3446             :       }
    3447             :     }
    3448             :     
    3449             :     virtual ptrdiff_t distance(const ConstIterator &iter) const
    3450             :     {
    3451             :       const self_type *iters = dynamic_cast<const self_type *>(&iter);
    3452             :       if (iters) {
    3453             :         return std::distance(current, iters->get_current());
    3454             :       } else {
    3455             :         throw std::invalid_argument("bad iterator type");
    3456             :       }
    3457             :     }
    3458             : 
    3459             :     virtual Iterator* advance(ptrdiff_t n)
    3460             :     {
    3461             :       std::advance( current, n );
    3462             :       return this;
    3463             :     }
    3464             : 
    3465             :   public:
    3466             : 
    3467             :     Iterator_T(nonconst_iter curr, VALUE seq = Qnil)
    3468             :       : Iterator(seq), current(curr)
    3469             :     {
    3470             :     }
    3471             : 
    3472             :     const nonconst_iter& get_current() const
    3473             :     {
    3474             :       return current;
    3475             :     }
    3476             : 
    3477             :     self_type& operator=( const self_type& b )
    3478             :     {
    3479             :       base::operator=( b );
    3480             :       return *this;
    3481             :     }
    3482             :     
    3483             :     self_type& operator=( const value_type& b )
    3484             :     {
    3485             :       *current = b;
    3486             :       return *this;
    3487             :     }
    3488             : 
    3489             :     const value_type& operator*() const
    3490             :     {
    3491             :       return *current;
    3492             :     }
    3493             : 
    3494             :     value_type& operator*()
    3495             :     {
    3496             :       return *current;
    3497             :     }
    3498             :     
    3499             :     virtual VALUE inspect() const
    3500             :     {
    3501             :       VALUE ret = rb_str_new2("#<");
    3502             :       ret = rb_str_cat2( ret, rb_obj_classname(_seq) );
    3503             :       ret = rb_str_cat2( ret, "::iterator " );
    3504             :       VALUE cur = value();
    3505             :       ret = rb_str_concat( ret, rb_inspect(cur) );
    3506             :       ret = rb_str_cat2( ret, ">" );
    3507             :       return ret;
    3508             :     }
    3509             : 
    3510             :     virtual VALUE to_s()    const
    3511             :     {
    3512             :       VALUE ret = rb_str_new2( rb_obj_classname(_seq) );
    3513             :       ret = rb_str_cat2( ret, "::iterator " );
    3514             :       VALUE cur = value();
    3515             :       ret = rb_str_concat( ret, rb_obj_as_string(cur) );
    3516             :       return ret;
    3517             :     }
    3518             : 
    3519             :   protected:
    3520             :     nonconst_iter current;
    3521             :   };
    3522             : 
    3523             : 
    3524             :   /**
    3525             :    * Auxiliary functor to store the value of a ruby object inside
    3526             :    * a reference of a compatible C++ type.  ie: Ruby -> C++
    3527             :    * 
    3528             :    */
    3529             :   template <class ValueType>
    3530             :   struct asval_oper 
    3531             :   {
    3532             :     typedef ValueType    value_type;
    3533             :     typedef bool        result_type;
    3534             :     bool operator()(VALUE obj, value_type& v) const
    3535             :     {
    3536             :       return ( swig::asval< value_type >(obj, &v) == SWIG_OK );
    3537             :     }
    3538             :   };
    3539             : 
    3540             :   /**
    3541             :    * Auxiliary functor to return a ruby object from a C++ type. 
    3542             :    * ie: C++ -> Ruby
    3543             :    * 
    3544             :    */
    3545             :   template <class ValueType>
    3546             :   struct from_oper 
    3547             :   {
    3548             :     typedef const ValueType& argument_type;
    3549             :     typedef VALUE result_type;
    3550             :     result_type operator()(argument_type v) const
    3551             :     {
    3552             :       return swig::from(v);
    3553             :     }
    3554             :   };
    3555             : 
    3556             : 
    3557             :   /** 
    3558             :    * ConstIterator class for a const_iterator with no end() boundaries.
    3559             :    *
    3560             :    */
    3561             :   template<typename OutConstIterator, 
    3562             :            typename ValueType = typename std::iterator_traits<OutConstIterator>::value_type,
    3563             :            typename FromOper = from_oper<ValueType> >
    3564             :   class ConstIteratorOpen_T :  public ConstIterator_T<OutConstIterator>
    3565             :   {
    3566             :   public:
    3567             :     FromOper from;
    3568             :     typedef OutConstIterator const_iter;
    3569             :     typedef ValueType value_type;
    3570             :     typedef ConstIterator_T<const_iter>  base;
    3571             :     typedef ConstIteratorOpen_T<OutConstIterator, ValueType, FromOper> self_type;
    3572             :     
    3573             :     ConstIteratorOpen_T(const_iter curr, VALUE seq = Qnil)
    3574             :       : ConstIterator_T<OutConstIterator>(curr, seq)
    3575             :     {
    3576             :     }
    3577             :     
    3578             :     virtual VALUE value() const {
    3579             :       return from(static_cast<const value_type&>(*(base::current)));
    3580             :     }
    3581             :     
    3582             :     ConstIterator *dup() const
    3583             :     {
    3584             :       return new self_type(*this);
    3585             :     }
    3586             :   };
    3587             : 
    3588             :   /** 
    3589             :    * Iterator class for an iterator with no end() boundaries.
    3590             :    *
    3591             :    */
    3592             :   template<typename InOutIterator, 
    3593             :            typename ValueType = typename std::iterator_traits<InOutIterator>::value_type,
    3594             :            typename FromOper = from_oper<ValueType>,
    3595             :            typename AsvalOper = asval_oper<ValueType> >
    3596             :   class IteratorOpen_T :  public Iterator_T<InOutIterator>
    3597             :   {
    3598             :   public:
    3599             :     FromOper  from;
    3600             :     AsvalOper asval;
    3601             :     typedef InOutIterator nonconst_iter;
    3602             :     typedef ValueType value_type;
    3603             :     typedef Iterator_T<nonconst_iter>  base;
    3604             :     typedef IteratorOpen_T<InOutIterator, ValueType, FromOper, AsvalOper> self_type;
    3605             : 
    3606             :   public:
    3607             :     IteratorOpen_T(nonconst_iter curr, VALUE seq = Qnil)
    3608             :       : Iterator_T<InOutIterator>(curr, seq)
    3609             :     {
    3610             :     }
    3611             :     
    3612             :     virtual VALUE value() const {
    3613             :       return from(static_cast<const value_type&>(*(base::current)));
    3614             :     }
    3615             : 
    3616             :     virtual VALUE setValue( const VALUE& v )
    3617             :     {
    3618             :       value_type& dst = *base::current;
    3619             :       if ( asval(v, dst) ) return v;
    3620             :       return Qnil;
    3621             :     }
    3622             :     
    3623             :     Iterator *dup() const
    3624             :     {
    3625             :       return new self_type(*this);
    3626             :     }
    3627             :   };
    3628             : 
    3629             :   /** 
    3630             :    * ConstIterator class for a const_iterator where begin() and end() boundaries are known.
    3631             :    *
    3632             :    */
    3633             :   template<typename OutConstIterator, 
    3634             :            typename ValueType = typename std::iterator_traits<OutConstIterator>::value_type,
    3635             :            typename FromOper = from_oper<ValueType> >
    3636           0 :   class ConstIteratorClosed_T :  public ConstIterator_T<OutConstIterator>
    3637             :   {
    3638             :   public:
    3639             :     FromOper from;
    3640             :     typedef OutConstIterator const_iter;
    3641             :     typedef ValueType value_type;
    3642             :     typedef ConstIterator_T<const_iter>  base;    
    3643             :     typedef ConstIteratorClosed_T<OutConstIterator, ValueType, FromOper> self_type;
    3644             :     
    3645             :   protected:
    3646           0 :     virtual ConstIterator* advance(ptrdiff_t n)
    3647             :     {
    3648           0 :       std::advance( base::current, n );
    3649           0 :       if ( base::current == end )
    3650           0 :         throw stop_iteration();
    3651           0 :       return this;
    3652             :     }
    3653             : 
    3654             :   public:
    3655           0 :     ConstIteratorClosed_T(const_iter curr, const_iter first, 
    3656             :                           const_iter last, VALUE seq = Qnil)
    3657           0 :       : ConstIterator_T<OutConstIterator>(curr, seq), begin(first), end(last)
    3658             :     {
    3659             :     }
    3660             :     
    3661           0 :     virtual VALUE value() const {
    3662           0 :       if (base::current == end) {
    3663           0 :         throw stop_iteration();
    3664             :       } else {
    3665           0 :         return from(static_cast<const value_type&>(*(base::current)));
    3666             :       }
    3667             :     }
    3668             :     
    3669           0 :     ConstIterator *dup() const
    3670             :     {
    3671           0 :       return new self_type(*this);
    3672             :     }
    3673             : 
    3674             : 
    3675             :   private:
    3676             :     const_iter begin;
    3677             :     const_iter end;
    3678             :   };
    3679             : 
    3680             :   /** 
    3681             :    * Iterator class for a iterator where begin() and end() boundaries are known.
    3682             :    *
    3683             :    */
    3684             :   template<typename InOutIterator, 
    3685             :            typename ValueType = typename std::iterator_traits<InOutIterator>::value_type,
    3686             :            typename FromOper = from_oper<ValueType>,
    3687             :            typename AsvalOper = asval_oper<ValueType> >
    3688             :   class IteratorClosed_T :  public Iterator_T<InOutIterator>
    3689             :   {
    3690             :   public:
    3691             :     FromOper   from;
    3692             :     AsvalOper asval;
    3693             :     typedef InOutIterator nonconst_iter;
    3694             :     typedef ValueType value_type;
    3695             :     typedef Iterator_T<nonconst_iter>  base;
    3696             :     typedef IteratorClosed_T<InOutIterator, ValueType, FromOper, AsvalOper> self_type;
    3697             :     
    3698             :   protected:
    3699             :     virtual Iterator* advance(ptrdiff_t n)
    3700             :     {
    3701             :       std::advance( base::current, n );
    3702             :       if ( base::current == end )
    3703             :         throw stop_iteration();
    3704             :       return this;
    3705             :     }
    3706             : 
    3707             :   public:
    3708             :     IteratorClosed_T(nonconst_iter curr, nonconst_iter first, 
    3709             :                      nonconst_iter last, VALUE seq = Qnil)
    3710             :       : Iterator_T<InOutIterator>(curr, seq), begin(first), end(last)
    3711             :     {
    3712             :     }
    3713             :     
    3714             :     virtual VALUE value() const {
    3715             :       if (base::current == end) {
    3716             :         throw stop_iteration();
    3717             :       } else {
    3718             :         return from(static_cast<const value_type&>(*(base::current)));
    3719             :       }
    3720             :     }
    3721             :     
    3722             :     // Iterator setter method, required by Ruby
    3723             :     virtual VALUE setValue( const VALUE& v )
    3724             :     {
    3725             :       if (base::current == end)
    3726             :         throw stop_iteration();
    3727             : 
    3728             :       value_type& dst = *base::current;
    3729             :       if ( asval( v, dst ) ) return v;
    3730             :       return Qnil;
    3731             :     }
    3732             :     
    3733             :     Iterator *dup() const
    3734             :     {
    3735             :       return new self_type(*this);
    3736             :     }
    3737             : 
    3738             :   private:
    3739             :     nonconst_iter begin;
    3740             :     nonconst_iter end;
    3741             :   };
    3742             : 
    3743             :   /* Partial specialization for bools which don't allow de-referencing */
    3744             :   template< typename InOutIterator, typename FromOper, typename AsvalOper >
    3745             :   class IteratorOpen_T< InOutIterator, bool, FromOper, AsvalOper > : 
    3746             :     public Iterator_T<InOutIterator>
    3747             :   {
    3748             :   public:
    3749             :     FromOper   from;
    3750             :     AsvalOper asval;
    3751             :     typedef InOutIterator nonconst_iter;
    3752             :     typedef bool value_type;
    3753             :     typedef Iterator_T<nonconst_iter>  base;
    3754             :     typedef IteratorOpen_T<InOutIterator, bool, FromOper, AsvalOper> self_type;
    3755             : 
    3756             :     IteratorOpen_T(nonconst_iter curr, VALUE seq = Qnil)
    3757             :       : Iterator_T<InOutIterator>(curr, seq)
    3758             :     {
    3759             :     }
    3760             : 
    3761             :     virtual VALUE value() const {
    3762             :       return from(static_cast<const value_type&>(*(base::current)));
    3763             :     }
    3764             :     
    3765             :     virtual VALUE setValue( const VALUE& v )
    3766             :     {
    3767             :       bool tmp = *base::current;
    3768             :       if ( asval( v, tmp ) )
    3769             :         {
    3770             :           *base::current = tmp;
    3771             :           return v;
    3772             :         }
    3773             :       return Qnil;
    3774             :     }    
    3775             :     
    3776             :     Iterator *dup() const
    3777             :     {
    3778             :       return new self_type(*this);
    3779             :     }
    3780             :     
    3781             :   };
    3782             : 
    3783             :   /* Partial specialization for bools which don't allow de-referencing */
    3784             :   template< typename InOutIterator, typename FromOper, typename AsvalOper >
    3785             :   class IteratorClosed_T< InOutIterator, bool, FromOper, AsvalOper > : 
    3786             :     public Iterator_T<InOutIterator>
    3787             :   {
    3788             :   public:
    3789             :     FromOper   from;
    3790             :     AsvalOper asval;
    3791             :     typedef InOutIterator nonconst_iter;
    3792             :     typedef bool value_type;
    3793             :     typedef Iterator_T<nonconst_iter>  base;
    3794             :     typedef IteratorClosed_T<InOutIterator, bool, FromOper, AsvalOper> self_type;
    3795             :     
    3796             :   protected:
    3797             :     virtual Iterator* advance(ptrdiff_t n)
    3798             :     {
    3799             :       std::advance( base::current, n );
    3800             :       if ( base::current == end )
    3801             :         throw stop_iteration();
    3802             :       return this;
    3803             :     }
    3804             : 
    3805             :   public:
    3806             :     IteratorClosed_T(nonconst_iter curr, nonconst_iter first, 
    3807             :                      nonconst_iter last, VALUE seq = Qnil)
    3808             :       : Iterator_T<InOutIterator>(curr, seq), begin(first), end(last)
    3809             :     {
    3810             :     }
    3811             : 
    3812             :     virtual VALUE value() const {
    3813             :       if (base::current == end) {
    3814             :         throw stop_iteration();
    3815             :       } else {
    3816             :         return from(static_cast<const value_type&>(*(base::current)));
    3817             :       }
    3818             :     }
    3819             : 
    3820             :     virtual VALUE setValue( const VALUE& v )
    3821             :     {
    3822             :       if (base::current == end)
    3823             :         throw stop_iteration();
    3824             : 
    3825             :       bool tmp = *base::current;
    3826             :       if ( asval( v, tmp ) )
    3827             :         {
    3828             :           *base::current = tmp;
    3829             :           return v;
    3830             :         }
    3831             :       return Qnil;
    3832             :     }
    3833             :     
    3834             :     Iterator *dup() const
    3835             :     {
    3836             :       return new self_type(*this);
    3837             :     }
    3838             : 
    3839             :   private:
    3840             :     nonconst_iter begin;
    3841             :     nonconst_iter end;
    3842             :   };
    3843             : 
    3844             : 
    3845             :   /** 
    3846             :    * Helper function used to wrap a bounded const_iterator.  This is to be used in
    3847             :    * a %typemap(out), for example.
    3848             :    *
    3849             :    */
    3850             :   template<typename InOutIter>
    3851             :   inline Iterator*
    3852             :   make_nonconst_iterator(const InOutIter& current, const InOutIter& begin,
    3853             :                          const InOutIter& end, VALUE seq = Qnil)
    3854             :   {
    3855             :     return new IteratorClosed_T<InOutIter>(current, begin, end, seq);
    3856             :   }
    3857             : 
    3858             :   /** 
    3859             :    * Helper function used to wrap an unbounded const_iterator.  This is to be used in
    3860             :    * a %typemap(out), for example.
    3861             :    *
    3862             :    */
    3863             :   template<typename InOutIter>
    3864             :   inline Iterator*
    3865             :   make_nonconst_iterator(const InOutIter& current, VALUE seq = Qnil)
    3866             :   {
    3867             :     return new IteratorOpen_T<InOutIter>(current, seq);
    3868             :   }
    3869             : 
    3870             :   /** 
    3871             :    * Helper function used to wrap a bounded const_iterator.  This is to be used in
    3872             :    * a %typemap(out), for example.
    3873             :    *
    3874             :    */
    3875             :   template<typename OutIter>
    3876             :   inline ConstIterator*
    3877             :   make_const_iterator(const OutIter& current, const OutIter& begin,
    3878             :                        const OutIter& end, VALUE seq = Qnil)
    3879             :   {
    3880             :     return new ConstIteratorClosed_T<OutIter>(current, begin, end, seq);
    3881             :   }
    3882             : 
    3883             :   /** 
    3884             :    * Helper function used to wrap an unbounded const_iterator.  This is to be used in
    3885             :    * a %typemap(out), for example.
    3886             :    *
    3887             :    */
    3888             :   template<typename OutIter>
    3889             :   inline ConstIterator*
    3890             :   make_const_iterator(const OutIter& current, VALUE seq = Qnil)
    3891             :   {
    3892             :     return new ConstIteratorOpen_T<OutIter>(current, seq);
    3893             :   }
    3894             : }
    3895             : 
    3896             : 
    3897             : namespace swig
    3898             : {
    3899             : 
    3900             :   /**
    3901             :    * This class is a proxy class for references, used to return and set values
    3902             :    * of an element of a Ruby Array of stuff.
    3903             :    * It can be used by RubySequence_InputIterator to make it work with STL
    3904             :    * algorithms.
    3905             :    */
    3906             :   template <class T>
    3907             :   struct RubySequence_Ref
    3908             :   {
    3909             :     RubySequence_Ref(VALUE  seq, int index)
    3910             :       : _seq(seq), _index(index)
    3911             :     {
    3912             :     }
    3913             :     
    3914           0 :     operator T () const
    3915             :     {
    3916           0 :       VALUE item = rb_ary_entry(_seq, _index );
    3917             :       try {
    3918           0 :         return swig::as<T>(item, true);
    3919           0 :       } catch (std::exception& e) {
    3920             :         char msg[1024];
    3921           0 :         sprintf(msg, "in sequence element %d ", _index);
    3922           0 :         VALUE lastErr = rb_gv_get("$!");
    3923           0 :         if ( lastErr == Qnil ) {
    3924           0 :           SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
    3925             :         }
    3926           0 :         VALUE str = rb_str_new2(msg);
    3927           0 :         str = rb_str_cat2( str, e.what() );
    3928           0 :         SWIG_Ruby_ExceptionType( NULL, str );
    3929           0 :         throw;
    3930             :       }
    3931             :     }
    3932             : 
    3933             :     RubySequence_Ref& operator=(const T& v)
    3934             :     {
    3935             :       rb_ary_set(_seq, _index, swig::from< T >(v));
    3936             :       return *this;
    3937             :     }
    3938             : 
    3939             :   private:
    3940             :     VALUE  _seq;
    3941             :     int _index;
    3942             :   };
    3943             : 
    3944             : 
    3945             :   /**
    3946             :    * This class is a proxy to return a pointer to a class, usually
    3947             :    * RubySequence_Ref. 
    3948             :    * It can be used by RubySequence_InputIterator to make it work with STL
    3949             :    * algorithms.
    3950             :    */
    3951             :   template <class T>
    3952           0 :   struct RubySequence_ArrowProxy
    3953             :   {
    3954           0 :     RubySequence_ArrowProxy(const T& x): m_value(x) {}
    3955             :     const T* operator->() const { return &m_value; }
    3956             :     operator const T*() const { return &m_value; }
    3957             :     T m_value;
    3958             :   };
    3959             : 
    3960             : 
    3961             :   /**
    3962             :    * Input Iterator.  This adapator class is a random access iterator that 
    3963             :    * allows you to use STL algorithms with a Ruby class (a Ruby Array by default).
    3964             :    */
    3965             :   template <class T, class Reference = RubySequence_Ref< T > >
    3966             :   struct RubySequence_InputIterator
    3967             :   {
    3968             :     typedef RubySequence_InputIterator<T, Reference > self;
    3969             : 
    3970             :     typedef std::random_access_iterator_tag iterator_category;
    3971             :     typedef Reference reference;
    3972             :     typedef T value_type;
    3973             :     typedef T* pointer;
    3974             :     typedef ptrdiff_t difference_type;
    3975             : 
    3976             :     RubySequence_InputIterator()
    3977             :     {
    3978             :     }
    3979             : 
    3980             :     RubySequence_InputIterator(VALUE  seq, int index)
    3981           0 :       : _seq(seq), _index(index)
    3982             :     {
    3983             :     }
    3984             : 
    3985             :     reference operator*() const
    3986             :     {
    3987           0 :       return reference(_seq, _index);
    3988             :     }
    3989             : 
    3990             :     RubySequence_ArrowProxy<T>
    3991           0 :     operator->() const {
    3992           0 :       return RubySequence_ArrowProxy<T>(operator*());
    3993             :     }
    3994             : 
    3995             :     bool operator==(const self& ri) const
    3996             :     {
    3997           0 :       return (_index == ri._index) && (_seq == ri._seq);
    3998             :     }
    3999             : 
    4000             :     bool operator!=(const self& ri) const
    4001             :     {
    4002           0 :       return !(operator==(ri));
    4003             :     }
    4004             : 
    4005             :     self& operator ++ ()
    4006             :     {
    4007           0 :       ++_index;
    4008             :       return *this;
    4009             :     }
    4010             : 
    4011             :     self& operator -- ()
    4012             :     {
    4013             :       --_index;
    4014             :       return *this;
    4015             :     }
    4016             : 
    4017             :     self& operator += (difference_type n)
    4018             :     {
    4019             :       _index += n;
    4020             :       return *this;
    4021             :     }
    4022             : 
    4023             :     self operator +(difference_type n) const
    4024             :     {
    4025             :       return self(_seq, _index + n);
    4026             :     }
    4027             : 
    4028             :     self& operator -= (difference_type n)
    4029             :     {
    4030             :       _index -= n;
    4031             :       return *this;
    4032             :     }
    4033             : 
    4034             :     self operator -(difference_type n) const
    4035             :     {
    4036             :       return self(_seq, _index - n);
    4037             :     }
    4038             : 
    4039             :     difference_type operator - (const self& ri) const
    4040             :     {
    4041             :       return _index - ri._index;
    4042             :     }
    4043             : 
    4044             :     bool operator < (const self& ri) const
    4045             :     {
    4046             :       return _index < ri._index;
    4047             :     }
    4048             : 
    4049             :     reference
    4050             :     operator[](difference_type n) const
    4051             :     {
    4052             :       return reference(_seq, _index + n);
    4053             :     }
    4054             : 
    4055             :   private:
    4056             :     VALUE  _seq;
    4057             :     difference_type _index;
    4058             :   };
    4059             : 
    4060             : 
    4061             :   /**
    4062             :    * This adaptor class allows you to use a Ruby Array as if it was an STL
    4063             :    * container, giving it begin(), end(), and iterators.
    4064             :    */
    4065             :   template <class T>
    4066             :   struct RubySequence_Cont
    4067             :   {
    4068             :     typedef RubySequence_Ref<T> reference;
    4069             :     typedef const RubySequence_Ref<T> const_reference;
    4070             :     typedef T value_type;
    4071             :     typedef T* pointer;
    4072             :     typedef int difference_type;
    4073             :     typedef int size_type;
    4074             :     typedef const pointer const_pointer;
    4075             :     typedef RubySequence_InputIterator<T, reference> iterator;
    4076             :     typedef RubySequence_InputIterator<T, const_reference> const_iterator;
    4077             : 
    4078           0 :     RubySequence_Cont(VALUE  seq) : _seq(0)
    4079             :     {
    4080           0 :       if (!rb_obj_is_kind_of(seq, rb_cArray)) {
    4081           0 :         throw std::invalid_argument("an Array is expected");
    4082             :       }
    4083           0 :       _seq = seq;
    4084           0 :     }
    4085             : 
    4086             :     ~RubySequence_Cont()
    4087             :     {
    4088             :     }
    4089             : 
    4090             :     size_type size() const
    4091             :     {
    4092           0 :       return RARRAY_LEN(_seq);
    4093             :     }
    4094             : 
    4095             :     bool empty() const
    4096             :     {
    4097             :       return size() == 0;
    4098             :     }
    4099             : 
    4100             :     iterator begin()
    4101             :     {
    4102             :       return iterator(_seq, 0);
    4103             :     }
    4104             : 
    4105             :     const_iterator begin() const
    4106             :     {
    4107           0 :       return const_iterator(_seq, 0);
    4108             :     }
    4109             : 
    4110             :     iterator end()
    4111             :     {
    4112             :       return iterator(_seq, size());
    4113             :     }
    4114             : 
    4115             :     const_iterator end() const
    4116             :     {
    4117           0 :       return const_iterator(_seq, size());
    4118             :     }
    4119             : 
    4120             :     reference operator[](difference_type n)
    4121             :     {
    4122             :       return reference(_seq, n);
    4123             :     }
    4124             : 
    4125             :     const_reference operator[](difference_type n)  const
    4126             :     {
    4127             :       return const_reference(_seq, n);
    4128             :     }
    4129             : 
    4130           0 :     bool check(bool set_err = false) const
    4131             :     {
    4132           0 :       int s = (int) size();
    4133           0 :       for (int i = 0; i < s; ++i) {
    4134           0 :         VALUE item = rb_ary_entry(_seq, i );
    4135           0 :         if (!swig::check<value_type>(item)) {
    4136           0 :           if (set_err) {
    4137             :             char msg[1024];
    4138           0 :             sprintf(msg, "in sequence element %d", i);
    4139           0 :             SWIG_Error(SWIG_RuntimeError, msg);
    4140             :           }
    4141             :           return false;
    4142             :         }
    4143             :       }
    4144             :       return true;
    4145             :     }
    4146             : 
    4147             :   private:
    4148             :     VALUE  _seq;
    4149             :   };
    4150             : 
    4151             : }
    4152             : 
    4153             : 
    4154             : namespace swig {
    4155             :   template <class RubySeq, class Seq>
    4156             :   inline void
    4157           0 :   assign(const RubySeq& rubyseq, Seq* seq) {
    4158             :     // seq->assign(rubyseq.begin(), rubyseq.end()); // not used as not always implemented
    4159             :     typedef typename RubySeq::value_type value_type;
    4160           0 :     typename RubySeq::const_iterator it = rubyseq.begin();
    4161           0 :     for (;it != rubyseq.end(); ++it) {
    4162           0 :       seq->insert(seq->end(),(value_type)(*it));
    4163             :     }
    4164           0 :   }
    4165             : 
    4166             :   template <class Seq, class T = typename Seq::value_type >
    4167             :   struct traits_asptr_stdseq {
    4168             :     typedef Seq sequence;
    4169             :     typedef T value_type;
    4170             : 
    4171           0 :     static int asptr(VALUE obj, sequence **seq) {
    4172           0 :       if (rb_obj_is_kind_of(obj, rb_cArray) == Qtrue) {
    4173             :         try {
    4174           0 :           RubySequence_Cont<value_type> rubyseq(obj);
    4175           0 :           if (seq) {
    4176           0 :             sequence *pseq = new sequence();
    4177           0 :             assign(rubyseq, pseq);
    4178           0 :             *seq = pseq;
    4179           0 :             return SWIG_NEWOBJ;
    4180             :           } else {
    4181           0 :             return rubyseq.check() ? SWIG_OK : SWIG_ERROR;
    4182             :           }
    4183           0 :         } catch (std::exception& e) {
    4184           0 :           if (seq) {
    4185           0 :             VALUE lastErr = rb_gv_get("$!");
    4186           0 :             if (lastErr == Qnil) {
    4187           0 :               rb_raise(rb_eTypeError, "%s", e.what());
    4188             :             }
    4189             :           }
    4190             :           return SWIG_ERROR;
    4191             :         }
    4192             :       } else {
    4193             :         sequence *p;
    4194           0 :         if (SWIG_ConvertPtr(obj,(void**)&p,
    4195             :                             swig::type_info<sequence>(),0) == SWIG_OK) {
    4196           0 :           if (seq) *seq = p;
    4197           0 :           return SWIG_OLDOBJ;
    4198             :         }
    4199             :       }
    4200           0 :       return SWIG_ERROR;
    4201             :     }
    4202             :   };
    4203             : 
    4204             :   // Partial specialization for GC_VALUE's.  No need to typecheck each
    4205             :   // element.
    4206             :   template< class Seq >
    4207             :   struct traits_asptr_stdseq< Seq, swig::GC_VALUE > {
    4208             :     typedef Seq sequence;
    4209             :     typedef swig::GC_VALUE value_type;
    4210             : 
    4211             :     static int asptr(VALUE obj, sequence **seq) {
    4212             :       if (rb_obj_is_kind_of(obj, rb_cArray) == Qtrue) {
    4213             :         try {
    4214             :           if (seq) {
    4215             :             RubySequence_Cont<value_type> rubyseq(obj);
    4216             :             sequence *pseq = new sequence();
    4217             :             assign(rubyseq, pseq);
    4218             :             *seq = pseq;
    4219             :             return SWIG_NEWOBJ;
    4220             :           } else {
    4221             :             return true;
    4222             :           }
    4223             :         } catch (std::exception& e) {
    4224             :           if (seq) {
    4225             :             VALUE lastErr = rb_gv_get("$!");
    4226             :             if (lastErr == Qnil) {
    4227             :               rb_raise(rb_eTypeError, "%s", e.what());
    4228             :             }
    4229             :           }
    4230             :           return SWIG_ERROR;
    4231             :         }
    4232             :       } else {
    4233             :         sequence *p;
    4234             :         if (SWIG_ConvertPtr(obj,(void**)&p,
    4235             :                             swig::type_info<sequence>(),0) == SWIG_OK) {
    4236             :           if (seq) *seq = p;
    4237             :           return SWIG_OLDOBJ;
    4238             :         }
    4239             :       }
    4240             :       return SWIG_ERROR;
    4241             :     }
    4242             :   };
    4243             : 
    4244             :   template <class Seq, class T = typename Seq::value_type >
    4245             :   struct traits_from_stdseq {
    4246             :     typedef Seq sequence;
    4247             :     typedef T value_type;
    4248             :     typedef typename Seq::size_type size_type;
    4249             :     typedef typename sequence::const_iterator const_iterator;
    4250             : 
    4251           6 :     static VALUE from(const sequence& seq) {
    4252             : 
    4253             : 
    4254             : 
    4255             : 
    4256             : 
    4257             : 
    4258          12 :       size_type size = seq.size();
    4259           6 :       if (size <= (size_type)INT_MAX) {
    4260           6 :         VALUE obj = rb_ary_new2((int)size);
    4261           6 :         int i = 0;
    4262         672 :         for (const_iterator it = seq.begin();
    4263         666 :              it != seq.end(); ++it, ++i) {
    4264         654 :           rb_ary_push(obj, swig::from< value_type >(*it));
    4265             :         }
    4266           6 :         rb_obj_freeze(obj);  // treat as immutable result
    4267             :         return obj;
    4268             :       } else {
    4269           0 :         rb_raise(rb_eRangeError,"sequence size not valid in ruby");
    4270             :         return Qnil;
    4271             :       }
    4272             :     }
    4273             :   };
    4274             : }
    4275             : 
    4276             : 
    4277             :   namespace swig {
    4278             :     template <class T>
    4279             :     struct traits_asptr<std::vector<T> >  {
    4280             :       static int asptr(VALUE obj, std::vector<T> **vec) {
    4281           0 :         return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
    4282             :       }
    4283             :     };
    4284             :     
    4285             :     template <class T>
    4286             :     struct traits_from<std::vector<T> > {
    4287             :       static VALUE from(const std::vector<T>& vec) {
    4288           6 :         return traits_from_stdseq<std::vector<T> >::from(vec);
    4289             :       }
    4290             :     };
    4291             :   }
    4292             : 
    4293             : 
    4294             :       namespace swig {
    4295             :         template <>  struct traits<std::vector< std::string, std::allocator< std::string > > > {
    4296             :           typedef pointer_category category;
    4297             :           static const char* type_name() {
    4298             :             return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
    4299             :           }
    4300             :         };
    4301             :       }
    4302             :     
    4303           0 : SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg__dup(std::vector< std::string > *self){
    4304           0 :       return new std::vector< std::string,std::allocator< std::string > >(*self);
    4305             :     }
    4306           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg__inspect(std::vector< std::string > *self){
    4307           0 :       std::vector< std::string,std::allocator< std::string > >::const_iterator i = self->begin();
    4308           0 :       std::vector< std::string,std::allocator< std::string > >::const_iterator e = self->end();
    4309           0 :       const char *type_name = swig::type_name< std::vector< std::string,std::allocator< std::string > > >();
    4310           0 :       VALUE str = rb_str_new2(type_name);
    4311           0 :       str = rb_str_cat2( str, " [" );
    4312             :       bool comma = false;
    4313             :       VALUE tmp;
    4314           0 :       for ( ; i != e; ++i, comma = true )
    4315             :         {
    4316           0 :           if (comma) str = rb_str_cat2( str, "," );
    4317           0 :           tmp = swig::from< std::vector< std::string,std::allocator< std::string > >::value_type >( *i );
    4318           0 :           tmp = rb_inspect( tmp );
    4319           0 :           str = rb_str_buf_append( str, tmp );
    4320             :         }
    4321           0 :       str = rb_str_cat2( str, "]" );
    4322           0 :       return str;
    4323             :     }
    4324           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg__to_a(std::vector< std::string > *self){
    4325           0 :       std::vector< std::string,std::allocator< std::string > >::const_iterator i = self->begin();
    4326           0 :       std::vector< std::string,std::allocator< std::string > >::const_iterator e = self->end();
    4327           0 :       VALUE ary = rb_ary_new2( std::distance( i, e ) );
    4328             :       VALUE tmp;
    4329           0 :       for ( ; i != e; ++i )
    4330             :         {
    4331           0 :           tmp = swig::from< std::vector< std::string,std::allocator< std::string > >::value_type >( *i );
    4332           0 :           rb_ary_push( ary, tmp );
    4333             :         }
    4334           0 :       return ary;
    4335             :     }
    4336           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg__to_s(std::vector< std::string > *self){
    4337           0 :       std::vector< std::string,std::allocator< std::string > >::iterator i = self->begin();
    4338           0 :       std::vector< std::string,std::allocator< std::string > >::iterator e = self->end();
    4339           0 :       VALUE str = rb_str_new2( "" );
    4340             :       VALUE tmp;
    4341           0 :       for ( ; i != e; ++i )
    4342             :         {
    4343           0 :           tmp = swig::from< std::vector< std::string,std::allocator< std::string > >::value_type >( *i );
    4344           0 :           tmp = rb_obj_as_string( tmp );
    4345           0 :           str = rb_str_buf_append( str, tmp );
    4346             :         }
    4347           0 :       return str;
    4348             :     }
    4349           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg__slice(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type length){
    4350           0 :       if ( length < 0 )
    4351             :         return Qnil;
    4352           0 :       std::size_t len = self->size();
    4353           0 :       if ( i < 0 ) {
    4354           0 :         if ( i + static_cast<std::vector< std::string,std::allocator< std::string > >::difference_type>(len) < 0 )
    4355             :           return Qnil;
    4356             :         else
    4357           0 :           i = len + i;
    4358             :       }
    4359           0 :       std::vector< std::string,std::allocator< std::string > >::difference_type j = length + i;
    4360           0 :       if ( j > static_cast<std::vector< std::string,std::allocator< std::string > >::difference_type>(len) )
    4361           0 :         j = len;
    4362             : 
    4363           0 :       VALUE r = Qnil;
    4364             :       try {
    4365           0 :         r = swig::from< const std::vector< std::string,std::allocator< std::string > >* >( swig::getslice(self, i, j) );
    4366             :       }
    4367           0 :       catch( std::out_of_range ) {
    4368             :       }
    4369             :       return r;
    4370             :     }
    4371           0 : SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg__each(std::vector< std::string > *self){
    4372           0 :         if ( !rb_block_given_p() )
    4373           0 :           rb_raise( rb_eArgError, "no block given");
    4374             : 
    4375             :         VALUE r;
    4376           0 :         std::vector< std::string,std::allocator< std::string > >::const_iterator i = self->begin();
    4377           0 :         std::vector< std::string,std::allocator< std::string > >::const_iterator e = self->end();
    4378           0 :         for ( ; i != e; ++i )
    4379             :           {
    4380           0 :             r = swig::from< std::vector< std::string,std::allocator< std::string > >::value_type >(*i);
    4381           0 :             rb_yield(r);
    4382             :           }
    4383             :         
    4384           0 :         return self;
    4385             :       }
    4386             : SWIGINTERN VALUE std_vector_Sl_std_string_Sg____delete2__(std::vector< std::string > *self,std::vector< std::string >::value_type const &i){
    4387           0 :       VALUE r = Qnil;
    4388             :       return r;
    4389             :     }
    4390           0 : SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg__select(std::vector< std::string > *self){
    4391           0 :       if ( !rb_block_given_p() )
    4392           0 :         rb_raise( rb_eArgError, "no block given" );
    4393             : 
    4394           0 :       std::vector< std::string,std::allocator< std::string > >* r = new std::vector< std::string,std::allocator< std::string > >();
    4395           0 :       std::vector< std::string,std::allocator< std::string > >::const_iterator i = self->begin();
    4396           0 :       std::vector< std::string,std::allocator< std::string > >::const_iterator e = self->end();
    4397           0 :       for ( ; i != e; ++i )
    4398             :         {
    4399           0 :           VALUE v = swig::from< std::vector< std::string,std::allocator< std::string > >::value_type >(*i);
    4400           0 :           if ( RTEST( rb_yield(v) ) )
    4401           0 :             self->insert( r->end(), *i);
    4402             :         }
    4403             :         
    4404           0 :       return r;
    4405             :     }
    4406           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg__delete_at(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
    4407           0 :       VALUE r = Qnil;
    4408             :       try {
    4409           0 :         std::vector< std::string,std::allocator< std::string > >::iterator at = swig::getpos(self, i);
    4410           0 :         r = swig::from< std::vector< std::string,std::allocator< std::string > >::value_type >( *(at) );
    4411           0 :         self->erase(at); 
    4412             :       }
    4413           0 :       catch (std::out_of_range)
    4414             :         {
    4415             :         }
    4416           0 :       return r;
    4417             :     }
    4418           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg__at(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
    4419           0 :       VALUE r = Qnil;
    4420             :       try {
    4421           0 :         r = swig::from< std::vector< std::string,std::allocator< std::string > >::value_type >( *(swig::cgetpos(self, i)) );
    4422             :       }
    4423           0 :       catch( std::out_of_range ) {
    4424             :       }
    4425           0 :       return r;
    4426             :     }
    4427           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > const *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type length){
    4428           0 :       if ( length < 0 )
    4429             :         return Qnil;
    4430           0 :       std::size_t len = self->size();
    4431           0 :       if ( i < 0 ) {
    4432           0 :         if ( i + static_cast<std::vector< std::string,std::allocator< std::string > >::difference_type>(len) < 0 )
    4433             :           return Qnil;
    4434             :         else
    4435           0 :           i = len + i;
    4436             :       }
    4437           0 :       std::vector< std::string,std::allocator< std::string > >::difference_type j = length + i;
    4438           0 :       if ( j > static_cast<std::vector< std::string,std::allocator< std::string > >::difference_type>(len) )
    4439           0 :         j = len;
    4440             : 
    4441           0 :       VALUE r = Qnil;
    4442             :       try {
    4443           0 :         r = swig::from< const std::vector< std::string,std::allocator< std::string > >* >( swig::getslice(self, i, j) );
    4444             :       }
    4445           0 :       catch( std::out_of_range ) {
    4446             :       }
    4447             :       return r;
    4448             :     }
    4449           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
    4450           0 :       VALUE r = Qnil;
    4451             :       try {
    4452           0 :         r = swig::from< std::vector< std::string,std::allocator< std::string > >::value_type >( *(swig::cgetpos(self, i)) );
    4453             :       }
    4454           0 :       catch( std::out_of_range ) {
    4455             :       }
    4456           0 :       return r;
    4457             :     }
    4458           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg____getitem____SWIG_2(std::vector< std::string > const *self,VALUE i){
    4459           0 :       if ( rb_obj_is_kind_of( i, rb_cRange ) == Qfalse ) {
    4460           0 :         rb_raise( rb_eTypeError, "not a valid index or range" );
    4461             :       }
    4462             : 
    4463           0 :       static ID id_end   = rb_intern("end");
    4464           0 :       static ID id_start = rb_intern("begin");
    4465           0 :       static ID id_noend = rb_intern("exclude_end?");
    4466             : 
    4467           0 :       VALUE start = rb_funcall( i, id_start, 0 );
    4468           0 :       VALUE end   = rb_funcall( i, id_end, 0 );
    4469           0 :       bool  noend = ( rb_funcall( i, id_noend, 0 ) == Qtrue );
    4470             : 
    4471           0 :       int len = self->size();
    4472             : 
    4473           0 :       int s = NUM2INT( start );
    4474           0 :       if ( s < 0 ) {
    4475           0 :         s = len + s;
    4476           0 :         if ( s < 0 )
    4477             :           return Qnil;
    4478           0 :       } else if ( s > len )
    4479             :         return Qnil;
    4480             : 
    4481           0 :       int e = NUM2INT( end );
    4482           0 :       if ( e < 0 ) e = len + e;
    4483           0 :       if ( noend ) e -= 1;
    4484           0 :       if ( e < 0 ) e = -1;
    4485           0 :       if ( e >= len ) e = len - 1;
    4486           0 :       if ( s == len ) e = len - 1;
    4487             : 
    4488           0 :       return swig::from< std::vector< std::string,std::allocator< std::string > >* >( swig::getslice(self, s, e+1) );
    4489             :     }
    4490           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
    4491           0 :         if ( i >= static_cast<std::vector< std::string,std::allocator< std::string > >::difference_type>( self->size()) )
    4492           0 :           swig::resize( self, i+1, x );
    4493             :         else
    4494           0 :           *(swig::getpos(self, i)) = x;
    4495             : 
    4496           0 :         return swig::from< std::vector< std::string,std::allocator< std::string > >::value_type >( x );
    4497             :       }
    4498           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type length,std::vector< std::string,std::allocator< std::string > > const &v){
    4499             : 
    4500           0 :       if ( length < 0 )
    4501             :         return Qnil;
    4502           0 :       std::size_t len = self->size();
    4503           0 :       if ( i < 0 ) {
    4504           0 :         if ( i + static_cast<std::vector< std::string,std::allocator< std::string > >::difference_type>(len) < 0 )
    4505             :           return Qnil;
    4506             :         else
    4507           0 :           i = len + i;
    4508             :       }
    4509           0 :       std::vector< std::string,std::allocator< std::string > >::difference_type j = length + i;
    4510           0 :       if ( j > static_cast<std::vector< std::string,std::allocator< std::string > >::difference_type>(len) ) {
    4511           0 :         swig::resize( self, j, *(v.begin()) );
    4512             :       }
    4513             : 
    4514           0 :       VALUE r = Qnil;
    4515           0 :       swig::setslice(self, i, j, v);
    4516           0 :       r = swig::from< const std::vector< std::string,std::allocator< std::string > >* >( &v );
    4517             :       return r;
    4518             :     }
    4519           0 : SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg__reject_bang(std::vector< std::string > *self){
    4520           0 :       if ( !rb_block_given_p() )
    4521           0 :         rb_raise( rb_eArgError, "no block given" );
    4522             : 
    4523           0 :       self->erase( std::remove_if( self->begin(), self->end(),
    4524           0 :             swig::yield< std::vector< std::string,std::allocator< std::string > >::value_type >() ), self->end() );
    4525           0 :       return self;
    4526             :     }
    4527           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
    4528           0 :       if (self->empty()) return Qnil;
    4529           0 :       std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
    4530           0 :       self->pop_back();
    4531           0 :       return swig::from< std::vector< std::string,std::allocator< std::string > >::value_type >( x );
    4532             :     }
    4533             : SWIGINTERN std::vector< std::string >::value_type const std_vector_Sl_std_string_Sg__push(std::vector< std::string > *self,std::vector< std::string >::value_type const &e){
    4534           0 :       self->push_back( e );
    4535           0 :       return e;
    4536             :     }
    4537           0 : SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg__reject(std::vector< std::string > *self){
    4538           0 :       if ( !rb_block_given_p() )
    4539           0 :         rb_raise( rb_eArgError, "no block given" );
    4540             : 
    4541           0 :       std::vector< std::string,std::allocator< std::string > >* r = new std::vector< std::string,std::allocator< std::string > >();
    4542             :       std::remove_copy_if( self->begin(), self->end(),              
    4543             :                            std::back_inserter(*r),
    4544           0 :                            swig::yield< std::vector< std::string,std::allocator< std::string > >::value_type >() );
    4545           0 :       return r;
    4546             :     }
    4547           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg__shift(std::vector< std::string > *self){
    4548           0 :       if (self->empty()) return Qnil;
    4549           0 :       std::vector< std::string,std::allocator< std::string > >::value_type x = self->front();
    4550           0 :       self->erase( self->begin() );
    4551           0 :       return swig::from< std::vector< std::string,std::allocator< std::string > >::value_type >( x );
    4552             :     }
    4553             : 
    4554             : SWIGINTERN int
    4555           0 : SWIG_AsVal_int (VALUE obj, int *val)
    4556             : {
    4557             :   long v;
    4558           0 :   int res = SWIG_AsVal_long (obj, &v);
    4559           0 :   if (SWIG_IsOK(res)) {
    4560           0 :     if ((v < INT_MIN || v > INT_MAX)) {
    4561             :       return SWIG_OverflowError;
    4562             :     } else {
    4563           0 :       if (val) *val = static_cast< int >(v);
    4564             :     }
    4565             :   }  
    4566             :   return res;
    4567             : }
    4568             : 
    4569           0 : SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg__insert(std::vector< std::string > *self,std::vector< std::string >::difference_type pos,int argc,VALUE *argv,...){
    4570           0 :       std::size_t len = self->size();
    4571           0 :       std::size_t   i = swig::check_index( pos, len, true );
    4572           0 :       std::vector< std::string,std::allocator< std::string > >::iterator start;
    4573             : 
    4574           0 :       VALUE elem = argv[0];
    4575           0 :       int idx = 0;
    4576             :       try {
    4577           0 :         std::vector< std::string,std::allocator< std::string > >::value_type val = swig::as<std::vector< std::string,std::allocator< std::string > >::value_type>( elem, true );
    4578           0 :         if ( i >= len ) {
    4579           0 :           self->resize(i-1, val);
    4580           0 :           return self;
    4581             :         }
    4582           0 :         start = self->begin();
    4583           0 :         std::advance( start, i );
    4584           0 :         self->insert( start++, val );
    4585             : 
    4586           0 :         for ( ++idx; idx < argc; ++idx )
    4587             :           {
    4588           0 :             elem = argv[idx];
    4589           0 :             val = swig::as<std::vector< std::string,std::allocator< std::string > >::value_type>( elem );
    4590           0 :             self->insert( start++, val );
    4591             :           }
    4592             : 
    4593             :       } 
    4594           0 :       catch( std::invalid_argument )
    4595             :         {
    4596           0 :           rb_raise( rb_eArgError, "%s",
    4597             :                     Ruby_Format_TypeError( "", 
    4598             :                                            swig::type_name<std::vector< std::string,std::allocator< std::string > >::value_type>(),
    4599           0 :                                            __FUNCTION__, idx+2, elem ));
    4600             :         }
    4601             : 
    4602             : 
    4603           0 :       return self;
    4604             :     }
    4605           0 : SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg__unshift(std::vector< std::string > *self,int argc,VALUE *argv,...){
    4606           0 :       for ( int idx = argc-1; idx >= 0; --idx )
    4607             :         {
    4608           0 :           std::vector< std::string,std::allocator< std::string > >::iterator start = self->begin();
    4609           0 :           VALUE elem = argv[idx];
    4610             :           try {
    4611           0 :             std::vector< std::string,std::allocator< std::string > >::value_type val = swig::as<std::vector< std::string,std::allocator< std::string > >::value_type>( elem, true );
    4612           0 :             self->insert( start, val );
    4613             :           }
    4614           0 :           catch( std::invalid_argument )
    4615             :             {
    4616           0 :               rb_raise( rb_eArgError, "%s",
    4617             :                         Ruby_Format_TypeError( "", 
    4618             :                                                swig::type_name<std::vector< std::string,std::allocator< std::string > >::value_type>(),
    4619           0 :                                                __FUNCTION__, idx+2, elem ));
    4620             :             }
    4621             :         }
    4622             : 
    4623           0 :       return self;
    4624             :     }
    4625             : 
    4626             : SWIGINTERNINLINE VALUE
    4627             : SWIG_From_unsigned_SS_long  (unsigned long value)
    4628             : {
    4629           1 :   return ULONG2NUM(value); 
    4630             : }
    4631             : 
    4632             : 
    4633             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4634             : SWIGINTERNINLINE VALUE 
    4635             : SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
    4636             : {
    4637             :   return ULL2NUM(value);
    4638             : }
    4639             : #endif
    4640             : 
    4641             : 
    4642             : SWIGINTERNINLINE VALUE
    4643             : SWIG_From_size_t  (size_t value)
    4644             : {    
    4645             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4646             :   if (sizeof(size_t) <= sizeof(unsigned long)) {
    4647             : #endif
    4648           1 :     return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
    4649             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4650             :   } else {
    4651             :     /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    4652             :     return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
    4653             :   }
    4654             : #endif
    4655             : }
    4656             : 
    4657           0 : SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg__map_bang(std::vector< std::string > *self){
    4658             : 
    4659           0 :     if ( !rb_block_given_p() )
    4660           0 :       rb_raise( rb_eArgError, "No block given" );
    4661             : 
    4662           0 :     VALUE r = Qnil;
    4663           0 :     std::vector< std::string >::iterator i = self->begin();
    4664           0 :     std::vector< std::string >::iterator e = self->end();
    4665             : 
    4666             :     try {
    4667           0 :       for ( ; i != e; ++i )
    4668             :         {
    4669           0 :           r = swig::from< std::string >( *i );
    4670           0 :           r = rb_yield( r );
    4671           0 :           *i = swig::as< std::string >( r );
    4672             :         }
    4673             :     }
    4674           0 :     catch ( const std::invalid_argument& )
    4675             :       {
    4676             :         rb_raise(rb_eTypeError,
    4677           0 :                  "Yield block did not return a valid element for " "std::vector");
    4678             :       }
    4679             :     
    4680           0 :     return self;
    4681             :   }
    4682           0 : SWIGINTERN VALUE std_vector_Sl_std_string_Sg____delete__(std::vector< std::string > *self,std::string const &val){
    4683           0 :     VALUE r = Qnil;
    4684           0 :     std::vector<std::string >::iterator e = self->end();
    4685           0 :     std::vector<std::string >::iterator i = std::remove( self->begin(), e, val );
    4686             :     // remove dangling elements now
    4687           0 :     self->erase( i, e );
    4688             :     
    4689           0 :     if ( i != e )
    4690             :       r = swig::from< std::string >( val );
    4691           0 :     else if ( rb_block_given_p() )
    4692           0 :       r = rb_yield(Qnil);
    4693           0 :     return r;
    4694             :   }
    4695             : 
    4696             :   #include "pluginspec.hpp"
    4697             :   #include "plugin.hpp"
    4698             :   #include "plugins.hpp"
    4699             :   #include "plugindatabase.hpp"
    4700             :   #include "modules.hpp"
    4701             :   #include "backendparser.hpp"
    4702             :   #include "backend.hpp"
    4703             :   #include "backends.hpp"
    4704             :   #include "backendbuilder.hpp"
    4705             :   #include "specreader.hpp"
    4706             : 
    4707             :   #include "toolexcept.hpp"
    4708             : 
    4709             :   using namespace kdb::tools;
    4710             : 
    4711             : 
    4712             : SWIGINTERNINLINE VALUE 
    4713          12 : SWIG_FromCharPtr(const char *cptr)
    4714             : { 
    4715          12 :   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
    4716             : }
    4717             : 
    4718             : 
    4719             :   /**
    4720             :    * SwigValueWrapper specialization for std::unique_ptr
    4721             :    * the default SwigValueWrapper implementation does not work here,
    4722             :    * since unique_ptr::unique_ptr(&unique_ptr) = delete;
    4723             :    *
    4724             :    * Therefore we have to create our own SwigValueWrapper for the
    4725             :    * pointer wrapper unique_ptr (wrapper of wrapper in a wrapper code ;)
    4726             :    */
    4727             :   template<>
    4728           3 :   class SwigValueWrapper< kdb::tools::PluginPtr > {
    4729             : 
    4730             :     kdb::tools::PluginPtr p;
    4731             : 
    4732             :   public:
    4733          10 :     SwigValueWrapper() : p(nullptr) { }
    4734           3 :     SwigValueWrapper& operator=(const kdb::tools::PluginPtr& t) {
    4735             :       /* transfer ownership from t to p
    4736             :        * scope of t will end in this function, thus also its pointer will
    4737             :        * be deleted (Plugin).
    4738             :        * So we move the pointer (Plugin) from t to p.
    4739             :        * a 'const_cast' is required here, since 'release()' modifies t
    4740             :        */
    4741           6 :       p.reset( (const_cast<kdb::tools::PluginPtr&>(t)).release() );
    4742           3 :       return *this;
    4743             :     }
    4744             : 
    4745             :     kdb::tools::PluginPtr *operator&() {
    4746             :       return &p;
    4747             :     }
    4748             :   };
    4749             : 
    4750             : 
    4751             :   /**
    4752             :    * SwigValueWrapper specialization for std::unique_ptr
    4753             :    * the default SwigValueWrapper implementation does not work here,
    4754             :    * since unique_ptr::unique_ptr(&unique_ptr) = delete;
    4755             :    *
    4756             :    * Therefore we have to create our own SwigValueWrapper for the
    4757             :    * pointer wrapper unique_ptr (wrapper of wrapper in a wrapper code ;)
    4758             :    */
    4759             :   template<>
    4760             :   class SwigValueWrapper< kdb::tools::BackendInterfacePtr > {
    4761             : 
    4762             :     kdb::tools::BackendInterfacePtr p;
    4763             : 
    4764             :   public:
    4765             :     SwigValueWrapper() : p(nullptr) { }
    4766             :     SwigValueWrapper& operator=(const kdb::tools::BackendInterfacePtr& t) {
    4767             :       /* transfer ownership from t to p
    4768             :        * scope of t will end in this function, thus also its pointer will
    4769             :        * be deleted (Plugin).
    4770             :        * So we move the pointer (Plugin) from t to p.
    4771             :        * a 'const_cast' is required here, since 'release()' modifies t
    4772             :        */
    4773             :       p.reset( (const_cast<kdb::tools::BackendInterfacePtr&>(t)).release() );
    4774             :       return *this;
    4775             :     }
    4776             : 
    4777             :     kdb::tools::BackendInterfacePtr *operator&() {
    4778             :       return &p;
    4779             :     }
    4780             :   };
    4781             : 
    4782             : 
    4783             :   /**
    4784             :    * SwigValueWrapper specialization for std::unique_ptr
    4785             :    * the default SwigValueWrapper implementation does not work here,
    4786             :    * since unique_ptr::unique_ptr(&unique_ptr) = delete;
    4787             :    *
    4788             :    * Therefore we have to create our own SwigValueWrapper for the
    4789             :    * pointer wrapper unique_ptr (wrapper of wrapper in a wrapper code ;)
    4790             :    */
    4791             :   template<>
    4792           0 :   class SwigValueWrapper< kdb::tools::MountBackendInterfacePtr > {
    4793             : 
    4794             :     kdb::tools::MountBackendInterfacePtr p;
    4795             : 
    4796             :   public:
    4797           0 :     SwigValueWrapper() : p(nullptr) { }
    4798             :     SwigValueWrapper& operator=(const kdb::tools::MountBackendInterfacePtr& t) {
    4799             :       /* transfer ownership from t to p
    4800             :        * scope of t will end in this function, thus also its pointer will
    4801             :        * be deleted (Plugin).
    4802             :        * So we move the pointer (Plugin) from t to p.
    4803             :        * a 'const_cast' is required here, since 'release()' modifies t
    4804             :        */
    4805           0 :       p.reset( (const_cast<kdb::tools::MountBackendInterfacePtr&>(t)).release() );
    4806             :       return *this;
    4807             :     }
    4808             : 
    4809             :     kdb::tools::MountBackendInterfacePtr *operator&() {
    4810             :       return &p;
    4811             :     }
    4812             :   };
    4813             : 
    4814             : 
    4815             :   namespace swig {
    4816             :     template <>  struct traits< kdb::tools::PluginSpec > {
    4817             :       typedef pointer_category category;
    4818             :       static const char* type_name() { return"kdb::tools::PluginSpec"; }
    4819             :     };
    4820             :   }
    4821             : 
    4822             : 
    4823             :       namespace swig {
    4824             :         template <>  struct traits<std::vector< kdb::tools::PluginSpec, std::allocator< kdb::tools::PluginSpec > > > {
    4825             :           typedef pointer_category category;
    4826             :           static const char* type_name() {
    4827             :             return "std::vector<" "kdb::tools::PluginSpec" "," "std::allocator< kdb::tools::PluginSpec >" " >";
    4828             :           }
    4829             :         };
    4830             :       }
    4831             :     
    4832           0 : SWIGINTERN std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *std_vector_Sl_kdb_tools_PluginSpec_Sg__dup(std::vector< kdb::tools::PluginSpec > *self){
    4833           0 :       return new std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >(*self);
    4834             :     }
    4835           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg__inspect(std::vector< kdb::tools::PluginSpec > *self){
    4836           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::const_iterator i = self->begin();
    4837           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::const_iterator e = self->end();
    4838           0 :       const char *type_name = swig::type_name< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > >();
    4839           0 :       VALUE str = rb_str_new2(type_name);
    4840           0 :       str = rb_str_cat2( str, " [" );
    4841             :       bool comma = false;
    4842             :       VALUE tmp;
    4843           0 :       for ( ; i != e; ++i, comma = true )
    4844             :         {
    4845           0 :           if (comma) str = rb_str_cat2( str, "," );
    4846           0 :           tmp = swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >( *i );
    4847           0 :           tmp = rb_inspect( tmp );
    4848           0 :           str = rb_str_buf_append( str, tmp );
    4849             :         }
    4850           0 :       str = rb_str_cat2( str, "]" );
    4851           0 :       return str;
    4852             :     }
    4853           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg__to_a(std::vector< kdb::tools::PluginSpec > *self){
    4854           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::const_iterator i = self->begin();
    4855           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::const_iterator e = self->end();
    4856           0 :       VALUE ary = rb_ary_new2( std::distance( i, e ) );
    4857             :       VALUE tmp;
    4858           0 :       for ( ; i != e; ++i )
    4859             :         {
    4860           0 :           tmp = swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >( *i );
    4861           0 :           rb_ary_push( ary, tmp );
    4862             :         }
    4863           0 :       return ary;
    4864             :     }
    4865           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg__to_s(std::vector< kdb::tools::PluginSpec > *self){
    4866           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::iterator i = self->begin();
    4867           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::iterator e = self->end();
    4868           0 :       VALUE str = rb_str_new2( "" );
    4869             :       VALUE tmp;
    4870           0 :       for ( ; i != e; ++i )
    4871             :         {
    4872           0 :           tmp = swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >( *i );
    4873           0 :           tmp = rb_obj_as_string( tmp );
    4874           0 :           str = rb_str_buf_append( str, tmp );
    4875             :         }
    4876           0 :       return str;
    4877             :     }
    4878           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg__slice(std::vector< kdb::tools::PluginSpec > *self,std::vector< kdb::tools::PluginSpec >::difference_type i,std::vector< kdb::tools::PluginSpec >::difference_type length){
    4879           0 :       if ( length < 0 )
    4880             :         return Qnil;
    4881           0 :       std::size_t len = self->size();
    4882           0 :       if ( i < 0 ) {
    4883           0 :         if ( i + static_cast<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::difference_type>(len) < 0 )
    4884             :           return Qnil;
    4885             :         else
    4886           0 :           i = len + i;
    4887             :       }
    4888           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::difference_type j = length + i;
    4889           0 :       if ( j > static_cast<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::difference_type>(len) )
    4890           0 :         j = len;
    4891             : 
    4892           0 :       VALUE r = Qnil;
    4893             :       try {
    4894           0 :         r = swig::from< const std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >* >( swig::getslice(self, i, j) );
    4895             :       }
    4896           0 :       catch( std::out_of_range ) {
    4897             :       }
    4898             :       return r;
    4899             :     }
    4900           0 : SWIGINTERN std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *std_vector_Sl_kdb_tools_PluginSpec_Sg__each(std::vector< kdb::tools::PluginSpec > *self){
    4901           0 :         if ( !rb_block_given_p() )
    4902           0 :           rb_raise( rb_eArgError, "no block given");
    4903             : 
    4904             :         VALUE r;
    4905           0 :         std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::const_iterator i = self->begin();
    4906           0 :         std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::const_iterator e = self->end();
    4907           0 :         for ( ; i != e; ++i )
    4908             :           {
    4909           0 :             r = swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >(*i);
    4910           0 :             rb_yield(r);
    4911             :           }
    4912             :         
    4913           0 :         return self;
    4914             :       }
    4915             : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg____delete2__(std::vector< kdb::tools::PluginSpec > *self,std::vector< kdb::tools::PluginSpec >::value_type const &i){
    4916           0 :       VALUE r = Qnil;
    4917             :       return r;
    4918             :     }
    4919           0 : SWIGINTERN std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *std_vector_Sl_kdb_tools_PluginSpec_Sg__select(std::vector< kdb::tools::PluginSpec > *self){
    4920           0 :       if ( !rb_block_given_p() )
    4921           0 :         rb_raise( rb_eArgError, "no block given" );
    4922             : 
    4923           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >* r = new std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >();
    4924           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::const_iterator i = self->begin();
    4925           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::const_iterator e = self->end();
    4926           0 :       for ( ; i != e; ++i )
    4927             :         {
    4928           0 :           VALUE v = swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >(*i);
    4929           0 :           if ( RTEST( rb_yield(v) ) )
    4930           0 :             self->insert( r->end(), *i);
    4931             :         }
    4932             :         
    4933           0 :       return r;
    4934             :     }
    4935           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg__delete_at(std::vector< kdb::tools::PluginSpec > *self,std::vector< kdb::tools::PluginSpec >::difference_type i){
    4936           0 :       VALUE r = Qnil;
    4937             :       try {
    4938           0 :         std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::iterator at = swig::getpos(self, i);
    4939           0 :         r = swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >( *(at) );
    4940           0 :         self->erase(at); 
    4941             :       }
    4942           0 :       catch (std::out_of_range)
    4943             :         {
    4944             :         }
    4945           0 :       return r;
    4946             :     }
    4947           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg__at(std::vector< kdb::tools::PluginSpec > const *self,std::vector< kdb::tools::PluginSpec >::difference_type i){
    4948           0 :       VALUE r = Qnil;
    4949             :       try {
    4950           0 :         r = swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >( *(swig::cgetpos(self, i)) );
    4951             :       }
    4952           0 :       catch( std::out_of_range ) {
    4953             :       }
    4954           0 :       return r;
    4955             :     }
    4956           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg____getitem____SWIG_0(std::vector< kdb::tools::PluginSpec > const *self,std::vector< kdb::tools::PluginSpec >::difference_type i,std::vector< kdb::tools::PluginSpec >::difference_type length){
    4957           0 :       if ( length < 0 )
    4958             :         return Qnil;
    4959           0 :       std::size_t len = self->size();
    4960           0 :       if ( i < 0 ) {
    4961           0 :         if ( i + static_cast<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::difference_type>(len) < 0 )
    4962             :           return Qnil;
    4963             :         else
    4964           0 :           i = len + i;
    4965             :       }
    4966           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::difference_type j = length + i;
    4967           0 :       if ( j > static_cast<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::difference_type>(len) )
    4968           0 :         j = len;
    4969             : 
    4970           0 :       VALUE r = Qnil;
    4971             :       try {
    4972           0 :         r = swig::from< const std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >* >( swig::getslice(self, i, j) );
    4973             :       }
    4974           0 :       catch( std::out_of_range ) {
    4975             :       }
    4976             :       return r;
    4977             :     }
    4978           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg____getitem____SWIG_1(std::vector< kdb::tools::PluginSpec > const *self,std::vector< kdb::tools::PluginSpec >::difference_type i){
    4979           0 :       VALUE r = Qnil;
    4980             :       try {
    4981           0 :         r = swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >( *(swig::cgetpos(self, i)) );
    4982             :       }
    4983           0 :       catch( std::out_of_range ) {
    4984             :       }
    4985           0 :       return r;
    4986             :     }
    4987           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg____getitem____SWIG_2(std::vector< kdb::tools::PluginSpec > const *self,VALUE i){
    4988           0 :       if ( rb_obj_is_kind_of( i, rb_cRange ) == Qfalse ) {
    4989           0 :         rb_raise( rb_eTypeError, "not a valid index or range" );
    4990             :       }
    4991             : 
    4992           0 :       static ID id_end   = rb_intern("end");
    4993           0 :       static ID id_start = rb_intern("begin");
    4994           0 :       static ID id_noend = rb_intern("exclude_end?");
    4995             : 
    4996           0 :       VALUE start = rb_funcall( i, id_start, 0 );
    4997           0 :       VALUE end   = rb_funcall( i, id_end, 0 );
    4998           0 :       bool  noend = ( rb_funcall( i, id_noend, 0 ) == Qtrue );
    4999             : 
    5000           0 :       int len = self->size();
    5001             : 
    5002           0 :       int s = NUM2INT( start );
    5003           0 :       if ( s < 0 ) {
    5004           0 :         s = len + s;
    5005           0 :         if ( s < 0 )
    5006             :           return Qnil;
    5007           0 :       } else if ( s > len )
    5008             :         return Qnil;
    5009             : 
    5010           0 :       int e = NUM2INT( end );
    5011           0 :       if ( e < 0 ) e = len + e;
    5012           0 :       if ( noend ) e -= 1;
    5013           0 :       if ( e < 0 ) e = -1;
    5014           0 :       if ( e >= len ) e = len - 1;
    5015           0 :       if ( s == len ) e = len - 1;
    5016             : 
    5017           0 :       return swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >* >( swig::getslice(self, s, e+1) );
    5018             :     }
    5019           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg____setitem____SWIG_0(std::vector< kdb::tools::PluginSpec > *self,std::vector< kdb::tools::PluginSpec >::difference_type i,std::vector< kdb::tools::PluginSpec >::value_type const &x){
    5020           0 :         if ( i >= static_cast<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::difference_type>( self->size()) )
    5021           0 :           swig::resize( self, i+1, x );
    5022             :         else
    5023           0 :           *(swig::getpos(self, i)) = x;
    5024             : 
    5025           0 :         return swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >( x );
    5026             :       }
    5027           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg____setitem____SWIG_1(std::vector< kdb::tools::PluginSpec > *self,std::vector< kdb::tools::PluginSpec >::difference_type i,std::vector< kdb::tools::PluginSpec >::difference_type length,std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > const &v){
    5028             : 
    5029           0 :       if ( length < 0 )
    5030             :         return Qnil;
    5031           0 :       std::size_t len = self->size();
    5032           0 :       if ( i < 0 ) {
    5033           0 :         if ( i + static_cast<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::difference_type>(len) < 0 )
    5034             :           return Qnil;
    5035             :         else
    5036           0 :           i = len + i;
    5037             :       }
    5038           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::difference_type j = length + i;
    5039           0 :       if ( j > static_cast<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::difference_type>(len) ) {
    5040           0 :         swig::resize( self, j, *(v.begin()) );
    5041             :       }
    5042             : 
    5043           0 :       VALUE r = Qnil;
    5044           0 :       swig::setslice(self, i, j, v);
    5045           0 :       r = swig::from< const std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >* >( &v );
    5046             :       return r;
    5047             :     }
    5048           0 : SWIGINTERN std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *std_vector_Sl_kdb_tools_PluginSpec_Sg__reject_bang(std::vector< kdb::tools::PluginSpec > *self){
    5049           0 :       if ( !rb_block_given_p() )
    5050           0 :         rb_raise( rb_eArgError, "no block given" );
    5051             : 
    5052           0 :       self->erase( std::remove_if( self->begin(), self->end(),
    5053           0 :             swig::yield< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >() ), self->end() );
    5054           0 :       return self;
    5055             :     }
    5056           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg__pop(std::vector< kdb::tools::PluginSpec > *self){
    5057           0 :       if (self->empty()) return Qnil;
    5058           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type x = self->back();
    5059           0 :       self->pop_back();
    5060           0 :       return swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >( x );
    5061             :     }
    5062             : SWIGINTERN std::vector< kdb::tools::PluginSpec >::value_type const std_vector_Sl_kdb_tools_PluginSpec_Sg__push(std::vector< kdb::tools::PluginSpec > *self,std::vector< kdb::tools::PluginSpec >::value_type const &e){
    5063           0 :       self->push_back( e );
    5064           0 :       return e;
    5065             :     }
    5066           0 : SWIGINTERN std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *std_vector_Sl_kdb_tools_PluginSpec_Sg__reject(std::vector< kdb::tools::PluginSpec > *self){
    5067           0 :       if ( !rb_block_given_p() )
    5068           0 :         rb_raise( rb_eArgError, "no block given" );
    5069             : 
    5070           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >* r = new std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >();
    5071             :       std::remove_copy_if( self->begin(), self->end(),              
    5072             :                            std::back_inserter(*r),
    5073           0 :                            swig::yield< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >() );
    5074           0 :       return r;
    5075             :     }
    5076           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_PluginSpec_Sg__shift(std::vector< kdb::tools::PluginSpec > *self){
    5077           0 :       if (self->empty()) return Qnil;
    5078           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type x = self->front();
    5079           0 :       self->erase( self->begin() );
    5080           0 :       return swig::from< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type >( x );
    5081             :     }
    5082           0 : SWIGINTERN std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *std_vector_Sl_kdb_tools_PluginSpec_Sg__insert(std::vector< kdb::tools::PluginSpec > *self,std::vector< kdb::tools::PluginSpec >::difference_type pos,int argc,VALUE *argv,...){
    5083           0 :       std::size_t len = self->size();
    5084           0 :       std::size_t   i = swig::check_index( pos, len, true );
    5085           0 :       std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::iterator start;
    5086             : 
    5087           0 :       VALUE elem = argv[0];
    5088           0 :       int idx = 0;
    5089             :       try {
    5090           0 :         std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type val = swig::as<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type>( elem, true );
    5091           0 :         if ( i >= len ) {
    5092           0 :           self->resize(i-1, val);
    5093           0 :           return self;
    5094             :         }
    5095           0 :         start = self->begin();
    5096           0 :         std::advance( start, i );
    5097           0 :         self->insert( start++, val );
    5098             : 
    5099           0 :         for ( ++idx; idx < argc; ++idx )
    5100             :           {
    5101           0 :             elem = argv[idx];
    5102           0 :             val = swig::as<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type>( elem );
    5103           0 :             self->insert( start++, val );
    5104             :           }
    5105             : 
    5106             :       } 
    5107           0 :       catch( std::invalid_argument )
    5108             :         {
    5109           0 :           rb_raise( rb_eArgError, "%s",
    5110             :                     Ruby_Format_TypeError( "", 
    5111             :                                            swig::type_name<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type>(),
    5112           0 :                                            __FUNCTION__, idx+2, elem ));
    5113             :         }
    5114             : 
    5115             : 
    5116           0 :       return self;
    5117             :     }
    5118           0 : SWIGINTERN std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *std_vector_Sl_kdb_tools_PluginSpec_Sg__unshift(std::vector< kdb::tools::PluginSpec > *self,int argc,VALUE *argv,...){
    5119           0 :       for ( int idx = argc-1; idx >= 0; --idx )
    5120             :         {
    5121           0 :           std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::iterator start = self->begin();
    5122           0 :           VALUE elem = argv[idx];
    5123             :           try {
    5124           0 :             std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type val = swig::as<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type>( elem, true );
    5125           0 :             self->insert( start, val );
    5126             :           }
    5127           0 :           catch( std::invalid_argument )
    5128             :             {
    5129           0 :               rb_raise( rb_eArgError, "%s",
    5130             :                         Ruby_Format_TypeError( "", 
    5131             :                                                swig::type_name<std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > >::value_type>(),
    5132           0 :                                                __FUNCTION__, idx+2, elem ));
    5133             :             }
    5134             :         }
    5135             : 
    5136           0 :       return self;
    5137             :     }
    5138             : 
    5139             : SWIGINTERN int
    5140           0 : SWIG_AsVal_bool (VALUE obj, bool *val)
    5141             : {
    5142           0 :   if (obj == Qtrue) {
    5143           0 :     if (val) *val = true;
    5144             :     return SWIG_OK;
    5145           0 :   } else if (obj == Qfalse) {
    5146           0 :     if (val) *val = false;
    5147             :     return SWIG_OK;
    5148             :   } else {
    5149           0 :     int res = 0;
    5150           0 :     if (SWIG_AsVal_int (obj, &res) == SWIG_OK) {    
    5151           0 :       if (val) *val = res ? true : false;
    5152             :       return SWIG_OK;
    5153             :     }
    5154             :   }  
    5155             :   return SWIG_TypeError;
    5156             : }
    5157             : 
    5158             : 
    5159             : namespace swig {
    5160             :   template <> struct traits< int > {
    5161             :     typedef value_category category;
    5162             :     static const char* type_name() { return"int"; }
    5163             :   };
    5164             :   template <>  struct traits_asval< int > {
    5165             :     typedef int value_type;
    5166             :     static int asval(VALUE obj, value_type *val) {
    5167           0 :       return SWIG_AsVal_int (obj, val);
    5168             :     }
    5169             :   };
    5170             :   template <>  struct traits_from< int > {
    5171             :     typedef int value_type;
    5172             :     static VALUE from(const value_type& val) {
    5173           6 :       return SWIG_From_int  (val);
    5174             :     }
    5175             :   };
    5176             : }
    5177             : 
    5178             : 
    5179             :   namespace swig {
    5180             : 
    5181             :     template <class T, class U >
    5182             :     struct traits_asval<std::pair<T,U> >  {
    5183             :       typedef std::pair<T,U> value_type;
    5184             : 
    5185             :       static int get_pair(VALUE first, VALUE second,
    5186             :                           std::pair<T,U> *val)
    5187             :       {
    5188             :         if (val) {
    5189             :           T *pfirst = &(val->first);
    5190             :           int res1 = swig::asval((VALUE)first, pfirst);
    5191             :           if (!SWIG_IsOK(res1)) return res1;
    5192             :           U *psecond = &(val->second);
    5193             :           int res2 = swig::asval((VALUE)second, psecond);
    5194             :           if (!SWIG_IsOK(res2)) return res2;
    5195             :           return res1 > res2 ? res1 : res2;
    5196             :         } else {
    5197             :           T *pfirst = 0;
    5198             :           int res1 = swig::asval((VALUE)first, pfirst);
    5199             :           if (!SWIG_IsOK(res1)) return res1;
    5200             :           U *psecond = 0;
    5201             :           int res2 = swig::asval((VALUE)second, psecond);
    5202             :           if (!SWIG_IsOK(res2)) return res2;
    5203             :           return res1 > res2 ? res1 : res2;
    5204             :         }       
    5205             :       }
    5206             : 
    5207             :       static int asval(VALUE obj, std::pair<T,U> *val) {
    5208             :         int res = SWIG_ERROR;
    5209             :         if ( TYPE(obj) == T_ARRAY ) {
    5210             :           if (RARRAY_LEN(obj) == 2) {
    5211             :             VALUE first = rb_ary_entry(obj,0);
    5212             :             VALUE second = rb_ary_entry(obj,1);
    5213             :             res = get_pair(first, second, val);
    5214             :           }
    5215             :         } else {
    5216             :           value_type *p;
    5217             :           res = SWIG_ConvertPtr(obj,(void**)&p,
    5218             :                                 swig::type_info<value_type>(),0);
    5219             :           if (SWIG_IsOK(res) && val)  *val = *p;
    5220             :         }
    5221             :         return res;
    5222             :       }
    5223             :     };
    5224             : 
    5225             :     template <class T, class U >
    5226             :     struct traits_asptr<std::pair<T,U> >  {
    5227             :       typedef std::pair<T,U> value_type;
    5228             : 
    5229           0 :       static int get_pair(VALUE first, VALUE second,
    5230             :                           std::pair<T,U> **val) 
    5231             :       {
    5232           0 :         if (val) {
    5233           0 :           value_type *vp = (new std::pair<T,U>);
    5234           0 :           T *pfirst = &(vp->first);
    5235           0 :           int res1 = swig::asval((VALUE)first, pfirst);
    5236           0 :           if (!SWIG_IsOK(res1)) return res1;
    5237           0 :           U *psecond = &(vp->second);
    5238           0 :           int res2 = swig::asval((VALUE)second, psecond);
    5239           0 :           if (!SWIG_IsOK(res2)) return res2;
    5240           0 :           *val = vp;
    5241           0 :           return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
    5242             :         } else {
    5243           0 :           T *pfirst = 0;
    5244           0 :           int res1 = swig::asval((VALUE)first, pfirst);
    5245           0 :           if (!SWIG_IsOK(res1)) return res1;
    5246           0 :           U *psecond = 0;
    5247           0 :           int res2 = swig::asval((VALUE)second, psecond);
    5248           0 :           if (!SWIG_IsOK(res2)) return res2;
    5249           0 :           return res1 > res2 ? res1 : res2;
    5250             :         }       
    5251             :       }
    5252             : 
    5253           0 :       static int asptr(VALUE obj, std::pair<T,U> **val) {
    5254           0 :         int res = SWIG_ERROR;
    5255           0 :         if ( TYPE(obj) == T_ARRAY ) {
    5256           0 :           if ( RARRAY_LEN(obj) == 2) {
    5257           0 :             VALUE first = rb_ary_entry(obj,0);
    5258           0 :             VALUE second = rb_ary_entry(obj,1);
    5259           0 :             res = get_pair(first, second, val);
    5260             :           }
    5261             :         } else {
    5262             :           value_type *p;
    5263           0 :           res = SWIG_ConvertPtr(obj,(void**)&p,
    5264             :                                 swig::type_info<value_type>(),0);
    5265           0 :           if (SWIG_IsOK(res) && val)  *val = p;
    5266             :         }
    5267           0 :         return res;
    5268             :       }
    5269             :     };
    5270             : 
    5271             : 
    5272             : 
    5273             :     template <class T, class U >
    5274             :     struct traits_from<std::pair<T,U> >   {
    5275           0 :       static VALUE _wrap_pair_second( VALUE self )
    5276             :       {
    5277           0 :         std::pair< typename swig::noconst_traits<T >::noconst_type,U>* p = NULL;
    5278           0 :         swig::asptr( self, &p );
    5279           0 :         return swig::from( p->second );
    5280             :       }
    5281             : 
    5282           0 :       static VALUE _wrap_pair_second_eq( VALUE self, VALUE arg )
    5283             :       {
    5284           0 :         std::pair< typename swig::noconst_traits<T >::noconst_type,U>* p = NULL;
    5285           0 :         swig::asptr( self, &p );
    5286           0 :         return swig::from( p->second );
    5287             :       }
    5288             : 
    5289           0 :       static VALUE from(const std::pair<T,U>& val) {
    5290           0 :         VALUE obj = rb_ary_new2(2);
    5291           0 :         rb_ary_push(obj, swig::from<typename swig::noconst_traits<T >::noconst_type>(val.first));
    5292           0 :         rb_ary_push(obj, swig::from(val.second));
    5293           0 :         rb_define_singleton_method(obj, "second",
    5294             :                                    VALUEFUNC(_wrap_pair_second), 0 );
    5295           0 :         rb_define_singleton_method(obj, "second=",
    5296             :                                    VALUEFUNC(_wrap_pair_second_eq), 1 );
    5297           0 :         rb_obj_freeze(obj); // treat as immutable tuple
    5298           0 :         return obj;
    5299             :       }
    5300             :     };
    5301             : 
    5302             :   }
    5303             : 
    5304             : 
    5305             :       namespace swig {
    5306             :         template <>  struct traits<std::pair< int, kdb::tools::PluginSpec > > {
    5307             :           typedef pointer_category category;
    5308             :           static const char* type_name() {
    5309             :             return "std::pair<" "int" "," "kdb::tools::PluginSpec" " >";
    5310             :           }
    5311             :         };
    5312             :       }
    5313             :     
    5314             : 
    5315             :   namespace swig {
    5316             :     template <class ValueType>
    5317             :     struct from_key_oper 
    5318             :     {
    5319             :       typedef const ValueType& argument_type;
    5320             :       typedef  VALUE result_type;
    5321             :       result_type operator()(argument_type v) const
    5322             :       {
    5323           0 :         return swig::from(v.first);
    5324             :       }
    5325             :     };
    5326             : 
    5327             :     template <class ValueType>
    5328             :     struct from_value_oper 
    5329             :     {
    5330             :       typedef const ValueType& argument_type;
    5331             :       typedef  VALUE result_type;
    5332             :       result_type operator()(argument_type v) const
    5333             :       {
    5334           0 :         return swig::from(v.second);
    5335             :       }
    5336             :     };
    5337             : 
    5338             :     template<class OutIterator, class FromOper, 
    5339             :              class ValueType = typename OutIterator::value_type>
    5340           0 :     struct MapIterator_T : ConstIteratorClosed_T<OutIterator, ValueType, FromOper>
    5341             :     {
    5342             :       MapIterator_T(OutIterator curr, OutIterator first, OutIterator last, VALUE seq)
    5343           0 :         : ConstIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
    5344             :       {
    5345             :       }
    5346             :     };
    5347             : 
    5348             : 
    5349             :     template<class OutIterator,
    5350             :              class FromOper = from_key_oper<typename OutIterator::value_type> >
    5351           0 :     struct MapKeyIterator_T : MapIterator_T<OutIterator, FromOper>
    5352             :     {
    5353             :       MapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, VALUE seq)
    5354           0 :         : MapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
    5355             :       {
    5356             :       }
    5357             :     };
    5358             : 
    5359             :     template<typename OutIter>
    5360             :     inline ConstIterator*
    5361           0 :     make_output_key_iterator(const OutIter& current, const OutIter& begin, 
    5362             :                              const OutIter& end, VALUE seq = 0)
    5363             :     {
    5364           0 :       return new MapKeyIterator_T<OutIter>(current, begin, end, seq);
    5365             :     }
    5366             : 
    5367             :     template<class OutIterator,
    5368             :              class FromOper = from_value_oper<typename OutIterator::value_type> >
    5369           0 :     struct MapValueIterator_T : MapIterator_T<OutIterator, FromOper>
    5370             :     {
    5371             :       MapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, VALUE seq)
    5372           0 :         : MapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
    5373             :       {
    5374             :       }
    5375             :     };
    5376             :     
    5377             : 
    5378             :     template<typename OutIter>
    5379             :     inline ConstIterator*
    5380           0 :     make_output_value_iterator(const OutIter& current, const OutIter& begin, 
    5381             :                                const OutIter& end, VALUE seq = 0)
    5382             :     {
    5383           0 :       return new MapValueIterator_T<OutIter>(current, begin, end, seq);
    5384             :     }
    5385             :   }
    5386             : 
    5387             : 
    5388             :   namespace swig {
    5389             :     template <class RubySeq, class K, class T >
    5390             :     inline void
    5391           0 :     assign(const RubySeq& rubyseq, std::map<K,T > *map) {
    5392             :       typedef typename std::map<K,T>::value_type value_type;
    5393           0 :       typename RubySeq::const_iterator it = rubyseq.begin();
    5394           0 :       for (;it != rubyseq.end(); ++it) {
    5395           0 :         map->insert(value_type(it->first, it->second));
    5396             :       }
    5397           0 :     }
    5398             : 
    5399             :     template <class K, class T>
    5400             :     struct traits_asptr<std::map<K,T> >  {
    5401             :       typedef std::map<K,T> map_type;
    5402           0 :       static int asptr(VALUE obj, map_type **val) {
    5403           0 :         int res = SWIG_ERROR;
    5404           0 :         if ( TYPE(obj) == T_HASH ) {
    5405           0 :           static ID id_to_a = rb_intern("to_a");
    5406           0 :           VALUE items = rb_funcall(obj, id_to_a, 0);
    5407           0 :           res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
    5408             :         } else {
    5409             :           map_type *p;
    5410           0 :           res = SWIG_ConvertPtr(obj,(void**)&p,swig::type_info<map_type>(),0);
    5411           0 :           if (SWIG_IsOK(res) && val)  *val = p;
    5412             :         }
    5413           0 :         return res;
    5414             :       }
    5415             :     };
    5416             :       
    5417             :     template <class K, class T >
    5418             :     struct traits_from<std::map<K,T> >  {
    5419             :       typedef std::map<K,T> map_type;
    5420             :       typedef typename map_type::const_iterator const_iterator;
    5421             :       typedef typename map_type::size_type size_type;
    5422             :             
    5423           1 :       static VALUE from(const map_type& map) {
    5424           1 :         swig_type_info *desc = swig::type_info<map_type>();
    5425           1 :         if (desc && desc->clientdata) {
    5426           2 :           return SWIG_NewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
    5427             :         } else {
    5428           0 :           size_type size = map.size();
    5429           0 :           int rubysize = (size <= (size_type) INT_MAX) ? (int) size : -1;
    5430           0 :           if (rubysize < 0) {
    5431             :             SWIG_RUBY_THREAD_BEGIN_BLOCK;
    5432           0 :             rb_raise( rb_eRuntimeError, "map size not valid in Ruby");
    5433             :             SWIG_RUBY_THREAD_END_BLOCK;
    5434             :             return Qnil;
    5435             :           }
    5436           0 :           VALUE obj = rb_hash_new();
    5437           0 :           for (const_iterator i= map.begin(); i!= map.end(); ++i) {
    5438           0 :             VALUE key = swig::from(i->first);
    5439           0 :             VALUE val = swig::from(i->second);
    5440           0 :             rb_hash_aset(obj, key, val);
    5441             :           }
    5442             :           return obj;
    5443             :         }
    5444             :       }
    5445             :     };
    5446             :   }
    5447             : 
    5448             : 
    5449             :       namespace swig {
    5450             :         template <>  struct traits<std::map< int, kdb::tools::PluginSpec, std::less< int >, std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > > {
    5451             :           typedef pointer_category category;
    5452             :           static const char* type_name() {
    5453             :             return "std::map<" "int" "," "kdb::tools::PluginSpec" "," "std::less< int >" "," "std::allocator< std::pair< int const,kdb::tools::PluginSpec > >" " >";
    5454             :           }
    5455             :         };
    5456             :       }
    5457             :     
    5458           0 : SWIGINTERN std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__dup(std::map< int,kdb::tools::PluginSpec > *self){
    5459           0 :       return new std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >(*self);
    5460             :     }
    5461           0 : SWIGINTERN VALUE std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg____delete__(std::map< int,kdb::tools::PluginSpec > *self,std::map< int,kdb::tools::PluginSpec >::key_type const &key){
    5462           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::iterator i = self->find(key);
    5463           0 :       if (i != self->end()) {
    5464           0 :         self->erase(i);
    5465           0 :         return swig::from( key );
    5466             :       }
    5467             :       else {
    5468             :         return Qnil;
    5469             :       }
    5470             :     }
    5471             : SWIGINTERN bool std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__has_key(std::map< int,kdb::tools::PluginSpec > const *self,std::map< int,kdb::tools::PluginSpec >::key_type const &key){
    5472           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator i = self->find(key);
    5473           0 :       return i != self->end();
    5474             :     }
    5475           0 : SWIGINTERN VALUE std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__keys(std::map< int,kdb::tools::PluginSpec > *self){
    5476           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::size_type size = self->size();
    5477           0 :       int rubysize = (size <= (std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::size_type) INT_MAX) ? (int) size : -1;
    5478           0 :       if (rubysize < 0) {
    5479             :         SWIG_RUBY_THREAD_BEGIN_BLOCK;
    5480           0 :         rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
    5481             :         SWIG_RUBY_THREAD_END_BLOCK;
    5482             :         return Qnil;
    5483             :       }
    5484           0 :       VALUE ary = rb_ary_new2(rubysize);
    5485           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator i = self->begin();
    5486           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator e = self->end();
    5487           0 :       for ( ; i != e; ++i ) {
    5488           0 :         rb_ary_push( ary, swig::from(i->first) );
    5489             :       }
    5490             :       return ary;
    5491             :     }
    5492           1 : SWIGINTERN std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__each(std::map< int,kdb::tools::PluginSpec > *self){
    5493           1 :         if ( !rb_block_given_p() )
    5494           0 :           rb_raise( rb_eArgError, "no block given");
    5495             : 
    5496             :         VALUE k, v;
    5497           1 :         std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::iterator i = self->begin();
    5498           1 :         std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::iterator e = self->end();
    5499           4 :         for ( ; i != e; ++i )
    5500             :           {
    5501           3 :             const std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::key_type&    key = i->first;
    5502           3 :             const std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::mapped_type& val = i->second;
    5503             : 
    5504           6 :             k = swig::from<std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::key_type>(key);
    5505           3 :             v = swig::from<std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::mapped_type>(val);
    5506           3 :             rb_yield_values(2, k, v);
    5507             :           }
    5508             :         
    5509           1 :         return self;
    5510             :       }
    5511           0 : SWIGINTERN std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__select(std::map< int,kdb::tools::PluginSpec > *self){
    5512           0 :       if ( !rb_block_given_p() )
    5513           0 :         rb_raise( rb_eArgError, "no block given" );
    5514             : 
    5515           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >* r = new std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >;
    5516           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::iterator i = self->begin();
    5517           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::iterator e = self->end();
    5518           0 :       for ( ; i != e; ++i )
    5519             :         {
    5520           0 :           VALUE k = swig::from<std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::key_type>(i->first);
    5521           0 :           VALUE v = swig::from<std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::mapped_type>(i->second);
    5522           0 :           if ( RTEST( rb_yield_values(2, k, v) ) )
    5523           0 :             self->insert(r->end(), *i);
    5524             :         }
    5525             :         
    5526           0 :       return r;
    5527             :     }
    5528           0 : SWIGINTERN VALUE std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__values_at(std::map< int,kdb::tools::PluginSpec > *self,int argc,VALUE *argv,...){
    5529             :     
    5530           0 :     VALUE r = rb_ary_new();
    5531           0 :     ID   id = rb_intern("[]");
    5532           0 :     swig_type_info* type = swig::type_info< std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > >();
    5533           0 :     VALUE me = SWIG_NewPointerObj( self, type, 0 );
    5534           0 :     for ( int i = 0; i < argc; ++i )
    5535             :       {
    5536           0 :         VALUE key = argv[i];
    5537           0 :         VALUE tmp = rb_funcall( me, id, 1, key );
    5538           0 :         rb_ary_push( r, tmp );
    5539             :       }
    5540             :     
    5541           0 :     return r;
    5542             :   }
    5543           0 : SWIGINTERN std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__each_key(std::map< int,kdb::tools::PluginSpec > *self){
    5544           0 :         if ( !rb_block_given_p() )
    5545           0 :           rb_raise( rb_eArgError, "no block given");
    5546             : 
    5547             :         VALUE r;
    5548           0 :         std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::iterator i = self->begin();
    5549           0 :         std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::iterator e = self->end();
    5550           0 :         for ( ; i != e; ++i )
    5551             :           {
    5552           0 :             r = swig::from( i->first );
    5553           0 :             rb_yield(r);
    5554             :           }
    5555             :         
    5556           0 :         return self;
    5557             :       }
    5558           0 : SWIGINTERN VALUE std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__values(std::map< int,kdb::tools::PluginSpec > *self){
    5559           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::size_type size = self->size();
    5560           0 :       int rubysize = (size <= (std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::size_type) INT_MAX) ? (int) size : -1;
    5561           0 :       if (rubysize < 0) {
    5562             :         SWIG_RUBY_THREAD_BEGIN_BLOCK;
    5563           0 :         rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
    5564             :         SWIG_RUBY_THREAD_END_BLOCK;
    5565             :         return Qnil;
    5566             :       }
    5567           0 :       VALUE ary = rb_ary_new2(rubysize);
    5568           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator i = self->begin();
    5569           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator e = self->end();
    5570           0 :       for ( ; i != e; ++i ) {
    5571           0 :         rb_ary_push( ary, swig::from(i->second) );
    5572             :       }
    5573             :       return ary;
    5574             :     }
    5575           0 : SWIGINTERN std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__each_value(std::map< int,kdb::tools::PluginSpec > *self){
    5576           0 :         if ( !rb_block_given_p() )
    5577           0 :           rb_raise( rb_eArgError, "no block given");
    5578             : 
    5579             :         VALUE r;
    5580           0 :         std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::iterator i = self->begin();
    5581           0 :         std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::iterator e = self->end();
    5582           0 :         for ( ; i != e; ++i )
    5583             :           {
    5584           0 :             r = swig::from( i->second );
    5585           0 :             rb_yield(r);
    5586             :           }
    5587             :         
    5588           0 :         return self;
    5589             :       }
    5590           0 : SWIGINTERN VALUE std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__entries(std::map< int,kdb::tools::PluginSpec > *self){
    5591           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::size_type size = self->size();
    5592           0 :       int rubysize = (size <= (std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::size_type) INT_MAX) ? (int) size : -1;
    5593           0 :       if (rubysize < 0) {
    5594             :         SWIG_RUBY_THREAD_BEGIN_BLOCK;
    5595           0 :         rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
    5596             :         SWIG_RUBY_THREAD_END_BLOCK;
    5597             :         return Qnil;
    5598             :       }
    5599           0 :       VALUE ary = rb_ary_new2(rubysize);
    5600           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator i = self->begin();
    5601           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator e = self->end();
    5602           0 :       for ( ; i != e; ++i ) {
    5603           0 :         rb_ary_push( ary, swig::from<std::pair<std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::key_type, 
    5604           0 :                      std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::mapped_type> >(*i) );
    5605             :       }
    5606             :       return ary;
    5607             :     }
    5608             : SWIGINTERN bool std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg____contains__(std::map< int,kdb::tools::PluginSpec > *self,std::map< int,kdb::tools::PluginSpec >::key_type const &key){
    5609           0 :       return self->find(key) != self->end();
    5610             :     }
    5611             : SWIGINTERN swig::ConstIterator *std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__key_iterator(std::map< int,kdb::tools::PluginSpec > *self,VALUE *RUBY_SELF){
    5612           0 :       return swig::make_output_key_iterator(self->begin(), self->begin(), 
    5613           0 :                                             self->end(), *RUBY_SELF);
    5614             :     }
    5615             : SWIGINTERN swig::ConstIterator *std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__value_iterator(std::map< int,kdb::tools::PluginSpec > *self,VALUE *RUBY_SELF){
    5616           0 :       return swig::make_output_value_iterator(self->begin(), self->begin(), 
    5617           0 :                                               self->end(), *RUBY_SELF);
    5618             :     }
    5619           0 : SWIGINTERN VALUE std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg____getitem__(std::map< int,kdb::tools::PluginSpec > const *self,std::map< int,kdb::tools::PluginSpec >::key_type const &key){
    5620           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator i = self->find(key);
    5621           0 :       if ( i != self->end() )
    5622           0 :         return swig::from<std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::mapped_type>( i->second );
    5623             :       else
    5624             :         return Qnil;
    5625             :     }
    5626             : SWIGINTERN void std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg____setitem__(std::map< int,kdb::tools::PluginSpec > *self,std::map< int,kdb::tools::PluginSpec >::key_type const &key,std::map< int,kdb::tools::PluginSpec >::mapped_type const &x){
    5627           0 :       (*self)[key] = x;
    5628             :     }
    5629           0 : SWIGINTERN VALUE std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__inspect(std::map< int,kdb::tools::PluginSpec > *self){
    5630           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator i = self->begin();
    5631           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator e = self->end();
    5632           0 :       const char *type_name = swig::type_name< std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > >();
    5633           0 :       VALUE str = rb_str_new2( type_name );
    5634           0 :       str = rb_str_cat2( str, " {" );
    5635             :       bool comma = false;
    5636             :       VALUE tmp;
    5637           0 :       for ( ; i != e; ++i, comma = true )
    5638             :         {
    5639           0 :           if (comma) str = rb_str_cat2( str, "," );
    5640           0 :           tmp = swig::from< std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::key_type >( i->first );
    5641           0 :           tmp = rb_inspect( tmp );
    5642           0 :           str = rb_str_buf_append( str, tmp );
    5643           0 :           str = rb_str_cat2( str, "=>" );
    5644           0 :           tmp = swig::from< std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::mapped_type >( i->second );
    5645           0 :           tmp = rb_inspect( tmp );
    5646           0 :           str = rb_str_buf_append( str, tmp );
    5647             :         }
    5648           0 :       str = rb_str_cat2( str, "}" );
    5649           0 :       return str;
    5650             :     }
    5651           0 : SWIGINTERN VALUE std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__to_a(std::map< int,kdb::tools::PluginSpec > *self){
    5652           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator i = self->begin();
    5653           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::const_iterator e = self->end();
    5654           0 :       VALUE ary = rb_ary_new2( std::distance( i, e ) );
    5655             :       VALUE tmp;
    5656           0 :       for ( ; i != e; ++i )
    5657             :         {
    5658             :           // @todo: improve -- this should just be swig::from(*i)
    5659             :           tmp = swig::from< std::pair<std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::key_type, 
    5660           0 :             std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::mapped_type> >( *i );
    5661           0 :           rb_ary_push( ary, tmp );
    5662             :         }
    5663           0 :       return ary;
    5664             :     }
    5665           0 : SWIGINTERN VALUE std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__to_s(std::map< int,kdb::tools::PluginSpec > *self){
    5666           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::iterator i = self->begin();
    5667           0 :       std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::iterator e = self->end();
    5668           0 :       VALUE str = rb_str_new2( "" );
    5669             :       VALUE tmp;
    5670           0 :       for ( ; i != e; ++i )
    5671             :         {
    5672             :           // @todo: improve -- this should just be swig::from(*i)
    5673             :           tmp = swig::from< std::pair<std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::key_type, 
    5674           0 :             std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > >::mapped_type> >( *i );
    5675           0 :           tmp = rb_obj_as_string( tmp );
    5676           0 :           str = rb_str_buf_append( str, tmp );
    5677             :         }
    5678           0 :       return str;
    5679             :     }
    5680           0 : SWIGINTERN std::string kdb_tools_Backend_status(kdb::tools::Backend *self){
    5681           0 :     std::ostringstream os;
    5682           0 :     self->status(os);
    5683           0 :     return os.str();
    5684             :   }
    5685           0 : SWIGINTERN std::string kdb_tools_ImportExportBackend_status__SWIG_1(kdb::tools::ImportExportBackend *self){
    5686           0 :     std::ostringstream os;
    5687           0 :     self->status(os);
    5688           0 :     return os.str();
    5689             :   }
    5690             : 
    5691             :   namespace swig {
    5692             :     template <>  struct traits< kdb::tools::BackendInfo > {
    5693             :       typedef pointer_category category;
    5694             :       static const char* type_name() { return"kdb::tools::BackendInfo"; }
    5695             :     };
    5696             :   }
    5697             : 
    5698             : 
    5699             :       namespace swig {
    5700             :         template <>  struct traits<std::vector< kdb::tools::BackendInfo, std::allocator< kdb::tools::BackendInfo > > > {
    5701             :           typedef pointer_category category;
    5702             :           static const char* type_name() {
    5703             :             return "std::vector<" "kdb::tools::BackendInfo" "," "std::allocator< kdb::tools::BackendInfo >" " >";
    5704             :           }
    5705             :         };
    5706             :       }
    5707             :     
    5708           0 : SWIGINTERN std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *std_vector_Sl_kdb_tools_BackendInfo_Sg__dup(std::vector< kdb::tools::BackendInfo > *self){
    5709           0 :       return new std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >(*self);
    5710             :     }
    5711           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg__inspect(std::vector< kdb::tools::BackendInfo > *self){
    5712           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::const_iterator i = self->begin();
    5713           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::const_iterator e = self->end();
    5714           0 :       const char *type_name = swig::type_name< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > >();
    5715           0 :       VALUE str = rb_str_new2(type_name);
    5716           0 :       str = rb_str_cat2( str, " [" );
    5717             :       bool comma = false;
    5718             :       VALUE tmp;
    5719           0 :       for ( ; i != e; ++i, comma = true )
    5720             :         {
    5721           0 :           if (comma) str = rb_str_cat2( str, "," );
    5722           0 :           tmp = swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >( *i );
    5723           0 :           tmp = rb_inspect( tmp );
    5724           0 :           str = rb_str_buf_append( str, tmp );
    5725             :         }
    5726           0 :       str = rb_str_cat2( str, "]" );
    5727           0 :       return str;
    5728             :     }
    5729           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg__to_a(std::vector< kdb::tools::BackendInfo > *self){
    5730           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::const_iterator i = self->begin();
    5731           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::const_iterator e = self->end();
    5732           0 :       VALUE ary = rb_ary_new2( std::distance( i, e ) );
    5733             :       VALUE tmp;
    5734           0 :       for ( ; i != e; ++i )
    5735             :         {
    5736           0 :           tmp = swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >( *i );
    5737           0 :           rb_ary_push( ary, tmp );
    5738             :         }
    5739           0 :       return ary;
    5740             :     }
    5741           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg__to_s(std::vector< kdb::tools::BackendInfo > *self){
    5742           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::iterator i = self->begin();
    5743           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::iterator e = self->end();
    5744           0 :       VALUE str = rb_str_new2( "" );
    5745             :       VALUE tmp;
    5746           0 :       for ( ; i != e; ++i )
    5747             :         {
    5748           0 :           tmp = swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >( *i );
    5749           0 :           tmp = rb_obj_as_string( tmp );
    5750           0 :           str = rb_str_buf_append( str, tmp );
    5751             :         }
    5752           0 :       return str;
    5753             :     }
    5754           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg__slice(std::vector< kdb::tools::BackendInfo > *self,std::vector< kdb::tools::BackendInfo >::difference_type i,std::vector< kdb::tools::BackendInfo >::difference_type length){
    5755           0 :       if ( length < 0 )
    5756             :         return Qnil;
    5757           0 :       std::size_t len = self->size();
    5758           0 :       if ( i < 0 ) {
    5759           0 :         if ( i + static_cast<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::difference_type>(len) < 0 )
    5760             :           return Qnil;
    5761             :         else
    5762           0 :           i = len + i;
    5763             :       }
    5764           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::difference_type j = length + i;
    5765           0 :       if ( j > static_cast<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::difference_type>(len) )
    5766           0 :         j = len;
    5767             : 
    5768           0 :       VALUE r = Qnil;
    5769             :       try {
    5770           0 :         r = swig::from< const std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >* >( swig::getslice(self, i, j) );
    5771             :       }
    5772           0 :       catch( std::out_of_range ) {
    5773             :       }
    5774             :       return r;
    5775             :     }
    5776           0 : SWIGINTERN std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *std_vector_Sl_kdb_tools_BackendInfo_Sg__each(std::vector< kdb::tools::BackendInfo > *self){
    5777           0 :         if ( !rb_block_given_p() )
    5778           0 :           rb_raise( rb_eArgError, "no block given");
    5779             : 
    5780             :         VALUE r;
    5781           0 :         std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::const_iterator i = self->begin();
    5782           0 :         std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::const_iterator e = self->end();
    5783           0 :         for ( ; i != e; ++i )
    5784             :           {
    5785           0 :             r = swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >(*i);
    5786           0 :             rb_yield(r);
    5787             :           }
    5788             :         
    5789           0 :         return self;
    5790             :       }
    5791             : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg____delete2__(std::vector< kdb::tools::BackendInfo > *self,std::vector< kdb::tools::BackendInfo >::value_type const &i){
    5792           0 :       VALUE r = Qnil;
    5793             :       return r;
    5794             :     }
    5795           0 : SWIGINTERN std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *std_vector_Sl_kdb_tools_BackendInfo_Sg__select(std::vector< kdb::tools::BackendInfo > *self){
    5796           0 :       if ( !rb_block_given_p() )
    5797           0 :         rb_raise( rb_eArgError, "no block given" );
    5798             : 
    5799           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >* r = new std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >();
    5800           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::const_iterator i = self->begin();
    5801           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::const_iterator e = self->end();
    5802           0 :       for ( ; i != e; ++i )
    5803             :         {
    5804           0 :           VALUE v = swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >(*i);
    5805           0 :           if ( RTEST( rb_yield(v) ) )
    5806           0 :             self->insert( r->end(), *i);
    5807             :         }
    5808             :         
    5809           0 :       return r;
    5810             :     }
    5811           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg__delete_at(std::vector< kdb::tools::BackendInfo > *self,std::vector< kdb::tools::BackendInfo >::difference_type i){
    5812           0 :       VALUE r = Qnil;
    5813             :       try {
    5814           0 :         std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::iterator at = swig::getpos(self, i);
    5815           0 :         r = swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >( *(at) );
    5816           0 :         self->erase(at); 
    5817             :       }
    5818           0 :       catch (std::out_of_range)
    5819             :         {
    5820             :         }
    5821           0 :       return r;
    5822             :     }
    5823           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg__at(std::vector< kdb::tools::BackendInfo > const *self,std::vector< kdb::tools::BackendInfo >::difference_type i){
    5824           0 :       VALUE r = Qnil;
    5825             :       try {
    5826           0 :         r = swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >( *(swig::cgetpos(self, i)) );
    5827             :       }
    5828           0 :       catch( std::out_of_range ) {
    5829             :       }
    5830           0 :       return r;
    5831             :     }
    5832           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg____getitem____SWIG_0(std::vector< kdb::tools::BackendInfo > const *self,std::vector< kdb::tools::BackendInfo >::difference_type i,std::vector< kdb::tools::BackendInfo >::difference_type length){
    5833           0 :       if ( length < 0 )
    5834             :         return Qnil;
    5835           0 :       std::size_t len = self->size();
    5836           0 :       if ( i < 0 ) {
    5837           0 :         if ( i + static_cast<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::difference_type>(len) < 0 )
    5838             :           return Qnil;
    5839             :         else
    5840           0 :           i = len + i;
    5841             :       }
    5842           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::difference_type j = length + i;
    5843           0 :       if ( j > static_cast<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::difference_type>(len) )
    5844           0 :         j = len;
    5845             : 
    5846           0 :       VALUE r = Qnil;
    5847             :       try {
    5848           0 :         r = swig::from< const std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >* >( swig::getslice(self, i, j) );
    5849             :       }
    5850           0 :       catch( std::out_of_range ) {
    5851             :       }
    5852             :       return r;
    5853             :     }
    5854           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg____getitem____SWIG_1(std::vector< kdb::tools::BackendInfo > const *self,std::vector< kdb::tools::BackendInfo >::difference_type i){
    5855           0 :       VALUE r = Qnil;
    5856             :       try {
    5857           0 :         r = swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >( *(swig::cgetpos(self, i)) );
    5858             :       }
    5859           0 :       catch( std::out_of_range ) {
    5860             :       }
    5861           0 :       return r;
    5862             :     }
    5863           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg____getitem____SWIG_2(std::vector< kdb::tools::BackendInfo > const *self,VALUE i){
    5864           0 :       if ( rb_obj_is_kind_of( i, rb_cRange ) == Qfalse ) {
    5865           0 :         rb_raise( rb_eTypeError, "not a valid index or range" );
    5866             :       }
    5867             : 
    5868           0 :       static ID id_end   = rb_intern("end");
    5869           0 :       static ID id_start = rb_intern("begin");
    5870           0 :       static ID id_noend = rb_intern("exclude_end?");
    5871             : 
    5872           0 :       VALUE start = rb_funcall( i, id_start, 0 );
    5873           0 :       VALUE end   = rb_funcall( i, id_end, 0 );
    5874           0 :       bool  noend = ( rb_funcall( i, id_noend, 0 ) == Qtrue );
    5875             : 
    5876           0 :       int len = self->size();
    5877             : 
    5878           0 :       int s = NUM2INT( start );
    5879           0 :       if ( s < 0 ) {
    5880           0 :         s = len + s;
    5881           0 :         if ( s < 0 )
    5882             :           return Qnil;
    5883           0 :       } else if ( s > len )
    5884             :         return Qnil;
    5885             : 
    5886           0 :       int e = NUM2INT( end );
    5887           0 :       if ( e < 0 ) e = len + e;
    5888           0 :       if ( noend ) e -= 1;
    5889           0 :       if ( e < 0 ) e = -1;
    5890           0 :       if ( e >= len ) e = len - 1;
    5891           0 :       if ( s == len ) e = len - 1;
    5892             : 
    5893           0 :       return swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >* >( swig::getslice(self, s, e+1) );
    5894             :     }
    5895           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg____setitem____SWIG_0(std::vector< kdb::tools::BackendInfo > *self,std::vector< kdb::tools::BackendInfo >::difference_type i,std::vector< kdb::tools::BackendInfo >::value_type const &x){
    5896           0 :         if ( i >= static_cast<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::difference_type>( self->size()) )
    5897           0 :           swig::resize( self, i+1, x );
    5898             :         else
    5899           0 :           *(swig::getpos(self, i)) = x;
    5900             : 
    5901           0 :         return swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >( x );
    5902             :       }
    5903           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg____setitem____SWIG_1(std::vector< kdb::tools::BackendInfo > *self,std::vector< kdb::tools::BackendInfo >::difference_type i,std::vector< kdb::tools::BackendInfo >::difference_type length,std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > const &v){
    5904             : 
    5905           0 :       if ( length < 0 )
    5906             :         return Qnil;
    5907           0 :       std::size_t len = self->size();
    5908           0 :       if ( i < 0 ) {
    5909           0 :         if ( i + static_cast<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::difference_type>(len) < 0 )
    5910             :           return Qnil;
    5911             :         else
    5912           0 :           i = len + i;
    5913             :       }
    5914           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::difference_type j = length + i;
    5915           0 :       if ( j > static_cast<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::difference_type>(len) ) {
    5916           0 :         swig::resize( self, j, *(v.begin()) );
    5917             :       }
    5918             : 
    5919           0 :       VALUE r = Qnil;
    5920           0 :       swig::setslice(self, i, j, v);
    5921           0 :       r = swig::from< const std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >* >( &v );
    5922             :       return r;
    5923             :     }
    5924           0 : SWIGINTERN std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *std_vector_Sl_kdb_tools_BackendInfo_Sg__reject_bang(std::vector< kdb::tools::BackendInfo > *self){
    5925           0 :       if ( !rb_block_given_p() )
    5926           0 :         rb_raise( rb_eArgError, "no block given" );
    5927             : 
    5928           0 :       self->erase( std::remove_if( self->begin(), self->end(),
    5929           0 :             swig::yield< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >() ), self->end() );
    5930           0 :       return self;
    5931             :     }
    5932           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg__pop(std::vector< kdb::tools::BackendInfo > *self){
    5933           0 :       if (self->empty()) return Qnil;
    5934           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type x = self->back();
    5935           0 :       self->pop_back();
    5936           0 :       return swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >( x );
    5937             :     }
    5938             : SWIGINTERN std::vector< kdb::tools::BackendInfo >::value_type const std_vector_Sl_kdb_tools_BackendInfo_Sg__push(std::vector< kdb::tools::BackendInfo > *self,std::vector< kdb::tools::BackendInfo >::value_type const &e){
    5939           0 :       self->push_back( e );
    5940           0 :       return e;
    5941             :     }
    5942           0 : SWIGINTERN std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *std_vector_Sl_kdb_tools_BackendInfo_Sg__reject(std::vector< kdb::tools::BackendInfo > *self){
    5943           0 :       if ( !rb_block_given_p() )
    5944           0 :         rb_raise( rb_eArgError, "no block given" );
    5945             : 
    5946           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >* r = new std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >();
    5947             :       std::remove_copy_if( self->begin(), self->end(),              
    5948             :                            std::back_inserter(*r),
    5949           0 :                            swig::yield< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >() );
    5950           0 :       return r;
    5951             :     }
    5952           0 : SWIGINTERN VALUE std_vector_Sl_kdb_tools_BackendInfo_Sg__shift(std::vector< kdb::tools::BackendInfo > *self){
    5953           0 :       if (self->empty()) return Qnil;
    5954           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type x = self->front();
    5955           0 :       self->erase( self->begin() );
    5956           0 :       return swig::from< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type >( x );
    5957             :     }
    5958           0 : SWIGINTERN std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *std_vector_Sl_kdb_tools_BackendInfo_Sg__insert(std::vector< kdb::tools::BackendInfo > *self,std::vector< kdb::tools::BackendInfo >::difference_type pos,int argc,VALUE *argv,...){
    5959           0 :       std::size_t len = self->size();
    5960           0 :       std::size_t   i = swig::check_index( pos, len, true );
    5961           0 :       std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::iterator start;
    5962             : 
    5963           0 :       VALUE elem = argv[0];
    5964           0 :       int idx = 0;
    5965             :       try {
    5966           0 :         std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type val = swig::as<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type>( elem, true );
    5967           0 :         if ( i >= len ) {
    5968           0 :           self->resize(i-1, val);
    5969           0 :           return self;
    5970             :         }
    5971           0 :         start = self->begin();
    5972           0 :         std::advance( start, i );
    5973           0 :         self->insert( start++, val );
    5974             : 
    5975           0 :         for ( ++idx; idx < argc; ++idx )
    5976             :           {
    5977           0 :             elem = argv[idx];
    5978           0 :             val = swig::as<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type>( elem );
    5979           0 :             self->insert( start++, val );
    5980             :           }
    5981             : 
    5982             :       } 
    5983           0 :       catch( std::invalid_argument )
    5984             :         {
    5985           0 :           rb_raise( rb_eArgError, "%s",
    5986             :                     Ruby_Format_TypeError( "", 
    5987             :                                            swig::type_name<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type>(),
    5988           0 :                                            __FUNCTION__, idx+2, elem ));
    5989             :         }
    5990             : 
    5991             : 
    5992           0 :       return self;
    5993             :     }
    5994           0 : SWIGINTERN std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *std_vector_Sl_kdb_tools_BackendInfo_Sg__unshift(std::vector< kdb::tools::BackendInfo > *self,int argc,VALUE *argv,...){
    5995           0 :       for ( int idx = argc-1; idx >= 0; --idx )
    5996             :         {
    5997           0 :           std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::iterator start = self->begin();
    5998           0 :           VALUE elem = argv[idx];
    5999             :           try {
    6000           0 :             std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type val = swig::as<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type>( elem, true );
    6001           0 :             self->insert( start, val );
    6002             :           }
    6003           0 :           catch( std::invalid_argument )
    6004             :             {
    6005           0 :               rb_raise( rb_eArgError, "%s",
    6006             :                         Ruby_Format_TypeError( "", 
    6007             :                                                swig::type_name<std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > >::value_type>(),
    6008           0 :                                                __FUNCTION__, idx+2, elem ));
    6009             :             }
    6010             :         }
    6011             : 
    6012           0 :       return self;
    6013             :     }
    6014             : SWIGINTERN kdb::tools::PluginSpecVector kdb_tools_BackendBuilder_to_add(kdb::tools::BackendBuilder *self){
    6015           0 :        return PluginSpecVector(self->begin(), self->end());
    6016             :     }
    6017             : 
    6018             :   namespace swig {
    6019             :     template <>  struct traits< kdb::Key > {
    6020             :       typedef pointer_category category;
    6021             :       static const char* type_name() { return"kdb::Key"; }
    6022             :     };
    6023             :   }
    6024             : 
    6025             : 
    6026             :   namespace swig {
    6027             :     template <>  struct traits< kdb::tools::SpecBackendBuilder > {
    6028             :       typedef pointer_category category;
    6029             :       static const char* type_name() { return"kdb::tools::SpecBackendBuilder"; }
    6030             :     };
    6031             :   }
    6032             : 
    6033             : 
    6034             :       namespace swig {
    6035             :         template <>  struct traits<std::pair< kdb::Key, kdb::tools::SpecBackendBuilder > > {
    6036             :           typedef pointer_category category;
    6037             :           static const char* type_name() {
    6038             :             return "std::pair<" "kdb::Key" "," "kdb::tools::SpecBackendBuilder" " >";
    6039             :           }
    6040             :         };
    6041             :       }
    6042             :     
    6043             : 
    6044             :       namespace swig {
    6045             :         template <>  struct traits<std::map< kdb::Key, kdb::tools::SpecBackendBuilder, std::less< kdb::Key >, std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > > {
    6046             :           typedef pointer_category category;
    6047             :           static const char* type_name() {
    6048             :             return "std::map<" "kdb::Key" "," "kdb::tools::SpecBackendBuilder" "," "std::less< kdb::Key >" "," "std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > >" " >";
    6049             :           }
    6050             :         };
    6051             :       }
    6052             :     
    6053           0 : SWIGINTERN std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__dup(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self){
    6054           0 :       return new std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >(*self);
    6055             :     }
    6056           0 : SWIGINTERN VALUE std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg____delete__(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self,std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &key){
    6057           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::iterator i = self->find(key);
    6058           0 :       if (i != self->end()) {
    6059           0 :         self->erase(i);
    6060             :         return swig::from( key );
    6061             :       }
    6062             :       else {
    6063             :         return Qnil;
    6064             :       }
    6065             :     }
    6066             : SWIGINTERN bool std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__has_key(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *self,std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &key){
    6067           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator i = self->find(key);
    6068           0 :       return i != self->end();
    6069             :     }
    6070           0 : SWIGINTERN VALUE std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__keys(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self){
    6071           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::size_type size = self->size();
    6072           0 :       int rubysize = (size <= (std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::size_type) INT_MAX) ? (int) size : -1;
    6073           0 :       if (rubysize < 0) {
    6074             :         SWIG_RUBY_THREAD_BEGIN_BLOCK;
    6075           0 :         rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
    6076             :         SWIG_RUBY_THREAD_END_BLOCK;
    6077             :         return Qnil;
    6078             :       }
    6079           0 :       VALUE ary = rb_ary_new2(rubysize);
    6080           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator i = self->begin();
    6081           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator e = self->end();
    6082           0 :       for ( ; i != e; ++i ) {
    6083           0 :         rb_ary_push( ary, swig::from(i->first) );
    6084             :       }
    6085             :       return ary;
    6086             :     }
    6087           0 : SWIGINTERN std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__each(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self){
    6088           0 :         if ( !rb_block_given_p() )
    6089           0 :           rb_raise( rb_eArgError, "no block given");
    6090             : 
    6091             :         VALUE k, v;
    6092           0 :         std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::iterator i = self->begin();
    6093           0 :         std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::iterator e = self->end();
    6094           0 :         for ( ; i != e; ++i )
    6095             :           {
    6096           0 :             const std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::key_type&    key = i->first;
    6097           0 :             const std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::mapped_type& val = i->second;
    6098             : 
    6099           0 :             k = swig::from<std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::key_type>(key);
    6100           0 :             v = swig::from<std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::mapped_type>(val);
    6101           0 :             rb_yield_values(2, k, v);
    6102             :           }
    6103             :         
    6104           0 :         return self;
    6105             :       }
    6106           0 : SWIGINTERN std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__select(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self){
    6107           0 :       if ( !rb_block_given_p() )
    6108           0 :         rb_raise( rb_eArgError, "no block given" );
    6109             : 
    6110           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >* r = new std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >;
    6111           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::iterator i = self->begin();
    6112           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::iterator e = self->end();
    6113           0 :       for ( ; i != e; ++i )
    6114             :         {
    6115           0 :           VALUE k = swig::from<std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::key_type>(i->first);
    6116           0 :           VALUE v = swig::from<std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::mapped_type>(i->second);
    6117           0 :           if ( RTEST( rb_yield_values(2, k, v) ) )
    6118           0 :             self->insert(r->end(), *i);
    6119             :         }
    6120             :         
    6121           0 :       return r;
    6122             :     }
    6123           0 : SWIGINTERN VALUE std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__values_at(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self,int argc,VALUE *argv,...){
    6124             :     
    6125           0 :     VALUE r = rb_ary_new();
    6126           0 :     ID   id = rb_intern("[]");
    6127           0 :     swig_type_info* type = swig::type_info< std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > >();
    6128           0 :     VALUE me = SWIG_NewPointerObj( self, type, 0 );
    6129           0 :     for ( int i = 0; i < argc; ++i )
    6130             :       {
    6131           0 :         VALUE key = argv[i];
    6132           0 :         VALUE tmp = rb_funcall( me, id, 1, key );
    6133           0 :         rb_ary_push( r, tmp );
    6134             :       }
    6135             :     
    6136           0 :     return r;
    6137             :   }
    6138           0 : SWIGINTERN std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__each_key(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self){
    6139           0 :         if ( !rb_block_given_p() )
    6140           0 :           rb_raise( rb_eArgError, "no block given");
    6141             : 
    6142             :         VALUE r;
    6143           0 :         std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::iterator i = self->begin();
    6144           0 :         std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::iterator e = self->end();
    6145           0 :         for ( ; i != e; ++i )
    6146             :           {
    6147           0 :             r = swig::from( i->first );
    6148           0 :             rb_yield(r);
    6149             :           }
    6150             :         
    6151           0 :         return self;
    6152             :       }
    6153           0 : SWIGINTERN VALUE std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__values(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self){
    6154           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::size_type size = self->size();
    6155           0 :       int rubysize = (size <= (std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::size_type) INT_MAX) ? (int) size : -1;
    6156           0 :       if (rubysize < 0) {
    6157             :         SWIG_RUBY_THREAD_BEGIN_BLOCK;
    6158           0 :         rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
    6159             :         SWIG_RUBY_THREAD_END_BLOCK;
    6160             :         return Qnil;
    6161             :       }
    6162           0 :       VALUE ary = rb_ary_new2(rubysize);
    6163           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator i = self->begin();
    6164           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator e = self->end();
    6165           0 :       for ( ; i != e; ++i ) {
    6166           0 :         rb_ary_push( ary, swig::from(i->second) );
    6167             :       }
    6168             :       return ary;
    6169             :     }
    6170           0 : SWIGINTERN std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__each_value(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self){
    6171           0 :         if ( !rb_block_given_p() )
    6172           0 :           rb_raise( rb_eArgError, "no block given");
    6173             : 
    6174             :         VALUE r;
    6175           0 :         std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::iterator i = self->begin();
    6176           0 :         std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::iterator e = self->end();
    6177           0 :         for ( ; i != e; ++i )
    6178             :           {
    6179           0 :             r = swig::from( i->second );
    6180           0 :             rb_yield(r);
    6181             :           }
    6182             :         
    6183           0 :         return self;
    6184             :       }
    6185           0 : SWIGINTERN VALUE std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__entries(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self){
    6186           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::size_type size = self->size();
    6187           0 :       int rubysize = (size <= (std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::size_type) INT_MAX) ? (int) size : -1;
    6188           0 :       if (rubysize < 0) {
    6189             :         SWIG_RUBY_THREAD_BEGIN_BLOCK;
    6190           0 :         rb_raise(rb_eRuntimeError, "map size not valid in Ruby");
    6191             :         SWIG_RUBY_THREAD_END_BLOCK;
    6192             :         return Qnil;
    6193             :       }
    6194           0 :       VALUE ary = rb_ary_new2(rubysize);
    6195           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator i = self->begin();
    6196           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator e = self->end();
    6197           0 :       for ( ; i != e; ++i ) {
    6198           0 :         rb_ary_push( ary, swig::from<std::pair<std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::key_type, 
    6199           0 :                      std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::mapped_type> >(*i) );
    6200             :       }
    6201             :       return ary;
    6202             :     }
    6203             : SWIGINTERN bool std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg____contains__(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self,std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &key){
    6204           0 :       return self->find(key) != self->end();
    6205             :     }
    6206             : SWIGINTERN swig::ConstIterator *std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__key_iterator(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self,VALUE *RUBY_SELF){
    6207           0 :       return swig::make_output_key_iterator(self->begin(), self->begin(), 
    6208           0 :                                             self->end(), *RUBY_SELF);
    6209             :     }
    6210             : SWIGINTERN swig::ConstIterator *std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__value_iterator(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self,VALUE *RUBY_SELF){
    6211           0 :       return swig::make_output_value_iterator(self->begin(), self->begin(), 
    6212           0 :                                               self->end(), *RUBY_SELF);
    6213             :     }
    6214           1 : SWIGINTERN VALUE std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg____getitem__(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *self,std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &key){
    6215           1 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator i = self->find(key);
    6216           1 :       if ( i != self->end() )
    6217           1 :         return swig::from<std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::mapped_type>( i->second );
    6218             :       else
    6219             :         return Qnil;
    6220             :     }
    6221           0 : SWIGINTERN void std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg____setitem__(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self,std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &key,std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::mapped_type const &x){
    6222           0 :       (*self)[key] = x;
    6223           0 :     }
    6224           0 : SWIGINTERN VALUE std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__inspect(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self){
    6225           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator i = self->begin();
    6226           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator e = self->end();
    6227           0 :       const char *type_name = swig::type_name< std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > >();
    6228           0 :       VALUE str = rb_str_new2( type_name );
    6229           0 :       str = rb_str_cat2( str, " {" );
    6230             :       bool comma = false;
    6231             :       VALUE tmp;
    6232           0 :       for ( ; i != e; ++i, comma = true )
    6233             :         {
    6234           0 :           if (comma) str = rb_str_cat2( str, "," );
    6235           0 :           tmp = swig::from< std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::key_type >( i->first );
    6236           0 :           tmp = rb_inspect( tmp );
    6237           0 :           str = rb_str_buf_append( str, tmp );
    6238           0 :           str = rb_str_cat2( str, "=>" );
    6239           0 :           tmp = swig::from< std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::mapped_type >( i->second );
    6240           0 :           tmp = rb_inspect( tmp );
    6241           0 :           str = rb_str_buf_append( str, tmp );
    6242             :         }
    6243           0 :       str = rb_str_cat2( str, "}" );
    6244           0 :       return str;
    6245             :     }
    6246           0 : SWIGINTERN VALUE std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__to_a(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self){
    6247           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator i = self->begin();
    6248           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::const_iterator e = self->end();
    6249           0 :       VALUE ary = rb_ary_new2( std::distance( i, e ) );
    6250             :       VALUE tmp;
    6251           0 :       for ( ; i != e; ++i )
    6252             :         {
    6253             :           // @todo: improve -- this should just be swig::from(*i)
    6254             :           tmp = swig::from< std::pair<std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::key_type, 
    6255           0 :             std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::mapped_type> >( *i );
    6256           0 :           rb_ary_push( ary, tmp );
    6257             :         }
    6258           0 :       return ary;
    6259             :     }
    6260           0 : SWIGINTERN VALUE std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__to_s(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *self){
    6261           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::iterator i = self->begin();
    6262           0 :       std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::iterator e = self->end();
    6263           0 :       VALUE str = rb_str_new2( "" );
    6264             :       VALUE tmp;
    6265           0 :       for ( ; i != e; ++i )
    6266             :         {
    6267             :           // @todo: improve -- this should just be swig::from(*i)
    6268             :           tmp = swig::from< std::pair<std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::key_type, 
    6269           0 :             std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > >::mapped_type> >( *i );
    6270           0 :           tmp = rb_obj_as_string( tmp );
    6271           0 :           str = rb_str_buf_append( str, tmp );
    6272             :         }
    6273           0 :       return str;
    6274             :     }
    6275             : 
    6276             : /*
    6277             :   Document-class: Kdbtools::GCVALUE
    6278             : 
    6279             :   Proxy of C++ Kdbtools::GCVALUE class
    6280             : 
    6281             : 
    6282             : */
    6283             : static swig_class SwigClassGCVALUE;
    6284             : 
    6285             : 
    6286             : /*
    6287             :   Document-method: Kdbtools::GCVALUE.inspect
    6288             : 
    6289             :   call-seq:
    6290             :     inspect -> VALUE
    6291             : 
    6292             : Inspect class and its contents.
    6293             : */
    6294             : SWIGINTERN VALUE
    6295           0 : _wrap_GCVALUE_inspect(int argc, VALUE *argv, VALUE self) {
    6296           0 :   swig::GC_VALUE *arg1 = (swig::GC_VALUE *) 0 ;
    6297           0 :   swig::GC_VALUE r1 ;
    6298             :   VALUE result;
    6299           0 :   VALUE vresult = Qnil;
    6300             :   
    6301           0 :   if ((argc < 0) || (argc > 0)) {
    6302           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    6303             :   }
    6304           0 :   r1 = self; arg1 = &r1;
    6305           0 :   result = (VALUE)((swig::GC_VALUE const *)arg1)->inspect();
    6306           0 :   vresult = result;
    6307           0 :   return vresult;
    6308             : fail:
    6309             :   return Qnil;
    6310             : }
    6311             : 
    6312             : 
    6313             : 
    6314             : /*
    6315             :   Document-method: Kdbtools::GCVALUE.to_s
    6316             : 
    6317             :   call-seq:
    6318             :     to_s -> VALUE
    6319             : 
    6320             : Convert class to a String representation.
    6321             : */
    6322             : SWIGINTERN VALUE
    6323           0 : _wrap_GCVALUE_to_s(int argc, VALUE *argv, VALUE self) {
    6324           0 :   swig::GC_VALUE *arg1 = (swig::GC_VALUE *) 0 ;
    6325           0 :   swig::GC_VALUE r1 ;
    6326             :   VALUE result;
    6327           0 :   VALUE vresult = Qnil;
    6328             :   
    6329           0 :   if ((argc < 0) || (argc > 0)) {
    6330           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    6331             :   }
    6332           0 :   r1 = self; arg1 = &r1;
    6333           0 :   result = (VALUE)((swig::GC_VALUE const *)arg1)->to_s();
    6334           0 :   vresult = result;
    6335           0 :   return vresult;
    6336             : fail:
    6337             :   return Qnil;
    6338             : }
    6339             : 
    6340             : 
    6341             : 
    6342             : /*
    6343             :   Document-class: Kdbtools::ConstIterator
    6344             : 
    6345             :   Proxy of C++ Kdbtools::ConstIterator class
    6346             : 
    6347             : 
    6348             : */
    6349             : static swig_class SwigClassConstIterator;
    6350             : 
    6351             : SWIGINTERN void
    6352           0 : free_swig_ConstIterator(void *self) {
    6353           0 :     swig::ConstIterator *arg1 = (swig::ConstIterator *)self;
    6354           0 :     delete arg1;
    6355           0 : }
    6356             : 
    6357             : 
    6358             : /*
    6359             :   Document-method: Kdbtools::ConstIterator.value
    6360             : 
    6361             :   call-seq:
    6362             :     value -> VALUE
    6363             : 
    6364             : An instance method.
    6365             : 
    6366             : */
    6367             : SWIGINTERN VALUE
    6368           0 : _wrap_ConstIterator_value(int argc, VALUE *argv, VALUE self) {
    6369           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6370           0 :   void *argp1 = 0 ;
    6371           0 :   int res1 = 0 ;
    6372             :   VALUE result;
    6373           0 :   VALUE vresult = Qnil;
    6374             :   
    6375           0 :   if ((argc < 0) || (argc > 0)) {
    6376           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    6377             :   }
    6378           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6379           0 :   if (!SWIG_IsOK(res1)) {
    6380           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","value", 1, self )); 
    6381             :   }
    6382           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6383             :   try {
    6384           0 :     result = (VALUE)((swig::ConstIterator const *)arg1)->value();
    6385             :   }
    6386           0 :   catch(swig::stop_iteration &_e) {
    6387             :     {
    6388             :       (void)_e;
    6389           0 :       SWIG_Ruby_ExceptionType(NULL, Qnil);
    6390             :       SWIG_fail;
    6391             :     }
    6392             :   }
    6393             :   
    6394             :   vresult = result;
    6395             :   return vresult;
    6396             : fail:
    6397           0 :   return Qnil;
    6398             : }
    6399             : 
    6400             : 
    6401             : 
    6402             : /*
    6403             :   Document-method: Kdbtools::ConstIterator.dup
    6404             : 
    6405             :   call-seq:
    6406             :     dup -> ConstIterator
    6407             : 
    6408             : Create a duplicate of the class and unfreeze it if needed.
    6409             : */
    6410             : SWIGINTERN VALUE
    6411           0 : _wrap_ConstIterator_dup(int argc, VALUE *argv, VALUE self) {
    6412           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6413           0 :   void *argp1 = 0 ;
    6414           0 :   int res1 = 0 ;
    6415           0 :   swig::ConstIterator *result = 0 ;
    6416           0 :   VALUE vresult = Qnil;
    6417             :   
    6418           0 :   if ((argc < 0) || (argc > 0)) {
    6419           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    6420             :   }
    6421           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6422           0 :   if (!SWIG_IsOK(res1)) {
    6423           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","dup", 1, self )); 
    6424             :   }
    6425           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6426           0 :   result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->dup();
    6427           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
    6428             :   return vresult;
    6429             : fail:
    6430             :   return Qnil;
    6431             : }
    6432             : 
    6433             : 
    6434             : 
    6435             : /*
    6436             :   Document-method: Kdbtools::ConstIterator.inspect
    6437             : 
    6438             :   call-seq:
    6439             :     inspect -> VALUE
    6440             : 
    6441             : Inspect class and its contents.
    6442             : */
    6443             : SWIGINTERN VALUE
    6444           0 : _wrap_ConstIterator_inspect(int argc, VALUE *argv, VALUE self) {
    6445           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6446           0 :   void *argp1 = 0 ;
    6447           0 :   int res1 = 0 ;
    6448             :   VALUE result;
    6449           0 :   VALUE vresult = Qnil;
    6450             :   
    6451           0 :   if ((argc < 0) || (argc > 0)) {
    6452           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    6453             :   }
    6454           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6455           0 :   if (!SWIG_IsOK(res1)) {
    6456           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","inspect", 1, self )); 
    6457             :   }
    6458           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6459           0 :   result = (VALUE)((swig::ConstIterator const *)arg1)->inspect();
    6460           0 :   vresult = result;
    6461             :   return vresult;
    6462             : fail:
    6463             :   return Qnil;
    6464             : }
    6465             : 
    6466             : 
    6467             : 
    6468             : /*
    6469             :   Document-method: Kdbtools::ConstIterator.to_s
    6470             : 
    6471             :   call-seq:
    6472             :     to_s -> VALUE
    6473             : 
    6474             : Convert class to a String representation.
    6475             : */
    6476             : SWIGINTERN VALUE
    6477           0 : _wrap_ConstIterator_to_s(int argc, VALUE *argv, VALUE self) {
    6478           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6479           0 :   void *argp1 = 0 ;
    6480           0 :   int res1 = 0 ;
    6481             :   VALUE result;
    6482           0 :   VALUE vresult = Qnil;
    6483             :   
    6484           0 :   if ((argc < 0) || (argc > 0)) {
    6485           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    6486             :   }
    6487           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6488           0 :   if (!SWIG_IsOK(res1)) {
    6489           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","to_s", 1, self )); 
    6490             :   }
    6491           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6492           0 :   result = (VALUE)((swig::ConstIterator const *)arg1)->to_s();
    6493           0 :   vresult = result;
    6494             :   return vresult;
    6495             : fail:
    6496             :   return Qnil;
    6497             : }
    6498             : 
    6499             : 
    6500             : 
    6501             : /*
    6502             :   Document-method: Kdbtools::ConstIterator.next
    6503             : 
    6504             :   call-seq:
    6505             :     next(size_t n=1) -> ConstIterator
    6506             :     next -> ConstIterator
    6507             : 
    6508             : An instance method.
    6509             : 
    6510             : */
    6511             : SWIGINTERN VALUE
    6512           0 : _wrap_ConstIterator_next__SWIG_0(int argc, VALUE *argv, VALUE self) {
    6513           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6514             :   size_t arg2 ;
    6515           0 :   void *argp1 = 0 ;
    6516           0 :   int res1 = 0 ;
    6517             :   size_t val2 ;
    6518           0 :   int ecode2 = 0 ;
    6519           0 :   swig::ConstIterator *result = 0 ;
    6520           0 :   VALUE vresult = Qnil;
    6521             :   
    6522           0 :   if ((argc < 1) || (argc > 1)) {
    6523           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    6524             :   }
    6525           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6526           0 :   if (!SWIG_IsOK(res1)) {
    6527           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","next", 1, self )); 
    6528             :   }
    6529           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6530           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
    6531           0 :   if (!SWIG_IsOK(ecode2)) {
    6532           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","next", 2, argv[0] ));
    6533             :   } 
    6534           0 :   arg2 = static_cast< size_t >(val2);
    6535           0 :   result = (swig::ConstIterator *)(arg1)->next(arg2);
    6536           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6537             :   return vresult;
    6538             : fail:
    6539             :   return Qnil;
    6540             : }
    6541             : 
    6542             : 
    6543             : SWIGINTERN VALUE
    6544           0 : _wrap_ConstIterator_next__SWIG_1(int argc, VALUE *argv, VALUE self) {
    6545           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6546           0 :   void *argp1 = 0 ;
    6547           0 :   int res1 = 0 ;
    6548           0 :   swig::ConstIterator *result = 0 ;
    6549           0 :   VALUE vresult = Qnil;
    6550             :   
    6551           0 :   if ((argc < 0) || (argc > 0)) {
    6552           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    6553             :   }
    6554           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6555           0 :   if (!SWIG_IsOK(res1)) {
    6556           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","next", 1, self )); 
    6557             :   }
    6558           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6559             :   try {
    6560           0 :     result = (swig::ConstIterator *)(arg1)->next();
    6561             :   }
    6562           0 :   catch(swig::stop_iteration &_e) {
    6563             :     {
    6564             :       (void)_e;
    6565           0 :       SWIG_Ruby_ExceptionType(NULL, Qnil);
    6566             :       SWIG_fail;
    6567             :     }
    6568             :   }
    6569             :   
    6570           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6571             :   return vresult;
    6572             : fail:
    6573             :   return Qnil;
    6574             : }
    6575             : 
    6576             : 
    6577           0 : SWIGINTERN VALUE _wrap_ConstIterator_next(int nargs, VALUE *args, VALUE self) {
    6578             :   int argc;
    6579             :   VALUE argv[3];
    6580             :   int ii;
    6581             :   
    6582           0 :   argc = nargs + 1;
    6583             :   argv[0] = self;
    6584           0 :   if (argc > 3) SWIG_fail;
    6585             :   for (ii = 1; (ii < argc); ++ii) {
    6586             :     argv[ii] = args[ii-1];
    6587             :   }
    6588           0 :   if (argc == 1) {
    6589           0 :     return _wrap_ConstIterator_next__SWIG_1(nargs, args, self);
    6590             :   }
    6591           0 :   if (argc == 2) {
    6592           0 :     return _wrap_ConstIterator_next__SWIG_0(nargs, args, self);
    6593             :   }
    6594             :   
    6595             : fail:
    6596             :   Ruby_Format_OverloadedError( argc, 3, "ConstIterator.next", 
    6597             :     "    swig::ConstIterator ConstIterator.next(size_t n)\n"
    6598           0 :     "    swig::ConstIterator * ConstIterator.next()\n");
    6599             :   
    6600             :   return Qnil;
    6601             : }
    6602             : 
    6603             : 
    6604             : 
    6605             : /*
    6606             :   Document-method: Kdbtools::ConstIterator.previous
    6607             : 
    6608             :   call-seq:
    6609             :     previous(size_t n=1) -> ConstIterator
    6610             :     previous -> ConstIterator
    6611             : 
    6612             : An instance method.
    6613             : 
    6614             : */
    6615             : SWIGINTERN VALUE
    6616           0 : _wrap_ConstIterator_previous__SWIG_0(int argc, VALUE *argv, VALUE self) {
    6617           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6618             :   size_t arg2 ;
    6619           0 :   void *argp1 = 0 ;
    6620           0 :   int res1 = 0 ;
    6621             :   size_t val2 ;
    6622           0 :   int ecode2 = 0 ;
    6623           0 :   swig::ConstIterator *result = 0 ;
    6624           0 :   VALUE vresult = Qnil;
    6625             :   
    6626           0 :   if ((argc < 1) || (argc > 1)) {
    6627           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    6628             :   }
    6629           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6630           0 :   if (!SWIG_IsOK(res1)) {
    6631           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","previous", 1, self )); 
    6632             :   }
    6633           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6634           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
    6635           0 :   if (!SWIG_IsOK(ecode2)) {
    6636           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","previous", 2, argv[0] ));
    6637             :   } 
    6638           0 :   arg2 = static_cast< size_t >(val2);
    6639           0 :   result = (swig::ConstIterator *)(arg1)->previous(arg2);
    6640           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6641             :   return vresult;
    6642             : fail:
    6643             :   return Qnil;
    6644             : }
    6645             : 
    6646             : 
    6647             : SWIGINTERN VALUE
    6648           0 : _wrap_ConstIterator_previous__SWIG_1(int argc, VALUE *argv, VALUE self) {
    6649           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6650           0 :   void *argp1 = 0 ;
    6651           0 :   int res1 = 0 ;
    6652           0 :   swig::ConstIterator *result = 0 ;
    6653           0 :   VALUE vresult = Qnil;
    6654             :   
    6655           0 :   if ((argc < 0) || (argc > 0)) {
    6656           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    6657             :   }
    6658           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6659           0 :   if (!SWIG_IsOK(res1)) {
    6660           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","previous", 1, self )); 
    6661             :   }
    6662           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6663             :   try {
    6664           0 :     result = (swig::ConstIterator *)(arg1)->previous();
    6665             :   }
    6666           0 :   catch(swig::stop_iteration &_e) {
    6667             :     {
    6668             :       (void)_e;
    6669           0 :       SWIG_Ruby_ExceptionType(NULL, Qnil);
    6670             :       SWIG_fail;
    6671             :     }
    6672             :   }
    6673             :   
    6674           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6675             :   return vresult;
    6676             : fail:
    6677             :   return Qnil;
    6678             : }
    6679             : 
    6680             : 
    6681           0 : SWIGINTERN VALUE _wrap_ConstIterator_previous(int nargs, VALUE *args, VALUE self) {
    6682             :   int argc;
    6683             :   VALUE argv[3];
    6684             :   int ii;
    6685             :   
    6686           0 :   argc = nargs + 1;
    6687             :   argv[0] = self;
    6688           0 :   if (argc > 3) SWIG_fail;
    6689             :   for (ii = 1; (ii < argc); ++ii) {
    6690             :     argv[ii] = args[ii-1];
    6691             :   }
    6692           0 :   if (argc == 1) {
    6693           0 :     return _wrap_ConstIterator_previous__SWIG_1(nargs, args, self);
    6694             :   }
    6695           0 :   if (argc == 2) {
    6696           0 :     return _wrap_ConstIterator_previous__SWIG_0(nargs, args, self);
    6697             :   }
    6698             :   
    6699             : fail:
    6700             :   Ruby_Format_OverloadedError( argc, 3, "ConstIterator.previous", 
    6701             :     "    swig::ConstIterator ConstIterator.previous(size_t n)\n"
    6702           0 :     "    swig::ConstIterator * ConstIterator.previous()\n");
    6703             :   
    6704             :   return Qnil;
    6705             : }
    6706             : 
    6707             : 
    6708             : 
    6709             : /*
    6710             :   Document-method: Kdbtools::ConstIterator.==
    6711             : 
    6712             :   call-seq:
    6713             :     ==(x) -> bool
    6714             : 
    6715             : Equality comparison operator.
    6716             : */
    6717             : SWIGINTERN VALUE
    6718           0 : _wrap_ConstIterator___eq__(int argc, VALUE *argv, VALUE self) {
    6719           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6720           0 :   swig::ConstIterator *arg2 = 0 ;
    6721           0 :   void *argp1 = 0 ;
    6722           0 :   int res1 = 0 ;
    6723             :   void *argp2 ;
    6724           0 :   int res2 = 0 ;
    6725             :   bool result;
    6726           0 :   VALUE vresult = Qnil;
    6727             :   
    6728           0 :   if ((argc < 1) || (argc > 1)) {
    6729           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    6730             :   }
    6731           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6732           0 :   if (!SWIG_IsOK(res1)) {
    6733           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator ==", 1, self )); 
    6734             :   }
    6735           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6736           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__ConstIterator,  0 );
    6737           0 :   if (!SWIG_IsOK(res2)) {
    6738           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::ConstIterator const &","operator ==", 2, argv[0] )); 
    6739             :   }
    6740           0 :   if (!argp2) {
    6741           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::ConstIterator const &","operator ==", 2, argv[0])); 
    6742             :   }
    6743           0 :   arg2 = reinterpret_cast< swig::ConstIterator * >(argp2);
    6744           0 :   result = (bool)((swig::ConstIterator const *)arg1)->operator ==((swig::ConstIterator const &)*arg2);
    6745           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
    6746             :   return vresult;
    6747             : fail:
    6748             :   return Qnil;
    6749             : }
    6750             : 
    6751             : 
    6752             : 
    6753             : /*
    6754             :   Document-method: Kdbtools::ConstIterator.+
    6755             : 
    6756             :   call-seq:
    6757             :     +(n) -> ConstIterator
    6758             : 
    6759             : Add operator.
    6760             : */
    6761             : SWIGINTERN VALUE
    6762           0 : _wrap_ConstIterator___add__(int argc, VALUE *argv, VALUE self) {
    6763           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6764             :   ptrdiff_t arg2 ;
    6765           0 :   void *argp1 = 0 ;
    6766           0 :   int res1 = 0 ;
    6767             :   ptrdiff_t val2 ;
    6768           0 :   int ecode2 = 0 ;
    6769           0 :   swig::ConstIterator *result = 0 ;
    6770           0 :   VALUE vresult = Qnil;
    6771             :   
    6772           0 :   if ((argc < 1) || (argc > 1)) {
    6773           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    6774             :   }
    6775           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6776           0 :   if (!SWIG_IsOK(res1)) {
    6777           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator +", 1, self )); 
    6778             :   }
    6779           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6780           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    6781           0 :   if (!SWIG_IsOK(ecode2)) {
    6782           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator +", 2, argv[0] ));
    6783             :   } 
    6784           0 :   arg2 = static_cast< ptrdiff_t >(val2);
    6785             :   try {
    6786           0 :     result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->operator +(arg2);
    6787             :   }
    6788           0 :   catch(swig::stop_iteration &_e) {
    6789             :     {
    6790             :       (void)_e;
    6791           0 :       SWIG_Ruby_ExceptionType(NULL, Qnil);
    6792             :       SWIG_fail;
    6793             :     }
    6794             :   }
    6795             :   
    6796           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
    6797             :   return vresult;
    6798             : fail:
    6799           0 :   return Qnil;
    6800             : }
    6801             : 
    6802             : 
    6803             : 
    6804             : /*
    6805             :   Document-method: Kdbtools::ConstIterator.-
    6806             : 
    6807             :   call-seq:
    6808             :     -(n) -> ConstIterator
    6809             :     -(x) -> ptrdiff_t
    6810             : 
    6811             : Substraction operator.
    6812             : */
    6813             : SWIGINTERN VALUE
    6814           0 : _wrap_ConstIterator___sub____SWIG_0(int argc, VALUE *argv, VALUE self) {
    6815           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6816             :   ptrdiff_t arg2 ;
    6817           0 :   void *argp1 = 0 ;
    6818           0 :   int res1 = 0 ;
    6819             :   ptrdiff_t val2 ;
    6820           0 :   int ecode2 = 0 ;
    6821           0 :   swig::ConstIterator *result = 0 ;
    6822           0 :   VALUE vresult = Qnil;
    6823             :   
    6824           0 :   if ((argc < 1) || (argc > 1)) {
    6825           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    6826             :   }
    6827           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6828           0 :   if (!SWIG_IsOK(res1)) {
    6829           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator -", 1, self )); 
    6830             :   }
    6831           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6832           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    6833           0 :   if (!SWIG_IsOK(ecode2)) {
    6834           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator -", 2, argv[0] ));
    6835             :   } 
    6836           0 :   arg2 = static_cast< ptrdiff_t >(val2);
    6837             :   try {
    6838           0 :     result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->operator -(arg2);
    6839             :   }
    6840           0 :   catch(swig::stop_iteration &_e) {
    6841             :     {
    6842             :       (void)_e;
    6843           0 :       SWIG_Ruby_ExceptionType(NULL, Qnil);
    6844             :       SWIG_fail;
    6845             :     }
    6846             :   }
    6847             :   
    6848           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
    6849             :   return vresult;
    6850             : fail:
    6851           0 :   return Qnil;
    6852             : }
    6853             : 
    6854             : 
    6855             : SWIGINTERN VALUE
    6856           0 : _wrap_ConstIterator___sub____SWIG_1(int argc, VALUE *argv, VALUE self) {
    6857           0 :   swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
    6858           0 :   swig::ConstIterator *arg2 = 0 ;
    6859           0 :   void *argp1 = 0 ;
    6860           0 :   int res1 = 0 ;
    6861             :   void *argp2 ;
    6862           0 :   int res2 = 0 ;
    6863             :   ptrdiff_t result;
    6864           0 :   VALUE vresult = Qnil;
    6865             :   
    6866           0 :   if ((argc < 1) || (argc > 1)) {
    6867           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    6868             :   }
    6869           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
    6870           0 :   if (!SWIG_IsOK(res1)) {
    6871           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator -", 1, self )); 
    6872             :   }
    6873           0 :   arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
    6874           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__ConstIterator,  0 );
    6875           0 :   if (!SWIG_IsOK(res2)) {
    6876           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::ConstIterator const &","operator -", 2, argv[0] )); 
    6877             :   }
    6878           0 :   if (!argp2) {
    6879           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::ConstIterator const &","operator -", 2, argv[0])); 
    6880             :   }
    6881           0 :   arg2 = reinterpret_cast< swig::ConstIterator * >(argp2);
    6882           0 :   result = ((swig::ConstIterator const *)arg1)->operator -((swig::ConstIterator const &)*arg2);
    6883           0 :   vresult = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
    6884             :   return vresult;
    6885             : fail:
    6886             :   return Qnil;
    6887             : }
    6888             : 
    6889             : 
    6890           0 : SWIGINTERN VALUE _wrap_ConstIterator___sub__(int nargs, VALUE *args, VALUE self) {
    6891             :   int argc;
    6892             :   VALUE argv[3];
    6893             :   int ii;
    6894             :   
    6895           0 :   argc = nargs + 1;
    6896             :   argv[0] = self;
    6897           0 :   if (argc > 3) SWIG_fail;
    6898           0 :   for (ii = 1; (ii < argc); ++ii) {
    6899           0 :     argv[ii] = args[ii-1];
    6900             :   }
    6901           0 :   if (argc == 2) {
    6902           0 :     int _v = 0;
    6903             :     {
    6904           0 :       void *vptr = 0;
    6905           0 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
    6906           0 :       _v = SWIG_CheckState(res);
    6907             :     }
    6908           0 :     if (!_v) goto check_1;
    6909           0 :     return _wrap_ConstIterator___sub____SWIG_1(nargs, args, self);
    6910             :   }
    6911             : check_1:
    6912             :   
    6913           0 :   if (argc == 2) {
    6914           0 :     return _wrap_ConstIterator___sub____SWIG_0(nargs, args, self);
    6915             :   }
    6916             :   
    6917             : fail:
    6918             :   Ruby_Format_OverloadedError( argc, 3, "ConstIterator.__sub__", 
    6919             :     "    swig::ConstIterator ConstIterator.__sub__(ptrdiff_t n)\n"
    6920           0 :     "    ptrdiff_t ConstIterator.__sub__(swig::ConstIterator const &x)\n");
    6921             :   
    6922             :   return Qnil;
    6923             : }
    6924             : 
    6925             : 
    6926             : 
    6927             : /*
    6928             :   Document-class: Kdbtools::Iterator < Kdbtools::swig::ConstIterator
    6929             : 
    6930             :   Proxy of C++ Kdbtools::Iterator class
    6931             : 
    6932             : 
    6933             : */
    6934             : static swig_class SwigClassIterator;
    6935             : 
    6936             : 
    6937             : /*
    6938             :   Document-method: Kdbtools::Iterator.value=
    6939             : 
    6940             :   call-seq:
    6941             :     value=(VALUE const & v) -> VALUE
    6942             : 
    6943             : An instance method.
    6944             : 
    6945             : */
    6946             : SWIGINTERN VALUE
    6947           0 : _wrap_Iterator_valuee___(int argc, VALUE *argv, VALUE self) {
    6948           0 :   swig::Iterator *arg1 = (swig::Iterator *) 0 ;
    6949           0 :   VALUE *arg2 = 0 ;
    6950           0 :   void *argp1 = 0 ;
    6951           0 :   int res1 = 0 ;
    6952             :   VALUE temp2 ;
    6953             :   VALUE result;
    6954           0 :   VALUE vresult = Qnil;
    6955             :   
    6956           0 :   if ((argc < 1) || (argc > 1)) {
    6957           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    6958             :   }
    6959           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
    6960           0 :   if (!SWIG_IsOK(res1)) {
    6961           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","setValue", 1, self )); 
    6962             :   }
    6963           0 :   arg1 = reinterpret_cast< swig::Iterator * >(argp1);
    6964           0 :   temp2 = static_cast< VALUE >(argv[0]);
    6965           0 :   arg2 = &temp2;
    6966           0 :   result = (VALUE)(arg1)->setValue((VALUE const &)*arg2);
    6967           0 :   vresult = result;
    6968             :   return vresult;
    6969             : fail:
    6970             :   return Qnil;
    6971             : }
    6972             : 
    6973             : 
    6974             : 
    6975             : /*
    6976             :   Document-method: Kdbtools::Iterator.dup
    6977             : 
    6978             :   call-seq:
    6979             :     dup -> Iterator
    6980             : 
    6981             : Create a duplicate of the class and unfreeze it if needed.
    6982             : */
    6983             : SWIGINTERN VALUE
    6984           0 : _wrap_Iterator_dup(int argc, VALUE *argv, VALUE self) {
    6985           0 :   swig::Iterator *arg1 = (swig::Iterator *) 0 ;
    6986           0 :   void *argp1 = 0 ;
    6987           0 :   int res1 = 0 ;
    6988           0 :   swig::Iterator *result = 0 ;
    6989           0 :   VALUE vresult = Qnil;
    6990             :   
    6991           0 :   if ((argc < 0) || (argc > 0)) {
    6992           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    6993             :   }
    6994           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
    6995           0 :   if (!SWIG_IsOK(res1)) {
    6996           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","dup", 1, self )); 
    6997             :   }
    6998           0 :   arg1 = reinterpret_cast< swig::Iterator * >(argp1);
    6999           0 :   result = (swig::Iterator *)((swig::Iterator const *)arg1)->dup();
    7000           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, SWIG_POINTER_OWN |  0 );
    7001             :   return vresult;
    7002             : fail:
    7003             :   return Qnil;
    7004             : }
    7005             : 
    7006             : 
    7007             : 
    7008             : /*
    7009             :   Document-method: Kdbtools::Iterator.next
    7010             : 
    7011             :   call-seq:
    7012             :     next(size_t n=1) -> Iterator
    7013             :     next -> Iterator
    7014             : 
    7015             : An instance method.
    7016             : 
    7017             : */
    7018             : SWIGINTERN VALUE
    7019           0 : _wrap_Iterator_next__SWIG_0(int argc, VALUE *argv, VALUE self) {
    7020           0 :   swig::Iterator *arg1 = (swig::Iterator *) 0 ;
    7021             :   size_t arg2 ;
    7022           0 :   void *argp1 = 0 ;
    7023           0 :   int res1 = 0 ;
    7024             :   size_t val2 ;
    7025           0 :   int ecode2 = 0 ;
    7026           0 :   swig::Iterator *result = 0 ;
    7027           0 :   VALUE vresult = Qnil;
    7028             :   
    7029           0 :   if ((argc < 1) || (argc > 1)) {
    7030           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    7031             :   }
    7032           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7033           0 :   if (!SWIG_IsOK(res1)) {
    7034           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","next", 1, self )); 
    7035             :   }
    7036           0 :   arg1 = reinterpret_cast< swig::Iterator * >(argp1);
    7037           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
    7038           0 :   if (!SWIG_IsOK(ecode2)) {
    7039           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","next", 2, argv[0] ));
    7040             :   } 
    7041           0 :   arg2 = static_cast< size_t >(val2);
    7042           0 :   result = (swig::Iterator *)(arg1)->next(arg2);
    7043           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7044             :   return vresult;
    7045             : fail:
    7046             :   return Qnil;
    7047             : }
    7048             : 
    7049             : 
    7050             : SWIGINTERN VALUE
    7051           0 : _wrap_Iterator_next__SWIG_1(int argc, VALUE *argv, VALUE self) {
    7052           0 :   swig::Iterator *arg1 = (swig::Iterator *) 0 ;
    7053           0 :   void *argp1 = 0 ;
    7054           0 :   int res1 = 0 ;
    7055           0 :   swig::Iterator *result = 0 ;
    7056           0 :   VALUE vresult = Qnil;
    7057             :   
    7058           0 :   if ((argc < 0) || (argc > 0)) {
    7059           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    7060             :   }
    7061           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7062           0 :   if (!SWIG_IsOK(res1)) {
    7063           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","next", 1, self )); 
    7064             :   }
    7065           0 :   arg1 = reinterpret_cast< swig::Iterator * >(argp1);
    7066             :   try {
    7067           0 :     result = (swig::Iterator *)(arg1)->next();
    7068             :   }
    7069           0 :   catch(swig::stop_iteration &_e) {
    7070             :     {
    7071             :       (void)_e;
    7072           0 :       SWIG_Ruby_ExceptionType(NULL, Qnil);
    7073             :       SWIG_fail;
    7074             :     }
    7075             :   }
    7076             :   
    7077           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7078             :   return vresult;
    7079             : fail:
    7080             :   return Qnil;
    7081             : }
    7082             : 
    7083             : 
    7084           0 : SWIGINTERN VALUE _wrap_Iterator_next(int nargs, VALUE *args, VALUE self) {
    7085             :   int argc;
    7086             :   VALUE argv[3];
    7087             :   int ii;
    7088             :   
    7089           0 :   argc = nargs + 1;
    7090             :   argv[0] = self;
    7091           0 :   if (argc > 3) SWIG_fail;
    7092             :   for (ii = 1; (ii < argc); ++ii) {
    7093             :     argv[ii] = args[ii-1];
    7094             :   }
    7095           0 :   if (argc == 1) {
    7096           0 :     return _wrap_Iterator_next__SWIG_1(nargs, args, self);
    7097             :   }
    7098           0 :   if (argc == 2) {
    7099           0 :     return _wrap_Iterator_next__SWIG_0(nargs, args, self);
    7100             :   }
    7101             :   
    7102             : fail:
    7103             :   Ruby_Format_OverloadedError( argc, 3, "Iterator.next", 
    7104             :     "    swig::Iterator Iterator.next(size_t n)\n"
    7105           0 :     "    swig::Iterator * Iterator.next()\n");
    7106             :   
    7107             :   return Qnil;
    7108             : }
    7109             : 
    7110             : 
    7111             : 
    7112             : /*
    7113             :   Document-method: Kdbtools::Iterator.previous
    7114             : 
    7115             :   call-seq:
    7116             :     previous(size_t n=1) -> Iterator
    7117             :     previous -> Iterator
    7118             : 
    7119             : An instance method.
    7120             : 
    7121             : */
    7122             : SWIGINTERN VALUE
    7123           0 : _wrap_Iterator_previous__SWIG_0(int argc, VALUE *argv, VALUE self) {
    7124           0 :   swig::Iterator *arg1 = (swig::Iterator *) 0 ;
    7125             :   size_t arg2 ;
    7126           0 :   void *argp1 = 0 ;
    7127           0 :   int res1 = 0 ;
    7128             :   size_t val2 ;
    7129           0 :   int ecode2 = 0 ;
    7130           0 :   swig::Iterator *result = 0 ;
    7131           0 :   VALUE vresult = Qnil;
    7132             :   
    7133           0 :   if ((argc < 1) || (argc > 1)) {
    7134           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    7135             :   }
    7136           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7137           0 :   if (!SWIG_IsOK(res1)) {
    7138           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","previous", 1, self )); 
    7139             :   }
    7140           0 :   arg1 = reinterpret_cast< swig::Iterator * >(argp1);
    7141           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
    7142           0 :   if (!SWIG_IsOK(ecode2)) {
    7143           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","previous", 2, argv[0] ));
    7144             :   } 
    7145           0 :   arg2 = static_cast< size_t >(val2);
    7146           0 :   result = (swig::Iterator *)(arg1)->previous(arg2);
    7147           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7148             :   return vresult;
    7149             : fail:
    7150             :   return Qnil;
    7151             : }
    7152             : 
    7153             : 
    7154             : SWIGINTERN VALUE
    7155           0 : _wrap_Iterator_previous__SWIG_1(int argc, VALUE *argv, VALUE self) {
    7156           0 :   swig::Iterator *arg1 = (swig::Iterator *) 0 ;
    7157           0 :   void *argp1 = 0 ;
    7158           0 :   int res1 = 0 ;
    7159           0 :   swig::Iterator *result = 0 ;
    7160           0 :   VALUE vresult = Qnil;
    7161             :   
    7162           0 :   if ((argc < 0) || (argc > 0)) {
    7163           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    7164             :   }
    7165           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7166           0 :   if (!SWIG_IsOK(res1)) {
    7167           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","previous", 1, self )); 
    7168             :   }
    7169           0 :   arg1 = reinterpret_cast< swig::Iterator * >(argp1);
    7170             :   try {
    7171           0 :     result = (swig::Iterator *)(arg1)->previous();
    7172             :   }
    7173           0 :   catch(swig::stop_iteration &_e) {
    7174             :     {
    7175             :       (void)_e;
    7176           0 :       SWIG_Ruby_ExceptionType(NULL, Qnil);
    7177             :       SWIG_fail;
    7178             :     }
    7179             :   }
    7180             :   
    7181           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7182             :   return vresult;
    7183             : fail:
    7184             :   return Qnil;
    7185             : }
    7186             : 
    7187             : 
    7188           0 : SWIGINTERN VALUE _wrap_Iterator_previous(int nargs, VALUE *args, VALUE self) {
    7189             :   int argc;
    7190             :   VALUE argv[3];
    7191             :   int ii;
    7192             :   
    7193           0 :   argc = nargs + 1;
    7194             :   argv[0] = self;
    7195           0 :   if (argc > 3) SWIG_fail;
    7196             :   for (ii = 1; (ii < argc); ++ii) {
    7197             :     argv[ii] = args[ii-1];
    7198             :   }
    7199           0 :   if (argc == 1) {
    7200           0 :     return _wrap_Iterator_previous__SWIG_1(nargs, args, self);
    7201             :   }
    7202           0 :   if (argc == 2) {
    7203           0 :     return _wrap_Iterator_previous__SWIG_0(nargs, args, self);
    7204             :   }
    7205             :   
    7206             : fail:
    7207             :   Ruby_Format_OverloadedError( argc, 3, "Iterator.previous", 
    7208             :     "    swig::Iterator Iterator.previous(size_t n)\n"
    7209           0 :     "    swig::Iterator * Iterator.previous()\n");
    7210             :   
    7211             :   return Qnil;
    7212             : }
    7213             : 
    7214             : 
    7215             : 
    7216             : /*
    7217             :   Document-method: Kdbtools::Iterator.==
    7218             : 
    7219             :   call-seq:
    7220             :     ==(x) -> bool
    7221             : 
    7222             : Equality comparison operator.
    7223             : */
    7224             : SWIGINTERN VALUE
    7225           0 : _wrap_Iterator___eq__(int argc, VALUE *argv, VALUE self) {
    7226           0 :   swig::Iterator *arg1 = (swig::Iterator *) 0 ;
    7227           0 :   swig::Iterator *arg2 = 0 ;
    7228           0 :   void *argp1 = 0 ;
    7229           0 :   int res1 = 0 ;
    7230             :   void *argp2 ;
    7231           0 :   int res2 = 0 ;
    7232             :   bool result;
    7233           0 :   VALUE vresult = Qnil;
    7234             :   
    7235           0 :   if ((argc < 1) || (argc > 1)) {
    7236           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    7237             :   }
    7238           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7239           0 :   if (!SWIG_IsOK(res1)) {
    7240           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator ==", 1, self )); 
    7241             :   }
    7242           0 :   arg1 = reinterpret_cast< swig::Iterator * >(argp1);
    7243           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__Iterator,  0 );
    7244           0 :   if (!SWIG_IsOK(res2)) {
    7245           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::Iterator const &","operator ==", 2, argv[0] )); 
    7246             :   }
    7247           0 :   if (!argp2) {
    7248           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::Iterator const &","operator ==", 2, argv[0])); 
    7249             :   }
    7250           0 :   arg2 = reinterpret_cast< swig::Iterator * >(argp2);
    7251           0 :   result = (bool)((swig::Iterator const *)arg1)->operator ==((swig::Iterator const &)*arg2);
    7252           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
    7253             :   return vresult;
    7254             : fail:
    7255             :   return Qnil;
    7256             : }
    7257             : 
    7258             : 
    7259             : 
    7260             : /*
    7261             :   Document-method: Kdbtools::Iterator.+
    7262             : 
    7263             :   call-seq:
    7264             :     +(n) -> Iterator
    7265             : 
    7266             : Add operator.
    7267             : */
    7268             : SWIGINTERN VALUE
    7269           0 : _wrap_Iterator___add__(int argc, VALUE *argv, VALUE self) {
    7270           0 :   swig::Iterator *arg1 = (swig::Iterator *) 0 ;
    7271             :   ptrdiff_t arg2 ;
    7272           0 :   void *argp1 = 0 ;
    7273           0 :   int res1 = 0 ;
    7274             :   ptrdiff_t val2 ;
    7275           0 :   int ecode2 = 0 ;
    7276           0 :   swig::Iterator *result = 0 ;
    7277           0 :   VALUE vresult = Qnil;
    7278             :   
    7279           0 :   if ((argc < 1) || (argc > 1)) {
    7280           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    7281             :   }
    7282           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7283           0 :   if (!SWIG_IsOK(res1)) {
    7284           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator +", 1, self )); 
    7285             :   }
    7286           0 :   arg1 = reinterpret_cast< swig::Iterator * >(argp1);
    7287           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    7288           0 :   if (!SWIG_IsOK(ecode2)) {
    7289           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator +", 2, argv[0] ));
    7290             :   } 
    7291           0 :   arg2 = static_cast< ptrdiff_t >(val2);
    7292             :   try {
    7293           0 :     result = (swig::Iterator *)((swig::Iterator const *)arg1)->operator +(arg2);
    7294             :   }
    7295           0 :   catch(swig::stop_iteration &_e) {
    7296             :     {
    7297             :       (void)_e;
    7298           0 :       SWIG_Ruby_ExceptionType(NULL, Qnil);
    7299             :       SWIG_fail;
    7300             :     }
    7301             :   }
    7302             :   
    7303           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, SWIG_POINTER_OWN |  0 );
    7304             :   return vresult;
    7305             : fail:
    7306           0 :   return Qnil;
    7307             : }
    7308             : 
    7309             : 
    7310             : 
    7311             : /*
    7312             :   Document-method: Kdbtools::Iterator.-
    7313             : 
    7314             :   call-seq:
    7315             :     -(n) -> Iterator
    7316             :     -(x) -> ptrdiff_t
    7317             : 
    7318             : Substraction operator.
    7319             : */
    7320             : SWIGINTERN VALUE
    7321           0 : _wrap_Iterator___sub____SWIG_0(int argc, VALUE *argv, VALUE self) {
    7322           0 :   swig::Iterator *arg1 = (swig::Iterator *) 0 ;
    7323             :   ptrdiff_t arg2 ;
    7324           0 :   void *argp1 = 0 ;
    7325           0 :   int res1 = 0 ;
    7326             :   ptrdiff_t val2 ;
    7327           0 :   int ecode2 = 0 ;
    7328           0 :   swig::Iterator *result = 0 ;
    7329           0 :   VALUE vresult = Qnil;
    7330             :   
    7331           0 :   if ((argc < 1) || (argc > 1)) {
    7332           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    7333             :   }
    7334           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7335           0 :   if (!SWIG_IsOK(res1)) {
    7336           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator -", 1, self )); 
    7337             :   }
    7338           0 :   arg1 = reinterpret_cast< swig::Iterator * >(argp1);
    7339           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    7340           0 :   if (!SWIG_IsOK(ecode2)) {
    7341           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator -", 2, argv[0] ));
    7342             :   } 
    7343           0 :   arg2 = static_cast< ptrdiff_t >(val2);
    7344             :   try {
    7345           0 :     result = (swig::Iterator *)((swig::Iterator const *)arg1)->operator -(arg2);
    7346             :   }
    7347           0 :   catch(swig::stop_iteration &_e) {
    7348             :     {
    7349             :       (void)_e;
    7350           0 :       SWIG_Ruby_ExceptionType(NULL, Qnil);
    7351             :       SWIG_fail;
    7352             :     }
    7353             :   }
    7354             :   
    7355           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, SWIG_POINTER_OWN |  0 );
    7356             :   return vresult;
    7357             : fail:
    7358           0 :   return Qnil;
    7359             : }
    7360             : 
    7361             : 
    7362             : SWIGINTERN VALUE
    7363           0 : _wrap_Iterator___sub____SWIG_1(int argc, VALUE *argv, VALUE self) {
    7364           0 :   swig::Iterator *arg1 = (swig::Iterator *) 0 ;
    7365           0 :   swig::Iterator *arg2 = 0 ;
    7366           0 :   void *argp1 = 0 ;
    7367           0 :   int res1 = 0 ;
    7368             :   void *argp2 ;
    7369           0 :   int res2 = 0 ;
    7370             :   ptrdiff_t result;
    7371           0 :   VALUE vresult = Qnil;
    7372             :   
    7373           0 :   if ((argc < 1) || (argc > 1)) {
    7374           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    7375             :   }
    7376           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_swig__Iterator, 0 |  0 );
    7377           0 :   if (!SWIG_IsOK(res1)) {
    7378           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator -", 1, self )); 
    7379             :   }
    7380           0 :   arg1 = reinterpret_cast< swig::Iterator * >(argp1);
    7381           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__Iterator,  0 );
    7382           0 :   if (!SWIG_IsOK(res2)) {
    7383           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::Iterator const &","operator -", 2, argv[0] )); 
    7384             :   }
    7385           0 :   if (!argp2) {
    7386           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::Iterator const &","operator -", 2, argv[0])); 
    7387             :   }
    7388           0 :   arg2 = reinterpret_cast< swig::Iterator * >(argp2);
    7389           0 :   result = ((swig::Iterator const *)arg1)->operator -((swig::Iterator const &)*arg2);
    7390           0 :   vresult = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
    7391             :   return vresult;
    7392             : fail:
    7393             :   return Qnil;
    7394             : }
    7395             : 
    7396             : 
    7397           0 : SWIGINTERN VALUE _wrap_Iterator___sub__(int nargs, VALUE *args, VALUE self) {
    7398             :   int argc;
    7399             :   VALUE argv[3];
    7400             :   int ii;
    7401             :   
    7402           0 :   argc = nargs + 1;
    7403             :   argv[0] = self;
    7404           0 :   if (argc > 3) SWIG_fail;
    7405           0 :   for (ii = 1; (ii < argc); ++ii) {
    7406           0 :     argv[ii] = args[ii-1];
    7407             :   }
    7408           0 :   if (argc == 2) {
    7409           0 :     int _v = 0;
    7410             :     {
    7411           0 :       void *vptr = 0;
    7412           0 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_swig__Iterator, 0);
    7413           0 :       _v = SWIG_CheckState(res);
    7414             :     }
    7415           0 :     if (!_v) goto check_1;
    7416           0 :     return _wrap_Iterator___sub____SWIG_1(nargs, args, self);
    7417             :   }
    7418             : check_1:
    7419             :   
    7420           0 :   if (argc == 2) {
    7421           0 :     return _wrap_Iterator___sub____SWIG_0(nargs, args, self);
    7422             :   }
    7423             :   
    7424             : fail:
    7425             :   Ruby_Format_OverloadedError( argc, 3, "Iterator.__sub__", 
    7426             :     "    swig::Iterator Iterator.__sub__(ptrdiff_t n)\n"
    7427           0 :     "    ptrdiff_t Iterator.__sub__(swig::Iterator const &x)\n");
    7428             :   
    7429             :   return Qnil;
    7430             : }
    7431             : 
    7432             : 
    7433             : SWIGINTERN void
    7434           0 : free_swig_Iterator(void *self) {
    7435           0 :     swig::Iterator *arg1 = (swig::Iterator *)self;
    7436           0 :     delete arg1;
    7437           0 : }
    7438             : 
    7439             : 
    7440             : /*
    7441             :   Document-class: Kdbtools::VectorStr
    7442             : 
    7443             :   Proxy of C++ Kdbtools::VectorStr class
    7444             : 
    7445             : 
    7446             : */
    7447             : static swig_class SwigClassVectorStr;
    7448             : 
    7449             : 
    7450             : /*
    7451             :   Document-method: Kdbtools::VectorStr.dup
    7452             : 
    7453             :   call-seq:
    7454             :     dup -> VectorStr
    7455             : 
    7456             : Create a duplicate of the class and unfreeze it if needed.
    7457             : */
    7458             : SWIGINTERN VALUE
    7459           0 : _wrap_VectorStr_dup(int argc, VALUE *argv, VALUE self) {
    7460           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7461           0 :   void *argp1 = 0 ;
    7462           0 :   int res1 = 0 ;
    7463           0 :   std::vector< std::string,std::allocator< std::string > > *result = 0 ;
    7464           0 :   VALUE vresult = Qnil;
    7465             :   
    7466           0 :   if ((argc < 0) || (argc > 0)) {
    7467           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    7468             :   }
    7469           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7470           0 :   if (!SWIG_IsOK(res1)) {
    7471           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","dup", 1, self )); 
    7472             :   }
    7473           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7474           0 :   result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg__dup(arg1);
    7475           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
    7476             :   return vresult;
    7477             : fail:
    7478             :   return Qnil;
    7479             : }
    7480             : 
    7481             : 
    7482             : 
    7483             : /*
    7484             :   Document-method: Kdbtools::VectorStr.inspect
    7485             : 
    7486             :   call-seq:
    7487             :     inspect -> VALUE
    7488             : 
    7489             : Inspect class and its contents.
    7490             : */
    7491             : SWIGINTERN VALUE
    7492           0 : _wrap_VectorStr_inspect(int argc, VALUE *argv, VALUE self) {
    7493           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7494           0 :   void *argp1 = 0 ;
    7495           0 :   int res1 = 0 ;
    7496             :   VALUE result;
    7497           0 :   VALUE vresult = Qnil;
    7498             :   
    7499           0 :   if ((argc < 0) || (argc > 0)) {
    7500           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    7501             :   }
    7502           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7503           0 :   if (!SWIG_IsOK(res1)) {
    7504           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","inspect", 1, self )); 
    7505             :   }
    7506           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7507           0 :   result = (VALUE)std_vector_Sl_std_string_Sg__inspect(arg1);
    7508           0 :   vresult = result;
    7509             :   return vresult;
    7510             : fail:
    7511             :   return Qnil;
    7512             : }
    7513             : 
    7514             : 
    7515             : 
    7516             : /*
    7517             :   Document-method: Kdbtools::VectorStr.to_a
    7518             : 
    7519             :   call-seq:
    7520             :     to_a -> VALUE
    7521             : 
    7522             : Convert VectorStr to an Array.
    7523             : */
    7524             : SWIGINTERN VALUE
    7525           0 : _wrap_VectorStr_to_a(int argc, VALUE *argv, VALUE self) {
    7526           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7527           0 :   void *argp1 = 0 ;
    7528           0 :   int res1 = 0 ;
    7529             :   VALUE result;
    7530           0 :   VALUE vresult = Qnil;
    7531             :   
    7532           0 :   if ((argc < 0) || (argc > 0)) {
    7533           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    7534             :   }
    7535           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7536           0 :   if (!SWIG_IsOK(res1)) {
    7537           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","to_a", 1, self )); 
    7538             :   }
    7539           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7540           0 :   result = (VALUE)std_vector_Sl_std_string_Sg__to_a(arg1);
    7541           0 :   vresult = result;
    7542             :   return vresult;
    7543             : fail:
    7544             :   return Qnil;
    7545             : }
    7546             : 
    7547             : 
    7548             : 
    7549             : /*
    7550             :   Document-method: Kdbtools::VectorStr.to_s
    7551             : 
    7552             :   call-seq:
    7553             :     to_s -> VALUE
    7554             : 
    7555             : Convert class to a String representation.
    7556             : */
    7557             : SWIGINTERN VALUE
    7558           0 : _wrap_VectorStr_to_s(int argc, VALUE *argv, VALUE self) {
    7559           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7560           0 :   void *argp1 = 0 ;
    7561           0 :   int res1 = 0 ;
    7562             :   VALUE result;
    7563           0 :   VALUE vresult = Qnil;
    7564             :   
    7565           0 :   if ((argc < 0) || (argc > 0)) {
    7566           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    7567             :   }
    7568           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7569           0 :   if (!SWIG_IsOK(res1)) {
    7570           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","to_s", 1, self )); 
    7571             :   }
    7572           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7573           0 :   result = (VALUE)std_vector_Sl_std_string_Sg__to_s(arg1);
    7574           0 :   vresult = result;
    7575             :   return vresult;
    7576             : fail:
    7577             :   return Qnil;
    7578             : }
    7579             : 
    7580             : 
    7581             : 
    7582             : /*
    7583             :   Document-method: Kdbtools::VectorStr.slice
    7584             : 
    7585             :   call-seq:
    7586             :     slice(i, length) -> VALUE
    7587             : 
    7588             : Return a slice (portion of) the VectorStr.
    7589             : */
    7590             : SWIGINTERN VALUE
    7591           0 : _wrap_VectorStr_slice(int argc, VALUE *argv, VALUE self) {
    7592           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7593             :   std::vector< std::string >::difference_type arg2 ;
    7594             :   std::vector< std::string >::difference_type arg3 ;
    7595           0 :   void *argp1 = 0 ;
    7596           0 :   int res1 = 0 ;
    7597             :   ptrdiff_t val2 ;
    7598           0 :   int ecode2 = 0 ;
    7599             :   ptrdiff_t val3 ;
    7600           0 :   int ecode3 = 0 ;
    7601             :   VALUE result;
    7602           0 :   VALUE vresult = Qnil;
    7603             :   
    7604           0 :   if ((argc < 2) || (argc > 2)) {
    7605           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
    7606             :   }
    7607           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7608           0 :   if (!SWIG_IsOK(res1)) {
    7609           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","slice", 1, self )); 
    7610             :   }
    7611           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7612           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    7613           0 :   if (!SWIG_IsOK(ecode2)) {
    7614           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::difference_type","slice", 2, argv[0] ));
    7615             :   } 
    7616           0 :   arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
    7617           0 :   ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
    7618           0 :   if (!SWIG_IsOK(ecode3)) {
    7619           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< std::string >::difference_type","slice", 3, argv[1] ));
    7620             :   } 
    7621           0 :   arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
    7622             :   try {
    7623           0 :     result = (VALUE)std_vector_Sl_std_string_Sg__slice(arg1,arg2,arg3);
    7624             :   }
    7625           0 :   catch(std::invalid_argument &_e) {
    7626           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
    7627             :   }
    7628             :   
    7629           0 :   vresult = result;
    7630             :   return vresult;
    7631             : fail:
    7632             :   return Qnil;
    7633             : }
    7634             : 
    7635             : 
    7636             : 
    7637             : /*
    7638             :   Document-method: Kdbtools::VectorStr.each
    7639             : 
    7640             :   call-seq:
    7641             :     each -> VectorStr
    7642             : 
    7643             : Iterate thru each element in the VectorStr.  A block must be provided.
    7644             : */
    7645             : SWIGINTERN VALUE
    7646           0 : _wrap_VectorStr_each(int argc, VALUE *argv, VALUE self) {
    7647           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7648           0 :   void *argp1 = 0 ;
    7649           0 :   int res1 = 0 ;
    7650           0 :   std::vector< std::string,std::allocator< std::string > > *result = 0 ;
    7651           0 :   VALUE vresult = Qnil;
    7652             :   
    7653           0 :   if ((argc < 0) || (argc > 0)) {
    7654           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    7655             :   }
    7656           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7657           0 :   if (!SWIG_IsOK(res1)) {
    7658           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","each", 1, self )); 
    7659             :   }
    7660           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7661           0 :   result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg__each(arg1);
    7662           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7663             :   return vresult;
    7664             : fail:
    7665             :   return Qnil;
    7666             : }
    7667             : 
    7668             : 
    7669             : 
    7670             : /*
    7671             :   Document-method: Kdbtools::VectorStr.__delete_2__
    7672             : 
    7673             :   call-seq:
    7674             :     __delete_2__(std::vector< std::string >::value_type const & i) -> VALUE
    7675             : 
    7676             : An instance method.
    7677             : 
    7678             : */
    7679             : SWIGINTERN VALUE
    7680           0 : _wrap_VectorStr___delete_2__(int argc, VALUE *argv, VALUE self) {
    7681           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7682           0 :   std::vector< std::string >::value_type *arg2 = 0 ;
    7683           0 :   void *argp1 = 0 ;
    7684           0 :   int res1 = 0 ;
    7685           0 :   int res2 = SWIG_OLDOBJ ;
    7686             :   VALUE result;
    7687           0 :   VALUE vresult = Qnil;
    7688             :   
    7689           0 :   if ((argc < 1) || (argc > 1)) {
    7690           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    7691             :   }
    7692           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7693           0 :   if (!SWIG_IsOK(res1)) {
    7694           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","__delete2__", 1, self )); 
    7695             :   }
    7696           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7697             :   {
    7698           0 :     std::string *ptr = (std::string *)0;
    7699           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    7700           0 :     if (!SWIG_IsOK(res2)) {
    7701           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::string >::value_type const &","__delete2__", 2, argv[0] )); 
    7702             :     }
    7703           0 :     if (!ptr) {
    7704           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string >::value_type const &","__delete2__", 2, argv[0])); 
    7705             :     }
    7706           0 :     arg2 = ptr;
    7707             :   }
    7708           0 :   result = (VALUE)std_vector_Sl_std_string_Sg____delete2__(arg1,(std::string const &)*arg2);
    7709           0 :   vresult = result;
    7710           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    7711             :   return vresult;
    7712             : fail:
    7713             :   if (SWIG_IsNewObj(res2)) delete arg2;
    7714             :   return Qnil;
    7715             : }
    7716             : 
    7717             : 
    7718             : 
    7719             : /*
    7720             :   Document-method: Kdbtools::VectorStr.select
    7721             : 
    7722             :   call-seq:
    7723             :     select -> VectorStr
    7724             : 
    7725             : Iterate thru each element in the VectorStr and select those that match a condition.  A block must be provided.
    7726             : */
    7727             : SWIGINTERN VALUE
    7728           0 : _wrap_VectorStr_select(int argc, VALUE *argv, VALUE self) {
    7729           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7730           0 :   void *argp1 = 0 ;
    7731           0 :   int res1 = 0 ;
    7732           0 :   std::vector< std::string,std::allocator< std::string > > *result = 0 ;
    7733           0 :   VALUE vresult = Qnil;
    7734             :   
    7735           0 :   if ((argc < 0) || (argc > 0)) {
    7736           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    7737             :   }
    7738           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7739           0 :   if (!SWIG_IsOK(res1)) {
    7740           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","select", 1, self )); 
    7741             :   }
    7742           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7743           0 :   result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg__select(arg1);
    7744           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
    7745             :   return vresult;
    7746             : fail:
    7747             :   return Qnil;
    7748             : }
    7749             : 
    7750             : 
    7751             : 
    7752             : /*
    7753             :   Document-method: Kdbtools::VectorStr.delete_at
    7754             : 
    7755             :   call-seq:
    7756             :     delete_at(i) -> VALUE
    7757             : 
    7758             : Delete an element at a certain index.
    7759             : */
    7760             : SWIGINTERN VALUE
    7761           0 : _wrap_VectorStr_delete_at(int argc, VALUE *argv, VALUE self) {
    7762           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7763             :   std::vector< std::string >::difference_type arg2 ;
    7764           0 :   void *argp1 = 0 ;
    7765           0 :   int res1 = 0 ;
    7766             :   ptrdiff_t val2 ;
    7767           0 :   int ecode2 = 0 ;
    7768             :   VALUE result;
    7769           0 :   VALUE vresult = Qnil;
    7770             :   
    7771           0 :   if ((argc < 1) || (argc > 1)) {
    7772           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    7773             :   }
    7774           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7775           0 :   if (!SWIG_IsOK(res1)) {
    7776           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","delete_at", 1, self )); 
    7777             :   }
    7778           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7779           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    7780           0 :   if (!SWIG_IsOK(ecode2)) {
    7781           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::difference_type","delete_at", 2, argv[0] ));
    7782             :   } 
    7783           0 :   arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
    7784           0 :   result = (VALUE)std_vector_Sl_std_string_Sg__delete_at(arg1,arg2);
    7785           0 :   vresult = result;
    7786             :   return vresult;
    7787             : fail:
    7788             :   return Qnil;
    7789             : }
    7790             : 
    7791             : 
    7792             : 
    7793             : /*
    7794             :   Document-method: Kdbtools::VectorStr.at
    7795             : 
    7796             :   call-seq:
    7797             :     at(i) -> VALUE
    7798             : 
    7799             : Return element at a certain index.
    7800             : */
    7801             : SWIGINTERN VALUE
    7802           0 : _wrap_VectorStr_at(int argc, VALUE *argv, VALUE self) {
    7803           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7804             :   std::vector< std::string >::difference_type arg2 ;
    7805           0 :   void *argp1 = 0 ;
    7806           0 :   int res1 = 0 ;
    7807             :   ptrdiff_t val2 ;
    7808           0 :   int ecode2 = 0 ;
    7809             :   VALUE result;
    7810           0 :   VALUE vresult = Qnil;
    7811             :   
    7812           0 :   if ((argc < 1) || (argc > 1)) {
    7813           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    7814             :   }
    7815           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7816           0 :   if (!SWIG_IsOK(res1)) {
    7817           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > const *","at", 1, self )); 
    7818             :   }
    7819           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7820           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    7821           0 :   if (!SWIG_IsOK(ecode2)) {
    7822           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::difference_type","at", 2, argv[0] ));
    7823             :   } 
    7824           0 :   arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
    7825           0 :   result = (VALUE)std_vector_Sl_std_string_Sg__at((std::vector< std::string > const *)arg1,arg2);
    7826           0 :   vresult = result;
    7827             :   return vresult;
    7828             : fail:
    7829             :   return Qnil;
    7830             : }
    7831             : 
    7832             : 
    7833             : 
    7834             : /*
    7835             :   Document-method: Kdbtools::VectorStr.[]
    7836             : 
    7837             :   call-seq:
    7838             :     [](i, length) -> VALUE
    7839             :     [](i) -> VALUE
    7840             :     [](i) -> VALUE
    7841             : 
    7842             : Element accessor/slicing.
    7843             : */
    7844             : SWIGINTERN VALUE
    7845           0 : _wrap_VectorStr___getitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
    7846           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7847             :   std::vector< std::string >::difference_type arg2 ;
    7848             :   std::vector< std::string >::difference_type arg3 ;
    7849           0 :   void *argp1 = 0 ;
    7850           0 :   int res1 = 0 ;
    7851             :   ptrdiff_t val2 ;
    7852           0 :   int ecode2 = 0 ;
    7853             :   ptrdiff_t val3 ;
    7854           0 :   int ecode3 = 0 ;
    7855             :   VALUE result;
    7856           0 :   VALUE vresult = Qnil;
    7857             :   
    7858           0 :   if ((argc < 2) || (argc > 2)) {
    7859           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
    7860             :   }
    7861           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7862           0 :   if (!SWIG_IsOK(res1)) {
    7863           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > const *","__getitem__", 1, self )); 
    7864             :   }
    7865           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7866           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    7867           0 :   if (!SWIG_IsOK(ecode2)) {
    7868           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::difference_type","__getitem__", 2, argv[0] ));
    7869             :   } 
    7870           0 :   arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
    7871           0 :   ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
    7872           0 :   if (!SWIG_IsOK(ecode3)) {
    7873           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< std::string >::difference_type","__getitem__", 3, argv[1] ));
    7874             :   } 
    7875           0 :   arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
    7876             :   try {
    7877           0 :     result = (VALUE)std_vector_Sl_std_string_Sg____getitem____SWIG_0((std::vector< std::string > const *)arg1,arg2,arg3);
    7878             :   }
    7879           0 :   catch(std::invalid_argument &_e) {
    7880           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
    7881             :   }
    7882             :   
    7883           0 :   vresult = result;
    7884             :   return vresult;
    7885             : fail:
    7886             :   return Qnil;
    7887             : }
    7888             : 
    7889             : 
    7890             : SWIGINTERN VALUE
    7891           0 : _wrap_VectorStr___getitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
    7892           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7893             :   std::vector< std::string >::difference_type arg2 ;
    7894           0 :   void *argp1 = 0 ;
    7895           0 :   int res1 = 0 ;
    7896             :   ptrdiff_t val2 ;
    7897           0 :   int ecode2 = 0 ;
    7898             :   VALUE result;
    7899           0 :   VALUE vresult = Qnil;
    7900             :   
    7901           0 :   if ((argc < 1) || (argc > 1)) {
    7902           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    7903             :   }
    7904           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7905           0 :   if (!SWIG_IsOK(res1)) {
    7906           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > const *","__getitem__", 1, self )); 
    7907             :   }
    7908           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7909           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    7910           0 :   if (!SWIG_IsOK(ecode2)) {
    7911           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::difference_type","__getitem__", 2, argv[0] ));
    7912             :   } 
    7913           0 :   arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
    7914           0 :   result = (VALUE)std_vector_Sl_std_string_Sg____getitem____SWIG_1((std::vector< std::string > const *)arg1,arg2);
    7915           0 :   vresult = result;
    7916             :   return vresult;
    7917             : fail:
    7918             :   return Qnil;
    7919             : }
    7920             : 
    7921             : 
    7922             : SWIGINTERN VALUE
    7923           0 : _wrap_VectorStr___getitem____SWIG_2(int argc, VALUE *argv, VALUE self) {
    7924           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    7925           0 :   VALUE arg2 = (VALUE) 0 ;
    7926           0 :   void *argp1 = 0 ;
    7927           0 :   int res1 = 0 ;
    7928             :   VALUE result;
    7929           0 :   VALUE vresult = Qnil;
    7930             :   
    7931           0 :   if ((argc < 1) || (argc > 1)) {
    7932           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    7933             :   }
    7934           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    7935           0 :   if (!SWIG_IsOK(res1)) {
    7936           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > const *","__getitem__", 1, self )); 
    7937             :   }
    7938           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    7939           0 :   arg2 = argv[0];
    7940             :   try {
    7941           0 :     result = (VALUE)std_vector_Sl_std_string_Sg____getitem____SWIG_2((std::vector< std::string > const *)arg1,arg2);
    7942             :   }
    7943           0 :   catch(std::invalid_argument &_e) {
    7944           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
    7945             :   }
    7946             :   
    7947           0 :   vresult = result;
    7948             :   return vresult;
    7949             : fail:
    7950             :   return Qnil;
    7951             : }
    7952             : 
    7953             : 
    7954           0 : SWIGINTERN VALUE _wrap_VectorStr___getitem__(int nargs, VALUE *args, VALUE self) {
    7955             :   int argc;
    7956             :   VALUE argv[4];
    7957             :   int ii;
    7958             :   
    7959           0 :   argc = nargs + 1;
    7960             :   argv[0] = self;
    7961           0 :   if (argc > 4) SWIG_fail;
    7962           0 :   for (ii = 1; (ii < argc); ++ii) {
    7963           0 :     argv[ii] = args[ii-1];
    7964             :   }
    7965           0 :   if (argc == 2) {
    7966           0 :     int _v = 0;
    7967             :     {
    7968             :       {
    7969           0 :         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
    7970           0 :         _v = SWIG_CheckState(res);
    7971             :       }
    7972             :     }
    7973           0 :     if (!_v) goto check_1;
    7974           0 :     return _wrap_VectorStr___getitem____SWIG_1(nargs, args, self);
    7975             :   }
    7976             : check_1:
    7977             :   
    7978           0 :   if (argc == 2) {
    7979           0 :     return _wrap_VectorStr___getitem____SWIG_2(nargs, args, self);
    7980             :   }
    7981           0 :   if (argc == 3) {
    7982           0 :     return _wrap_VectorStr___getitem____SWIG_0(nargs, args, self);
    7983             :   }
    7984             :   
    7985             : fail:
    7986             :   Ruby_Format_OverloadedError( argc, 4, "__getitem__", 
    7987             :     "    VALUE __getitem__(std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type length)\n"
    7988             :     "    VALUE __getitem__(std::vector< std::string >::difference_type i)\n"
    7989           0 :     "    VALUE __getitem__(VALUE i)\n");
    7990             :   
    7991             :   return Qnil;
    7992             : }
    7993             : 
    7994             : 
    7995             : 
    7996             : /*
    7997             :   Document-method: Kdbtools::VectorStr.[]=
    7998             : 
    7999             :   call-seq:
    8000             :     []=(i, x) -> VALUE
    8001             :     []=(i, length, v) -> VALUE
    8002             : 
    8003             : Element setter/slicing.
    8004             : */
    8005             : SWIGINTERN VALUE
    8006           0 : _wrap_VectorStr___setitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
    8007           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8008             :   std::vector< std::string >::difference_type arg2 ;
    8009           0 :   std::vector< std::string >::value_type *arg3 = 0 ;
    8010           0 :   void *argp1 = 0 ;
    8011           0 :   int res1 = 0 ;
    8012             :   ptrdiff_t val2 ;
    8013           0 :   int ecode2 = 0 ;
    8014           0 :   int res3 = SWIG_OLDOBJ ;
    8015             :   VALUE result;
    8016           0 :   VALUE vresult = Qnil;
    8017             :   
    8018           0 :   if ((argc < 2) || (argc > 2)) {
    8019           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
    8020             :   }
    8021           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8022           0 :   if (!SWIG_IsOK(res1)) {
    8023           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","__setitem__", 1, self )); 
    8024             :   }
    8025           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8026           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    8027           0 :   if (!SWIG_IsOK(ecode2)) {
    8028           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::difference_type","__setitem__", 2, argv[0] ));
    8029             :   } 
    8030           0 :   arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
    8031             :   {
    8032           0 :     std::string *ptr = (std::string *)0;
    8033           0 :     res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    8034           0 :     if (!SWIG_IsOK(res3)) {
    8035           0 :       SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< std::string >::value_type const &","__setitem__", 3, argv[1] )); 
    8036             :     }
    8037           0 :     if (!ptr) {
    8038           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string >::value_type const &","__setitem__", 3, argv[1])); 
    8039             :     }
    8040           0 :     arg3 = ptr;
    8041             :   }
    8042             :   try {
    8043           0 :     result = (VALUE)std_vector_Sl_std_string_Sg____setitem____SWIG_0(arg1,arg2,(std::string const &)*arg3);
    8044             :   }
    8045           0 :   catch(std::invalid_argument &_e) {
    8046           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
    8047             :   }
    8048           0 :   catch(std::out_of_range &_e) {
    8049           0 :     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
    8050             :   }
    8051             :   
    8052           0 :   vresult = result;
    8053           0 :   if (SWIG_IsNewObj(res3)) delete arg3;
    8054             :   return vresult;
    8055             : fail:
    8056             :   if (SWIG_IsNewObj(res3)) delete arg3;
    8057             :   return Qnil;
    8058             : }
    8059             : 
    8060             : 
    8061             : SWIGINTERN VALUE
    8062           0 : _wrap_VectorStr___setitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
    8063           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8064             :   std::vector< std::string >::difference_type arg2 ;
    8065             :   std::vector< std::string >::difference_type arg3 ;
    8066           0 :   std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
    8067           0 :   void *argp1 = 0 ;
    8068           0 :   int res1 = 0 ;
    8069             :   ptrdiff_t val2 ;
    8070           0 :   int ecode2 = 0 ;
    8071             :   ptrdiff_t val3 ;
    8072           0 :   int ecode3 = 0 ;
    8073           0 :   int res4 = SWIG_OLDOBJ ;
    8074             :   VALUE result;
    8075           0 :   VALUE vresult = Qnil;
    8076             :   
    8077           0 :   if ((argc < 3) || (argc > 3)) {
    8078           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
    8079             :   }
    8080           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8081           0 :   if (!SWIG_IsOK(res1)) {
    8082           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","__setitem__", 1, self )); 
    8083             :   }
    8084           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8085           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    8086           0 :   if (!SWIG_IsOK(ecode2)) {
    8087           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::difference_type","__setitem__", 2, argv[0] ));
    8088             :   } 
    8089           0 :   arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
    8090           0 :   ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
    8091           0 :   if (!SWIG_IsOK(ecode3)) {
    8092           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< std::string >::difference_type","__setitem__", 3, argv[1] ));
    8093             :   } 
    8094           0 :   arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
    8095             :   {
    8096           0 :     std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    8097           0 :     res4 = swig::asptr(argv[2], &ptr);
    8098           0 :     if (!SWIG_IsOK(res4)) {
    8099           0 :       SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector< std::string,std::allocator< std::string > > const &","__setitem__", 4, argv[2] )); 
    8100             :     }
    8101           0 :     if (!ptr) {
    8102           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string,std::allocator< std::string > > const &","__setitem__", 4, argv[2])); 
    8103             :     }
    8104           0 :     arg4 = ptr;
    8105             :   }
    8106             :   try {
    8107           0 :     result = (VALUE)std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2,arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    8108             :   }
    8109           0 :   catch(std::invalid_argument &_e) {
    8110           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
    8111             :   }
    8112             :   
    8113           0 :   vresult = result;
    8114           0 :   if (SWIG_IsNewObj(res4)) delete arg4;
    8115             :   return vresult;
    8116             : fail:
    8117             :   if (SWIG_IsNewObj(res4)) delete arg4;
    8118             :   return Qnil;
    8119             : }
    8120             : 
    8121             : 
    8122           0 : SWIGINTERN VALUE _wrap_VectorStr___setitem__(int nargs, VALUE *args, VALUE self) {
    8123             :   int argc;
    8124             :   VALUE argv[5];
    8125             :   int ii;
    8126             :   
    8127           0 :   argc = nargs + 1;
    8128             :   argv[0] = self;
    8129           0 :   if (argc > 5) SWIG_fail;
    8130             :   for (ii = 1; (ii < argc); ++ii) {
    8131             :     argv[ii] = args[ii-1];
    8132             :   }
    8133           0 :   if (argc == 3) {
    8134           0 :     return _wrap_VectorStr___setitem____SWIG_0(nargs, args, self);
    8135             :   }
    8136           0 :   if (argc == 4) {
    8137           0 :     return _wrap_VectorStr___setitem____SWIG_1(nargs, args, self);
    8138             :   }
    8139             :   
    8140             : fail:
    8141             :   Ruby_Format_OverloadedError( argc, 5, "__setitem__", 
    8142             :     "    VALUE __setitem__(std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const &x)\n"
    8143           0 :     "    VALUE __setitem__(std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type length, std::vector< std::string,std::allocator< std::string > > const &v)\n");
    8144             :   
    8145             :   return Qnil;
    8146             : }
    8147             : 
    8148             : 
    8149             : 
    8150             : /*
    8151             :   Document-method: Kdbtools::VectorStr.reject_bang
    8152             : 
    8153             :   call-seq:
    8154             :     reject_bang -> VectorStr
    8155             : 
    8156             : Iterate thru each element in the VectorStr and reject those that fail a condition.  A block must be provided.  VectorStr is modified in place.
    8157             : */
    8158             : SWIGINTERN VALUE
    8159           0 : _wrap_VectorStr_reject_bang(int argc, VALUE *argv, VALUE self) {
    8160           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8161           0 :   void *argp1 = 0 ;
    8162           0 :   int res1 = 0 ;
    8163           0 :   std::vector< std::string,std::allocator< std::string > > *result = 0 ;
    8164           0 :   VALUE vresult = Qnil;
    8165             :   
    8166           0 :   if ((argc < 0) || (argc > 0)) {
    8167           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    8168             :   }
    8169           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8170           0 :   if (!SWIG_IsOK(res1)) {
    8171           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","reject_bang", 1, self )); 
    8172             :   }
    8173           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8174           0 :   result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg__reject_bang(arg1);
    8175           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8176             :   return vresult;
    8177             : fail:
    8178             :   return Qnil;
    8179             : }
    8180             : 
    8181             : 
    8182             : 
    8183             : /*
    8184             :   Document-method: Kdbtools::VectorStr.pop
    8185             : 
    8186             :   call-seq:
    8187             :     pop -> VALUE
    8188             : 
    8189             : Remove and return element at the end of the VectorStr.
    8190             : */
    8191             : SWIGINTERN VALUE
    8192           0 : _wrap_VectorStr_pop(int argc, VALUE *argv, VALUE self) {
    8193           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8194           0 :   void *argp1 = 0 ;
    8195           0 :   int res1 = 0 ;
    8196             :   VALUE result;
    8197           0 :   VALUE vresult = Qnil;
    8198             :   
    8199           0 :   if ((argc < 0) || (argc > 0)) {
    8200           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    8201             :   }
    8202           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8203           0 :   if (!SWIG_IsOK(res1)) {
    8204           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","pop", 1, self )); 
    8205             :   }
    8206           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8207           0 :   result = (VALUE)std_vector_Sl_std_string_Sg__pop(arg1);
    8208           0 :   vresult = result;
    8209             :   return vresult;
    8210             : fail:
    8211             :   return Qnil;
    8212             : }
    8213             : 
    8214             : 
    8215             : 
    8216             : /*
    8217             :   Document-method: Kdbtools::VectorStr.push
    8218             : 
    8219             :   call-seq:
    8220             :     push(e) -> std::vector< std::string >::value_type const
    8221             : 
    8222             : Add an element at the end of the VectorStr.
    8223             : */
    8224             : SWIGINTERN VALUE
    8225           0 : _wrap_VectorStr_push(int argc, VALUE *argv, VALUE self) {
    8226           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8227           0 :   std::vector< std::string >::value_type *arg2 = 0 ;
    8228           0 :   void *argp1 = 0 ;
    8229           0 :   int res1 = 0 ;
    8230           0 :   int res2 = SWIG_OLDOBJ ;
    8231           0 :   std::vector< std::string >::value_type result;
    8232           0 :   VALUE vresult = Qnil;
    8233             :   
    8234           0 :   if ((argc < 1) || (argc > 1)) {
    8235           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    8236             :   }
    8237           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8238           0 :   if (!SWIG_IsOK(res1)) {
    8239           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","push", 1, self )); 
    8240             :   }
    8241           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8242             :   {
    8243           0 :     std::string *ptr = (std::string *)0;
    8244           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    8245           0 :     if (!SWIG_IsOK(res2)) {
    8246           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::string >::value_type const &","push", 2, argv[0] )); 
    8247             :     }
    8248           0 :     if (!ptr) {
    8249           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string >::value_type const &","push", 2, argv[0])); 
    8250             :     }
    8251           0 :     arg2 = ptr;
    8252             :   }
    8253           0 :   result = std_vector_Sl_std_string_Sg__push(arg1,(std::string const &)*arg2);
    8254           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
    8255           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    8256           0 :   return vresult;
    8257             : fail:
    8258             :   if (SWIG_IsNewObj(res2)) delete arg2;
    8259             :   return Qnil;
    8260             : }
    8261             : 
    8262             : 
    8263             : 
    8264             : /*
    8265             :   Document-method: Kdbtools::VectorStr.reject
    8266             : 
    8267             :   call-seq:
    8268             :     reject -> VectorStr
    8269             : 
    8270             : Iterate thru each element in the VectorStr and reject those that fail a condition returning a new VectorStr.  A block must be provided.
    8271             : */
    8272             : SWIGINTERN VALUE
    8273           0 : _wrap_VectorStr_reject(int argc, VALUE *argv, VALUE self) {
    8274           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8275           0 :   void *argp1 = 0 ;
    8276           0 :   int res1 = 0 ;
    8277           0 :   std::vector< std::string,std::allocator< std::string > > *result = 0 ;
    8278           0 :   VALUE vresult = Qnil;
    8279             :   
    8280           0 :   if ((argc < 0) || (argc > 0)) {
    8281           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    8282             :   }
    8283           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8284           0 :   if (!SWIG_IsOK(res1)) {
    8285           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","reject", 1, self )); 
    8286             :   }
    8287           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8288           0 :   result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg__reject(arg1);
    8289           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
    8290             :   return vresult;
    8291             : fail:
    8292             :   return Qnil;
    8293             : }
    8294             : 
    8295             : 
    8296             : 
    8297             : /*
    8298             :   Document-method: Kdbtools::VectorStr.shift
    8299             : 
    8300             :   call-seq:
    8301             :     shift -> VALUE
    8302             : 
    8303             : Remove and return element at the beginning of the VectorStr.
    8304             : */
    8305             : SWIGINTERN VALUE
    8306           0 : _wrap_VectorStr_shift(int argc, VALUE *argv, VALUE self) {
    8307           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8308           0 :   void *argp1 = 0 ;
    8309           0 :   int res1 = 0 ;
    8310             :   VALUE result;
    8311           0 :   VALUE vresult = Qnil;
    8312             :   
    8313           0 :   if ((argc < 0) || (argc > 0)) {
    8314           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    8315             :   }
    8316           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8317           0 :   if (!SWIG_IsOK(res1)) {
    8318           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","shift", 1, self )); 
    8319             :   }
    8320           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8321           0 :   result = (VALUE)std_vector_Sl_std_string_Sg__shift(arg1);
    8322           0 :   vresult = result;
    8323             :   return vresult;
    8324             : fail:
    8325             :   return Qnil;
    8326             : }
    8327             : 
    8328             : 
    8329             : 
    8330             : /*
    8331             :   Document-method: Kdbtools::VectorStr.insert
    8332             : 
    8333             :   call-seq:
    8334             :     insert(pos, argc) -> VectorStr
    8335             : 
    8336             : Insert one or more new elements in the VectorStr.
    8337             : */
    8338             : SWIGINTERN VALUE
    8339           0 : _wrap_VectorStr_insert(int argc, VALUE *argv, VALUE self) {
    8340           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8341             :   std::vector< std::string >::difference_type arg2 ;
    8342             :   int arg3 ;
    8343           0 :   VALUE *arg4 = (VALUE *) 0 ;
    8344           0 :   void *arg5 = 0 ;
    8345           0 :   void *argp1 = 0 ;
    8346           0 :   int res1 = 0 ;
    8347             :   ptrdiff_t val2 ;
    8348           0 :   int ecode2 = 0 ;
    8349           0 :   std::vector< std::string,std::allocator< std::string > > *result = 0 ;
    8350           0 :   VALUE vresult = Qnil;
    8351             :   
    8352           0 :   if (argc < 2) {
    8353           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
    8354             :   }
    8355           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8356           0 :   if (!SWIG_IsOK(res1)) {
    8357           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","insert", 1, self )); 
    8358             :   }
    8359           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8360           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
    8361           0 :   if (!SWIG_IsOK(ecode2)) {
    8362           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::difference_type","insert", 2, argv[0] ));
    8363             :   } 
    8364           0 :   arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
    8365             :   {
    8366           0 :     arg3 = argc - 1;
    8367           0 :     arg4 = argv + 1;
    8368             :   }
    8369           0 :   result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg__insert(arg1,arg2,arg3,arg4,arg5);
    8370           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8371             :   return vresult;
    8372             : fail:
    8373             :   return Qnil;
    8374             : }
    8375             : 
    8376             : 
    8377             : 
    8378             : /*
    8379             :   Document-method: Kdbtools::VectorStr.unshift
    8380             : 
    8381             :   call-seq:
    8382             :     unshift(argc) -> VectorStr
    8383             : 
    8384             : Add one or more elements at the beginning of the VectorStr.
    8385             : */
    8386             : SWIGINTERN VALUE
    8387           0 : _wrap_VectorStr_unshift(int argc, VALUE *argv, VALUE self) {
    8388           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8389             :   int arg2 ;
    8390           0 :   VALUE *arg3 = (VALUE *) 0 ;
    8391           0 :   void *arg4 = 0 ;
    8392           0 :   void *argp1 = 0 ;
    8393           0 :   int res1 = 0 ;
    8394           0 :   std::vector< std::string,std::allocator< std::string > > *result = 0 ;
    8395           0 :   VALUE vresult = Qnil;
    8396             :   
    8397           0 :   if (argc < 1) {
    8398           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    8399             :   }
    8400           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8401           0 :   if (!SWIG_IsOK(res1)) {
    8402           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","unshift", 1, self )); 
    8403             :   }
    8404           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8405             :   {
    8406           0 :     arg2 = argc;
    8407           0 :     arg3 = argv;
    8408             :   }
    8409           0 :   result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg__unshift(arg1,arg2,arg3,arg4);
    8410           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8411             :   return vresult;
    8412             : fail:
    8413             :   return Qnil;
    8414             : }
    8415             : 
    8416             : 
    8417             : 
    8418             : /*
    8419             :   Document-method: Kdbtools::VectorStr.new
    8420             : 
    8421             :   call-seq:
    8422             :     VectorStr.new
    8423             :     VectorStr.new(VectorStr arg2)
    8424             :     VectorStr.new(std::vector< std::string >::size_type size)
    8425             :     VectorStr.new(std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value)
    8426             : 
    8427             : Class constructor.
    8428             : 
    8429             : */
    8430             : SWIGINTERN VALUE
    8431           0 : _wrap_new_VectorStr__SWIG_0(int argc, VALUE *argv, VALUE self) {
    8432           0 :   std::vector< std::string > *result = 0 ;
    8433             :   
    8434           0 :   if ((argc < 0) || (argc > 0)) {
    8435           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    8436             :   }
    8437           0 :   result = (std::vector< std::string > *)new std::vector< std::string >();
    8438           0 :   DATA_PTR(self) = result;
    8439             :   return self;
    8440             : fail:
    8441             :   return Qnil;
    8442             : }
    8443             : 
    8444             : 
    8445             : SWIGINTERN VALUE
    8446           0 : _wrap_new_VectorStr__SWIG_1(int argc, VALUE *argv, VALUE self) {
    8447           0 :   std::vector< std::string > *arg1 = 0 ;
    8448           0 :   int res1 = SWIG_OLDOBJ ;
    8449           0 :   std::vector< std::string > *result = 0 ;
    8450             :   
    8451           0 :   if ((argc < 1) || (argc > 1)) {
    8452           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    8453             :   }
    8454             :   {
    8455           0 :     std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    8456           0 :     res1 = swig::asptr(argv[0], &ptr);
    8457           0 :     if (!SWIG_IsOK(res1)) {
    8458           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > const &","vector<(std::string)>", 1, argv[0] )); 
    8459             :     }
    8460           0 :     if (!ptr) {
    8461           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string > const &","vector<(std::string)>", 1, argv[0])); 
    8462             :     }
    8463           0 :     arg1 = ptr;
    8464             :   }
    8465           0 :   result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
    8466           0 :   DATA_PTR(self) = result;
    8467           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
    8468             :   return self;
    8469             : fail:
    8470             :   if (SWIG_IsNewObj(res1)) delete arg1;
    8471             :   return Qnil;
    8472             : }
    8473             : 
    8474             : 
    8475             : 
    8476             : /*
    8477             :   Document-method: Kdbtools::VectorStr.empty
    8478             : 
    8479             :   call-seq:
    8480             :     empty -> bool
    8481             : 
    8482             : Check if the VectorStr is empty or not.
    8483             : */
    8484             : SWIGINTERN VALUE
    8485           0 : _wrap_VectorStr_empty(int argc, VALUE *argv, VALUE self) {
    8486           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8487           0 :   void *argp1 = 0 ;
    8488           0 :   int res1 = 0 ;
    8489             :   bool result;
    8490           0 :   VALUE vresult = Qnil;
    8491             :   
    8492           0 :   if ((argc < 0) || (argc > 0)) {
    8493           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    8494             :   }
    8495           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8496           0 :   if (!SWIG_IsOK(res1)) {
    8497           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > const *","empty", 1, self )); 
    8498             :   }
    8499           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8500           0 :   result = (bool)((std::vector< std::string > const *)arg1)->empty();
    8501           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
    8502             :   return vresult;
    8503             : fail:
    8504             :   return Qnil;
    8505             : }
    8506             : 
    8507             : 
    8508             : 
    8509             : /*
    8510             :   Document-method: Kdbtools::VectorStr.size
    8511             : 
    8512             :   call-seq:
    8513             :     size -> std::vector< std::string >::size_type
    8514             : 
    8515             : Size or Length of the VectorStr.
    8516             : */
    8517             : SWIGINTERN VALUE
    8518           0 : _wrap_VectorStr_size(int argc, VALUE *argv, VALUE self) {
    8519           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8520           0 :   void *argp1 = 0 ;
    8521           0 :   int res1 = 0 ;
    8522             :   std::vector< std::string >::size_type result;
    8523           0 :   VALUE vresult = Qnil;
    8524             :   
    8525           0 :   if ((argc < 0) || (argc > 0)) {
    8526           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    8527             :   }
    8528           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8529           0 :   if (!SWIG_IsOK(res1)) {
    8530           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > const *","size", 1, self )); 
    8531             :   }
    8532           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8533           0 :   result = ((std::vector< std::string > const *)arg1)->size();
    8534           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
    8535             :   return vresult;
    8536             : fail:
    8537             :   return Qnil;
    8538             : }
    8539             : 
    8540             : 
    8541             : 
    8542             : /*
    8543             :   Document-method: Kdbtools::VectorStr.swap
    8544             : 
    8545             :   call-seq:
    8546             :     swap(VectorStr v)
    8547             : 
    8548             : An instance method.
    8549             : 
    8550             : */
    8551             : SWIGINTERN VALUE
    8552           0 : _wrap_VectorStr_swap(int argc, VALUE *argv, VALUE self) {
    8553           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8554           0 :   std::vector< std::string > *arg2 = 0 ;
    8555           0 :   void *argp1 = 0 ;
    8556           0 :   int res1 = 0 ;
    8557           0 :   void *argp2 = 0 ;
    8558           0 :   int res2 = 0 ;
    8559             :   
    8560           0 :   if ((argc < 1) || (argc > 1)) {
    8561           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    8562             :   }
    8563           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8564           0 :   if (!SWIG_IsOK(res1)) {
    8565           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","swap", 1, self )); 
    8566             :   }
    8567           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8568           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
    8569           0 :   if (!SWIG_IsOK(res2)) {
    8570           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::string > &","swap", 2, argv[0] )); 
    8571             :   }
    8572           0 :   if (!argp2) {
    8573           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string > &","swap", 2, argv[0])); 
    8574             :   }
    8575           0 :   arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
    8576           0 :   (arg1)->swap(*arg2);
    8577             :   return Qnil;
    8578             : fail:
    8579             :   return Qnil;
    8580             : }
    8581             : 
    8582             : 
    8583             : 
    8584             : /*
    8585             :   Document-method: Kdbtools::VectorStr.clear
    8586             : 
    8587             :   call-seq:
    8588             :     clear
    8589             : 
    8590             : Clear VectorStr contents.
    8591             : */
    8592             : SWIGINTERN VALUE
    8593           0 : _wrap_VectorStr_clear(int argc, VALUE *argv, VALUE self) {
    8594           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8595           0 :   void *argp1 = 0 ;
    8596           0 :   int res1 = 0 ;
    8597             :   
    8598           0 :   if ((argc < 0) || (argc > 0)) {
    8599           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    8600             :   }
    8601           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8602           0 :   if (!SWIG_IsOK(res1)) {
    8603           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","clear", 1, self )); 
    8604             :   }
    8605           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8606           0 :   (arg1)->clear();
    8607             :   return Qnil;
    8608             : fail:
    8609             :   return Qnil;
    8610             : }
    8611             : 
    8612             : 
    8613             : 
    8614             : /*
    8615             :   Document-method: Kdbtools::VectorStr.get_allocator
    8616             : 
    8617             :   call-seq:
    8618             :     get_allocator -> std::vector< std::string >::allocator_type
    8619             : 
    8620             : An instance method.
    8621             : 
    8622             : */
    8623             : SWIGINTERN VALUE
    8624           0 : _wrap_VectorStr_get_allocator(int argc, VALUE *argv, VALUE self) {
    8625           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8626           0 :   void *argp1 = 0 ;
    8627           0 :   int res1 = 0 ;
    8628           0 :   SwigValueWrapper< std::allocator< std::string > > result;
    8629           0 :   VALUE vresult = Qnil;
    8630             :   
    8631           0 :   if ((argc < 0) || (argc > 0)) {
    8632           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    8633             :   }
    8634           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8635           0 :   if (!SWIG_IsOK(res1)) {
    8636           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > const *","get_allocator", 1, self )); 
    8637             :   }
    8638           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8639           0 :   result = ((std::vector< std::string > const *)arg1)->get_allocator();
    8640           0 :   vresult = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
    8641           0 :   return vresult;
    8642             : fail:
    8643             :   return Qnil;
    8644             : }
    8645             : 
    8646             : 
    8647             : 
    8648             : /*
    8649             :   Document-method: Kdbtools::VectorStr.new
    8650             : 
    8651             :   call-seq:
    8652             :     VectorStr.new
    8653             :     VectorStr.new(VectorStr arg2)
    8654             :     VectorStr.new(std::vector< std::string >::size_type size)
    8655             :     VectorStr.new(std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value)
    8656             : 
    8657             : Class constructor.
    8658             : 
    8659             : */
    8660             : SWIGINTERN VALUE
    8661           0 : _wrap_new_VectorStr__SWIG_2(int argc, VALUE *argv, VALUE self) {
    8662             :   std::vector< std::string >::size_type arg1 ;
    8663             :   size_t val1 ;
    8664           0 :   int ecode1 = 0 ;
    8665           0 :   std::vector< std::string > *result = 0 ;
    8666             :   
    8667           0 :   if ((argc < 1) || (argc > 1)) {
    8668           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    8669             :   }
    8670           0 :   ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
    8671           0 :   if (!SWIG_IsOK(ecode1)) {
    8672           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "std::vector< std::string >::size_type","vector<(std::string)>", 1, argv[0] ));
    8673             :   } 
    8674           0 :   arg1 = static_cast< std::vector< std::string >::size_type >(val1);
    8675           0 :   result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
    8676           0 :   DATA_PTR(self) = result;
    8677             :   return self;
    8678             : fail:
    8679             :   return Qnil;
    8680             : }
    8681             : 
    8682             : 
    8683             : 
    8684             : /*
    8685             :   Document-method: Kdbtools::VectorStr.resize
    8686             : 
    8687             :   call-seq:
    8688             :     resize(new_size)
    8689             :     resize(new_size, x)
    8690             : 
    8691             : Resize the size of the VectorStr.
    8692             : */
    8693             : SWIGINTERN VALUE
    8694           0 : _wrap_VectorStr_resize__SWIG_0(int argc, VALUE *argv, VALUE self) {
    8695           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8696             :   std::vector< std::string >::size_type arg2 ;
    8697           0 :   void *argp1 = 0 ;
    8698           0 :   int res1 = 0 ;
    8699             :   size_t val2 ;
    8700           0 :   int ecode2 = 0 ;
    8701             :   
    8702           0 :   if ((argc < 1) || (argc > 1)) {
    8703           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    8704             :   }
    8705           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8706           0 :   if (!SWIG_IsOK(res1)) {
    8707           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","resize", 1, self )); 
    8708             :   }
    8709           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8710           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
    8711           0 :   if (!SWIG_IsOK(ecode2)) {
    8712           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::size_type","resize", 2, argv[0] ));
    8713             :   } 
    8714           0 :   arg2 = static_cast< std::vector< std::string >::size_type >(val2);
    8715           0 :   (arg1)->resize(arg2);
    8716             :   return Qnil;
    8717             : fail:
    8718             :   return Qnil;
    8719             : }
    8720             : 
    8721             : 
    8722             : SWIGINTERN VALUE
    8723             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
    8724           0 : _wrap_VectorStr_allocate(VALUE self)
    8725             : #else
    8726             : _wrap_VectorStr_allocate(int argc, VALUE *argv, VALUE self)
    8727             : #endif
    8728             : {
    8729           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t);
    8730             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    8731             :   rb_obj_call_init(vresult, argc, argv);
    8732             : #endif
    8733           0 :   return vresult;
    8734             : }
    8735             : 
    8736             : 
    8737             : 
    8738             : /*
    8739             :   Document-method: Kdbtools::VectorStr.new
    8740             : 
    8741             :   call-seq:
    8742             :     VectorStr.new
    8743             :     VectorStr.new(VectorStr arg2)
    8744             :     VectorStr.new(std::vector< std::string >::size_type size)
    8745             :     VectorStr.new(std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value)
    8746             : 
    8747             : Class constructor.
    8748             : 
    8749             : */
    8750             : SWIGINTERN VALUE
    8751           0 : _wrap_new_VectorStr__SWIG_3(int argc, VALUE *argv, VALUE self) {
    8752             :   std::vector< std::string >::size_type arg1 ;
    8753           0 :   std::vector< std::string >::value_type *arg2 = 0 ;
    8754             :   size_t val1 ;
    8755           0 :   int ecode1 = 0 ;
    8756           0 :   int res2 = SWIG_OLDOBJ ;
    8757           0 :   std::vector< std::string > *result = 0 ;
    8758             :   
    8759           0 :   if ((argc < 2) || (argc > 2)) {
    8760           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
    8761             :   }
    8762           0 :   ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
    8763           0 :   if (!SWIG_IsOK(ecode1)) {
    8764           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "std::vector< std::string >::size_type","vector<(std::string)>", 1, argv[0] ));
    8765             :   } 
    8766           0 :   arg1 = static_cast< std::vector< std::string >::size_type >(val1);
    8767             :   {
    8768           0 :     std::string *ptr = (std::string *)0;
    8769           0 :     res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    8770           0 :     if (!SWIG_IsOK(res2)) {
    8771           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::string >::value_type const &","vector<(std::string)>", 2, argv[1] )); 
    8772             :     }
    8773           0 :     if (!ptr) {
    8774           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string >::value_type const &","vector<(std::string)>", 2, argv[1])); 
    8775             :     }
    8776           0 :     arg2 = ptr;
    8777             :   }
    8778           0 :   result = (std::vector< std::string > *)new std::vector< std::string >(arg1,(std::vector< std::string >::value_type const &)*arg2);
    8779           0 :   DATA_PTR(self) = result;
    8780           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    8781             :   return self;
    8782             : fail:
    8783             :   if (SWIG_IsNewObj(res2)) delete arg2;
    8784             :   return Qnil;
    8785             : }
    8786             : 
    8787             : 
    8788           0 : SWIGINTERN VALUE _wrap_new_VectorStr(int nargs, VALUE *args, VALUE self) {
    8789             :   int argc;
    8790             :   VALUE argv[2];
    8791             :   int ii;
    8792             :   
    8793           0 :   argc = nargs;
    8794           0 :   if (argc > 2) SWIG_fail;
    8795           0 :   for (ii = 0; (ii < argc); ++ii) {
    8796           0 :     argv[ii] = args[ii];
    8797             :   }
    8798           0 :   if (argc == 0) {
    8799           0 :     return _wrap_new_VectorStr__SWIG_0(nargs, args, self);
    8800             :   }
    8801           0 :   if (argc == 1) {
    8802           0 :     int _v = 0;
    8803             :     {
    8804             :       {
    8805           0 :         int res = SWIG_AsVal_size_t(argv[0], NULL);
    8806           0 :         _v = SWIG_CheckState(res);
    8807             :       }
    8808             :     }
    8809           0 :     if (!_v) goto check_2;
    8810           0 :     return _wrap_new_VectorStr__SWIG_2(nargs, args, self);
    8811             :   }
    8812             : check_2:
    8813             :   
    8814           0 :   if (argc == 1) {
    8815           0 :     return _wrap_new_VectorStr__SWIG_1(nargs, args, self);
    8816             :   }
    8817           0 :   if (argc == 2) {
    8818           0 :     return _wrap_new_VectorStr__SWIG_3(nargs, args, self);
    8819             :   }
    8820             :   
    8821             : fail:
    8822             :   Ruby_Format_OverloadedError( argc, 2, "VectorStr.new", 
    8823             :     "    VectorStr.new()\n"
    8824             :     "    VectorStr.new(std::vector< std::string > const &)\n"
    8825             :     "    VectorStr.new(std::vector< std::string >::size_type size)\n"
    8826           0 :     "    VectorStr.new(std::vector< std::string >::size_type size, std::vector< std::string >::value_type const &value)\n");
    8827             :   
    8828             :   return Qnil;
    8829             : }
    8830             : 
    8831             : 
    8832             : 
    8833             : /*
    8834             :   Document-method: Kdbtools::VectorStr.front
    8835             : 
    8836             :   call-seq:
    8837             :     front -> std::vector< std::string >::value_type const &
    8838             : 
    8839             : Return the first element in VectorStr.
    8840             : */
    8841             : SWIGINTERN VALUE
    8842           0 : _wrap_VectorStr_front(int argc, VALUE *argv, VALUE self) {
    8843           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8844           0 :   void *argp1 = 0 ;
    8845           0 :   int res1 = 0 ;
    8846           0 :   std::vector< std::string >::value_type *result = 0 ;
    8847           0 :   VALUE vresult = Qnil;
    8848             :   
    8849           0 :   if ((argc < 0) || (argc > 0)) {
    8850           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    8851             :   }
    8852           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8853           0 :   if (!SWIG_IsOK(res1)) {
    8854           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > const *","front", 1, self )); 
    8855             :   }
    8856           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8857           0 :   result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->front();
    8858           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
    8859             :   return vresult;
    8860             : fail:
    8861             :   return Qnil;
    8862             : }
    8863             : 
    8864             : 
    8865             : 
    8866             : /*
    8867             :   Document-method: Kdbtools::VectorStr.back
    8868             : 
    8869             :   call-seq:
    8870             :     back -> std::vector< std::string >::value_type const &
    8871             : 
    8872             : Return the last element in VectorStr.
    8873             : */
    8874             : SWIGINTERN VALUE
    8875           0 : _wrap_VectorStr_back(int argc, VALUE *argv, VALUE self) {
    8876           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8877           0 :   void *argp1 = 0 ;
    8878           0 :   int res1 = 0 ;
    8879           0 :   std::vector< std::string >::value_type *result = 0 ;
    8880           0 :   VALUE vresult = Qnil;
    8881             :   
    8882           0 :   if ((argc < 0) || (argc > 0)) {
    8883           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    8884             :   }
    8885           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8886           0 :   if (!SWIG_IsOK(res1)) {
    8887           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > const *","back", 1, self )); 
    8888             :   }
    8889           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8890           0 :   result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->back();
    8891           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
    8892             :   return vresult;
    8893             : fail:
    8894             :   return Qnil;
    8895             : }
    8896             : 
    8897             : 
    8898             : 
    8899             : /*
    8900             :   Document-method: Kdbtools::VectorStr.assign
    8901             : 
    8902             :   call-seq:
    8903             :     assign(n, x)
    8904             : 
    8905             : Assign a new VectorStr or portion of it.
    8906             : */
    8907             : SWIGINTERN VALUE
    8908           0 : _wrap_VectorStr_assign(int argc, VALUE *argv, VALUE self) {
    8909           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8910             :   std::vector< std::string >::size_type arg2 ;
    8911           0 :   std::vector< std::string >::value_type *arg3 = 0 ;
    8912           0 :   void *argp1 = 0 ;
    8913           0 :   int res1 = 0 ;
    8914             :   size_t val2 ;
    8915           0 :   int ecode2 = 0 ;
    8916           0 :   int res3 = SWIG_OLDOBJ ;
    8917             :   
    8918           0 :   if ((argc < 2) || (argc > 2)) {
    8919           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
    8920             :   }
    8921           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8922           0 :   if (!SWIG_IsOK(res1)) {
    8923           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","assign", 1, self )); 
    8924             :   }
    8925           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8926           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
    8927           0 :   if (!SWIG_IsOK(ecode2)) {
    8928           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::size_type","assign", 2, argv[0] ));
    8929             :   } 
    8930           0 :   arg2 = static_cast< std::vector< std::string >::size_type >(val2);
    8931             :   {
    8932           0 :     std::string *ptr = (std::string *)0;
    8933           0 :     res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    8934           0 :     if (!SWIG_IsOK(res3)) {
    8935           0 :       SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< std::string >::value_type const &","assign", 3, argv[1] )); 
    8936             :     }
    8937           0 :     if (!ptr) {
    8938           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string >::value_type const &","assign", 3, argv[1])); 
    8939             :     }
    8940           0 :     arg3 = ptr;
    8941             :   }
    8942           0 :   (arg1)->assign(arg2,(std::vector< std::string >::value_type const &)*arg3);
    8943           0 :   if (SWIG_IsNewObj(res3)) delete arg3;
    8944             :   return Qnil;
    8945             : fail:
    8946             :   if (SWIG_IsNewObj(res3)) delete arg3;
    8947             :   return Qnil;
    8948             : }
    8949             : 
    8950             : 
    8951             : 
    8952             : /*
    8953             :   Document-method: Kdbtools::VectorStr.resize
    8954             : 
    8955             :   call-seq:
    8956             :     resize(new_size)
    8957             :     resize(new_size, x)
    8958             : 
    8959             : Resize the size of the VectorStr.
    8960             : */
    8961             : SWIGINTERN VALUE
    8962           0 : _wrap_VectorStr_resize__SWIG_1(int argc, VALUE *argv, VALUE self) {
    8963           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    8964             :   std::vector< std::string >::size_type arg2 ;
    8965           0 :   std::vector< std::string >::value_type *arg3 = 0 ;
    8966           0 :   void *argp1 = 0 ;
    8967           0 :   int res1 = 0 ;
    8968             :   size_t val2 ;
    8969           0 :   int ecode2 = 0 ;
    8970           0 :   int res3 = SWIG_OLDOBJ ;
    8971             :   
    8972           0 :   if ((argc < 2) || (argc > 2)) {
    8973           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
    8974             :   }
    8975           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    8976           0 :   if (!SWIG_IsOK(res1)) {
    8977           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","resize", 1, self )); 
    8978             :   }
    8979           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    8980           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
    8981           0 :   if (!SWIG_IsOK(ecode2)) {
    8982           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::size_type","resize", 2, argv[0] ));
    8983             :   } 
    8984           0 :   arg2 = static_cast< std::vector< std::string >::size_type >(val2);
    8985             :   {
    8986           0 :     std::string *ptr = (std::string *)0;
    8987           0 :     res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
    8988           0 :     if (!SWIG_IsOK(res3)) {
    8989           0 :       SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< std::string >::value_type const &","resize", 3, argv[1] )); 
    8990             :     }
    8991           0 :     if (!ptr) {
    8992           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string >::value_type const &","resize", 3, argv[1])); 
    8993             :     }
    8994           0 :     arg3 = ptr;
    8995             :   }
    8996           0 :   (arg1)->resize(arg2,(std::vector< std::string >::value_type const &)*arg3);
    8997           0 :   if (SWIG_IsNewObj(res3)) delete arg3;
    8998             :   return Qnil;
    8999             : fail:
    9000             :   if (SWIG_IsNewObj(res3)) delete arg3;
    9001             :   return Qnil;
    9002             : }
    9003             : 
    9004             : 
    9005           0 : SWIGINTERN VALUE _wrap_VectorStr_resize(int nargs, VALUE *args, VALUE self) {
    9006             :   int argc;
    9007             :   VALUE argv[4];
    9008             :   int ii;
    9009             :   
    9010           0 :   argc = nargs + 1;
    9011             :   argv[0] = self;
    9012           0 :   if (argc > 4) SWIG_fail;
    9013             :   for (ii = 1; (ii < argc); ++ii) {
    9014             :     argv[ii] = args[ii-1];
    9015             :   }
    9016           0 :   if (argc == 2) {
    9017           0 :     return _wrap_VectorStr_resize__SWIG_0(nargs, args, self);
    9018             :   }
    9019           0 :   if (argc == 3) {
    9020           0 :     return _wrap_VectorStr_resize__SWIG_1(nargs, args, self);
    9021             :   }
    9022             :   
    9023             : fail:
    9024             :   Ruby_Format_OverloadedError( argc, 4, "VectorStr.resize", 
    9025             :     "    void VectorStr.resize(std::vector< std::string >::size_type new_size)\n"
    9026           0 :     "    void VectorStr.resize(std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const &x)\n");
    9027             :   
    9028             :   return Qnil;
    9029             : }
    9030             : 
    9031             : 
    9032             : 
    9033             : /*
    9034             :   Document-method: Kdbtools::VectorStr.reserve
    9035             : 
    9036             :   call-seq:
    9037             :     reserve(n)
    9038             : 
    9039             : Reserve memory in the VectorStr for a number of elements.
    9040             : */
    9041             : SWIGINTERN VALUE
    9042           0 : _wrap_VectorStr_reserve(int argc, VALUE *argv, VALUE self) {
    9043           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    9044             :   std::vector< std::string >::size_type arg2 ;
    9045           0 :   void *argp1 = 0 ;
    9046           0 :   int res1 = 0 ;
    9047             :   size_t val2 ;
    9048           0 :   int ecode2 = 0 ;
    9049             :   
    9050           0 :   if ((argc < 1) || (argc > 1)) {
    9051           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    9052             :   }
    9053           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    9054           0 :   if (!SWIG_IsOK(res1)) {
    9055           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","reserve", 1, self )); 
    9056             :   }
    9057           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    9058           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
    9059           0 :   if (!SWIG_IsOK(ecode2)) {
    9060           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::string >::size_type","reserve", 2, argv[0] ));
    9061             :   } 
    9062           0 :   arg2 = static_cast< std::vector< std::string >::size_type >(val2);
    9063           0 :   (arg1)->reserve(arg2);
    9064             :   return Qnil;
    9065             : fail:
    9066             :   return Qnil;
    9067             : }
    9068             : 
    9069             : 
    9070             : 
    9071             : /*
    9072             :   Document-method: Kdbtools::VectorStr.capacity
    9073             : 
    9074             :   call-seq:
    9075             :     capacity -> std::vector< std::string >::size_type
    9076             : 
    9077             : Reserved capacity of the VectorStr.
    9078             : */
    9079             : SWIGINTERN VALUE
    9080           0 : _wrap_VectorStr_capacity(int argc, VALUE *argv, VALUE self) {
    9081           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    9082           0 :   void *argp1 = 0 ;
    9083           0 :   int res1 = 0 ;
    9084             :   std::vector< std::string >::size_type result;
    9085           0 :   VALUE vresult = Qnil;
    9086             :   
    9087           0 :   if ((argc < 0) || (argc > 0)) {
    9088           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9089             :   }
    9090           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    9091           0 :   if (!SWIG_IsOK(res1)) {
    9092           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > const *","capacity", 1, self )); 
    9093             :   }
    9094           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    9095           0 :   result = ((std::vector< std::string > const *)arg1)->capacity();
    9096           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
    9097             :   return vresult;
    9098             : fail:
    9099             :   return Qnil;
    9100             : }
    9101             : 
    9102             : 
    9103             : 
    9104             : /*
    9105             :   Document-method: Kdbtools::VectorStr.map_bang
    9106             : 
    9107             :   call-seq:
    9108             :     map_bang -> VectorStr
    9109             : 
    9110             : An instance method.
    9111             : 
    9112             : */
    9113             : SWIGINTERN VALUE
    9114           0 : _wrap_VectorStr_map_bang(int argc, VALUE *argv, VALUE self) {
    9115           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    9116           0 :   void *argp1 = 0 ;
    9117           0 :   int res1 = 0 ;
    9118           0 :   std::vector< std::string,std::allocator< std::string > > *result = 0 ;
    9119           0 :   VALUE vresult = Qnil;
    9120             :   
    9121           0 :   if ((argc < 0) || (argc > 0)) {
    9122           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9123             :   }
    9124           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    9125           0 :   if (!SWIG_IsOK(res1)) {
    9126           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","map_bang", 1, self )); 
    9127             :   }
    9128           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    9129           0 :   result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg__map_bang(arg1);
    9130           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    9131             :   return vresult;
    9132             : fail:
    9133             :   return Qnil;
    9134             : }
    9135             : 
    9136             : 
    9137             : 
    9138             : /*
    9139             :   Document-method: Kdbtools::VectorStr.__delete__
    9140             : 
    9141             :   call-seq:
    9142             :     __delete__(val) -> VALUE
    9143             : 
    9144             : Delete a matching element.
    9145             : */
    9146             : SWIGINTERN VALUE
    9147           0 : _wrap_VectorStr___delete__(int argc, VALUE *argv, VALUE self) {
    9148           0 :   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
    9149           0 :   std::string *arg2 = 0 ;
    9150           0 :   void *argp1 = 0 ;
    9151           0 :   int res1 = 0 ;
    9152           0 :   int res2 = SWIG_OLDOBJ ;
    9153             :   VALUE result;
    9154           0 :   VALUE vresult = Qnil;
    9155             :   
    9156           0 :   if ((argc < 1) || (argc > 1)) {
    9157           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    9158             :   }
    9159           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
    9160           0 :   if (!SWIG_IsOK(res1)) {
    9161           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::string > *","__delete__", 1, self )); 
    9162             :   }
    9163           0 :   arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
    9164             :   {
    9165           0 :     std::string *ptr = (std::string *)0;
    9166           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    9167           0 :     if (!SWIG_IsOK(res2)) {
    9168           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","__delete__", 2, argv[0] )); 
    9169             :     }
    9170           0 :     if (!ptr) {
    9171           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","__delete__", 2, argv[0])); 
    9172             :     }
    9173           0 :     arg2 = ptr;
    9174             :   }
    9175           0 :   result = (VALUE)std_vector_Sl_std_string_Sg____delete__(arg1,(std::string const &)*arg2);
    9176           0 :   vresult = result;
    9177           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    9178             :   return vresult;
    9179             : fail:
    9180             :   if (SWIG_IsNewObj(res2)) delete arg2;
    9181             :   return Qnil;
    9182             : }
    9183             : 
    9184             : 
    9185             : SWIGINTERN void
    9186           0 : free_std_vector_Sl_std_string_Sg_(void *self) {
    9187           0 :     std::vector< std::string > *arg1 = (std::vector< std::string > *)self;
    9188           0 :     delete arg1;
    9189           0 : }
    9190             : 
    9191             : 
    9192             : /*
    9193             :   Document-class: Kdbtools::ToolException
    9194             : 
    9195             :   Proxy of C++ Kdbtools::ToolException class
    9196             : 
    9197             : 
    9198             : */
    9199             : static swig_class SwigClassToolException;
    9200             : 
    9201             : 
    9202             : /*
    9203             :   Document-method: Kdbtools::ToolException.new
    9204             : 
    9205             :   call-seq:
    9206             :     ToolException.new
    9207             :     ToolException.new(std::string message)
    9208             : 
    9209             : Class constructor.
    9210             : 
    9211             : */
    9212             : SWIGINTERN VALUE
    9213           0 : _wrap_new_ToolException__SWIG_0(int argc, VALUE *argv, VALUE self) {
    9214           0 :   kdb::tools::ToolException *result = 0 ;
    9215             :   
    9216           0 :   if ((argc < 0) || (argc > 0)) {
    9217           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9218             :   }
    9219           0 :   result = (kdb::tools::ToolException *)new kdb::tools::ToolException();
    9220           0 :   DATA_PTR(self) = result;
    9221             :   return self;
    9222             : fail:
    9223             :   return Qnil;
    9224             : }
    9225             : 
    9226             : 
    9227             : SWIGINTERN VALUE
    9228             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
    9229           0 : _wrap_ToolException_allocate(VALUE self)
    9230             : #else
    9231             : _wrap_ToolException_allocate(int argc, VALUE *argv, VALUE self)
    9232             : #endif
    9233             : {
    9234           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__ToolException);
    9235             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    9236             :   rb_obj_call_init(vresult, argc, argv);
    9237             : #endif
    9238           0 :   return vresult;
    9239             : }
    9240             : 
    9241             : 
    9242             : SWIGINTERN VALUE
    9243           0 : _wrap_new_ToolException__SWIG_1(int argc, VALUE *argv, VALUE self) {
    9244           0 :   std::string arg1 ;
    9245           0 :   kdb::tools::ToolException *result = 0 ;
    9246             :   
    9247           0 :   if ((argc < 1) || (argc > 1)) {
    9248           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    9249             :   }
    9250             :   {
    9251           0 :     std::string *ptr = (std::string *)0;
    9252           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    9253           0 :     if (!SWIG_IsOK(res) || !ptr) {
    9254           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","ToolException", 1, argv[0] )); 
    9255             :     }
    9256           0 :     arg1 = *ptr;
    9257           0 :     if (SWIG_IsNewObj(res)) delete ptr;
    9258             :   }
    9259           0 :   result = (kdb::tools::ToolException *)new kdb::tools::ToolException(arg1);
    9260           0 :   DATA_PTR(self) = result;
    9261           0 :   return self;
    9262             : fail:
    9263             :   return Qnil;
    9264             : }
    9265             : 
    9266             : 
    9267           0 : SWIGINTERN VALUE _wrap_new_ToolException(int nargs, VALUE *args, VALUE self) {
    9268             :   int argc;
    9269             :   VALUE argv[1];
    9270             :   int ii;
    9271             :   
    9272           0 :   argc = nargs;
    9273           0 :   if (argc > 1) SWIG_fail;
    9274             :   for (ii = 0; (ii < argc); ++ii) {
    9275             :     argv[ii] = args[ii];
    9276             :   }
    9277           0 :   if (argc == 0) {
    9278           0 :     return _wrap_new_ToolException__SWIG_0(nargs, args, self);
    9279             :   }
    9280           0 :   if (argc == 1) {
    9281           0 :     return _wrap_new_ToolException__SWIG_1(nargs, args, self);
    9282             :   }
    9283             :   
    9284             : fail:
    9285             :   Ruby_Format_OverloadedError( argc, 1, "ToolException.new", 
    9286             :     "    ToolException.new()\n"
    9287           0 :     "    ToolException.new(std::string message)\n");
    9288             :   
    9289             :   return Qnil;
    9290             : }
    9291             : 
    9292             : 
    9293             : SWIGINTERN void
    9294           0 : free_kdb_tools_ToolException(void *self) {
    9295           0 :     kdb::tools::ToolException *arg1 = (kdb::tools::ToolException *)self;
    9296           0 :     delete arg1;
    9297           0 : }
    9298             : 
    9299             : 
    9300             : /*
    9301             :   Document-class: Kdbtools::ParseException < Kdbtools::kdb::tools::ToolException
    9302             : 
    9303             :   Proxy of C++ Kdbtools::ParseException class
    9304             : 
    9305             : 
    9306             : */
    9307             : static swig_class SwigClassParseException;
    9308             : 
    9309             : SWIGINTERN VALUE
    9310             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
    9311           0 : _wrap_ParseException_allocate(VALUE self)
    9312             : #else
    9313             : _wrap_ParseException_allocate(int argc, VALUE *argv, VALUE self)
    9314             : #endif
    9315             : {
    9316           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__ParseException);
    9317             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    9318             :   rb_obj_call_init(vresult, argc, argv);
    9319             : #endif
    9320           0 :   return vresult;
    9321             : }
    9322             : 
    9323             : 
    9324             : 
    9325             : /*
    9326             :   Document-method: Kdbtools::ParseException.new
    9327             : 
    9328             :   call-seq:
    9329             :     ParseException.new(std::string str)
    9330             : 
    9331             : Class constructor.
    9332             : 
    9333             : */
    9334             : SWIGINTERN VALUE
    9335           0 : _wrap_new_ParseException(int argc, VALUE *argv, VALUE self) {
    9336           0 :   std::string arg1 ;
    9337           0 :   kdb::tools::ParseException *result = 0 ;
    9338             :   
    9339           0 :   if ((argc < 1) || (argc > 1)) {
    9340           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    9341             :   }
    9342             :   {
    9343           0 :     std::string *ptr = (std::string *)0;
    9344           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    9345           0 :     if (!SWIG_IsOK(res) || !ptr) {
    9346           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","ParseException", 1, argv[0] )); 
    9347             :     }
    9348           0 :     arg1 = *ptr;
    9349           0 :     if (SWIG_IsNewObj(res)) delete ptr;
    9350             :   }
    9351           0 :   result = (kdb::tools::ParseException *)new kdb::tools::ParseException(arg1);
    9352           0 :   DATA_PTR(self) = result;
    9353           0 :   return self;
    9354             : fail:
    9355             :   return Qnil;
    9356             : }
    9357             : 
    9358             : 
    9359             : SWIGINTERN void
    9360           1 : free_kdb_tools_ParseException(void *self) {
    9361           1 :     kdb::tools::ParseException *arg1 = (kdb::tools::ParseException *)self;
    9362           1 :     delete arg1;
    9363           1 : }
    9364             : 
    9365             : 
    9366             : /*
    9367             :   Document-method: Kdbtools::ParseException.to_s
    9368             : 
    9369             :   call-seq:
    9370             :     to_s -> char const *
    9371             : 
    9372             : An instance method.
    9373             : 
    9374             : */
    9375             : SWIGINTERN VALUE
    9376           0 : _wrap_ParseException_to_s(int argc, VALUE *argv, VALUE self) {
    9377           0 :   kdb::tools::ParseException *arg1 = (kdb::tools::ParseException *) 0 ;
    9378           0 :   void *argp1 = 0 ;
    9379           0 :   int res1 = 0 ;
    9380           0 :   char *result = 0 ;
    9381           0 :   VALUE vresult = Qnil;
    9382             :   
    9383           0 :   if ((argc < 0) || (argc > 0)) {
    9384           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9385             :   }
    9386           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ParseException, 0 |  0 );
    9387           0 :   if (!SWIG_IsOK(res1)) {
    9388           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ParseException const *","what", 1, self )); 
    9389             :   }
    9390           0 :   arg1 = reinterpret_cast< kdb::tools::ParseException * >(argp1);
    9391           0 :   result = (char *)((kdb::tools::ParseException const *)arg1)->what();
    9392           0 :   vresult = SWIG_FromCharPtr((const char *)result);
    9393             :   return vresult;
    9394             : fail:
    9395             :   return Qnil;
    9396             : }
    9397             : 
    9398             : 
    9399             : 
    9400             : /*
    9401             :   Document-method: Kdbtools::ParseException.m_str
    9402             : 
    9403             :   call-seq:
    9404             :     m_str -> std::string
    9405             : 
    9406             : Get value of attribute.
    9407             : 
    9408             : */
    9409             : 
    9410             : /*
    9411             :   Document-method: Kdbtools::ParseException.m_str=
    9412             : 
    9413             :   call-seq:
    9414             :     m_str=(x) -> std::string
    9415             : 
    9416             : Set new value for attribute.
    9417             : 
    9418             : */
    9419             : SWIGINTERN VALUE
    9420           0 : _wrap_ParseException_m_str_set(int argc, VALUE *argv, VALUE self) {
    9421           0 :   kdb::tools::ParseException *arg1 = (kdb::tools::ParseException *) 0 ;
    9422           0 :   std::string *arg2 = 0 ;
    9423           0 :   void *argp1 = 0 ;
    9424           0 :   int res1 = 0 ;
    9425           0 :   int res2 = SWIG_OLDOBJ ;
    9426             :   
    9427           0 :   if ((argc < 1) || (argc > 1)) {
    9428           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    9429             :   }
    9430           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ParseException, 0 |  0 );
    9431           0 :   if (!SWIG_IsOK(res1)) {
    9432           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ParseException *","m_str", 1, self )); 
    9433             :   }
    9434           0 :   arg1 = reinterpret_cast< kdb::tools::ParseException * >(argp1);
    9435             :   {
    9436           0 :     std::string *ptr = (std::string *)0;
    9437           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    9438           0 :     if (!SWIG_IsOK(res2)) {
    9439           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","m_str", 2, argv[0] )); 
    9440             :     }
    9441           0 :     if (!ptr) {
    9442           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","m_str", 2, argv[0])); 
    9443             :     }
    9444           0 :     arg2 = ptr;
    9445             :   }
    9446           0 :   if (arg1) (arg1)->m_str = *arg2;
    9447           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    9448             :   return Qnil;
    9449             : fail:
    9450             :   if (SWIG_IsNewObj(res2)) delete arg2;
    9451             :   return Qnil;
    9452             : }
    9453             : 
    9454             : 
    9455             : SWIGINTERN VALUE
    9456           0 : _wrap_ParseException_m_str_get(int argc, VALUE *argv, VALUE self) {
    9457           0 :   kdb::tools::ParseException *arg1 = (kdb::tools::ParseException *) 0 ;
    9458           0 :   void *argp1 = 0 ;
    9459           0 :   int res1 = 0 ;
    9460           0 :   std::string *result = 0 ;
    9461           0 :   VALUE vresult = Qnil;
    9462             :   
    9463           0 :   if ((argc < 0) || (argc > 0)) {
    9464           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9465             :   }
    9466           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ParseException, 0 |  0 );
    9467           0 :   if (!SWIG_IsOK(res1)) {
    9468           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ParseException *","m_str", 1, self )); 
    9469             :   }
    9470           0 :   arg1 = reinterpret_cast< kdb::tools::ParseException * >(argp1);
    9471           0 :   result = (std::string *) & ((arg1)->m_str);
    9472           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
    9473             :   return vresult;
    9474             : fail:
    9475             :   return Qnil;
    9476             : }
    9477             : 
    9478             : 
    9479             : 
    9480             : /*
    9481             :   Document-class: Kdbtools::PluginCheckException < Kdbtools::kdb::tools::ToolException
    9482             : 
    9483             :   Proxy of C++ Kdbtools::PluginCheckException class
    9484             : 
    9485             : 
    9486             : */
    9487             : static swig_class SwigClassPluginCheckException;
    9488             : 
    9489             : 
    9490             : /*
    9491             :   Document-method: Kdbtools::PluginCheckException.to_s
    9492             : 
    9493             :   call-seq:
    9494             :     to_s -> char const *
    9495             : 
    9496             : An instance method.
    9497             : 
    9498             : */
    9499             : SWIGINTERN VALUE
    9500           0 : _wrap_PluginCheckException_to_s(int argc, VALUE *argv, VALUE self) {
    9501           0 :   kdb::tools::PluginCheckException *arg1 = (kdb::tools::PluginCheckException *) 0 ;
    9502           0 :   void *argp1 = 0 ;
    9503           0 :   int res1 = 0 ;
    9504           0 :   char *result = 0 ;
    9505           0 :   VALUE vresult = Qnil;
    9506             :   
    9507           0 :   if ((argc < 0) || (argc > 0)) {
    9508           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9509             :   }
    9510           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginCheckException, 0 |  0 );
    9511           0 :   if (!SWIG_IsOK(res1)) {
    9512           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginCheckException const *","what", 1, self )); 
    9513             :   }
    9514           0 :   arg1 = reinterpret_cast< kdb::tools::PluginCheckException * >(argp1);
    9515           0 :   result = (char *)((kdb::tools::PluginCheckException const *)arg1)->what();
    9516           0 :   vresult = SWIG_FromCharPtr((const char *)result);
    9517             :   return vresult;
    9518             : fail:
    9519             :   return Qnil;
    9520             : }
    9521             : 
    9522             : 
    9523             : SWIGINTERN VALUE
    9524             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
    9525           0 : _wrap_PluginCheckException_allocate(VALUE self)
    9526             : #else
    9527             : _wrap_PluginCheckException_allocate(int argc, VALUE *argv, VALUE self)
    9528             : #endif
    9529             : {
    9530           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__PluginCheckException);
    9531             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    9532             :   rb_obj_call_init(vresult, argc, argv);
    9533             : #endif
    9534           0 :   return vresult;
    9535             : }
    9536             : 
    9537             : 
    9538             : 
    9539             : /*
    9540             :   Document-method: Kdbtools::PluginCheckException.new
    9541             : 
    9542             :   call-seq:
    9543             :     PluginCheckException.new
    9544             : 
    9545             : Class constructor.
    9546             : 
    9547             : */
    9548             : SWIGINTERN VALUE
    9549           0 : _wrap_new_PluginCheckException(int argc, VALUE *argv, VALUE self) {
    9550           0 :   kdb::tools::PluginCheckException *result = 0 ;
    9551             :   
    9552           0 :   if ((argc < 0) || (argc > 0)) {
    9553           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9554             :   }
    9555           0 :   result = (kdb::tools::PluginCheckException *)new kdb::tools::PluginCheckException();
    9556           0 :   DATA_PTR(self) = result;
    9557             :   return self;
    9558             : fail:
    9559             :   return Qnil;
    9560             : }
    9561             : 
    9562             : 
    9563             : SWIGINTERN void
    9564           0 : free_kdb_tools_PluginCheckException(void *self) {
    9565           0 :     kdb::tools::PluginCheckException *arg1 = (kdb::tools::PluginCheckException *)self;
    9566           0 :     delete arg1;
    9567           0 : }
    9568             : 
    9569             : 
    9570             : /*
    9571             :   Document-class: Kdbtools::BackendCheckException < Kdbtools::kdb::tools::ToolException
    9572             : 
    9573             :   Proxy of C++ Kdbtools::BackendCheckException class
    9574             : 
    9575             : 
    9576             : */
    9577             : static swig_class SwigClassBackendCheckException;
    9578             : 
    9579             : 
    9580             : /*
    9581             :   Document-method: Kdbtools::BackendCheckException.to_s
    9582             : 
    9583             :   call-seq:
    9584             :     to_s -> char const *
    9585             : 
    9586             : An instance method.
    9587             : 
    9588             : */
    9589             : SWIGINTERN VALUE
    9590           0 : _wrap_BackendCheckException_to_s(int argc, VALUE *argv, VALUE self) {
    9591           0 :   kdb::tools::BackendCheckException *arg1 = (kdb::tools::BackendCheckException *) 0 ;
    9592           0 :   void *argp1 = 0 ;
    9593           0 :   int res1 = 0 ;
    9594           0 :   char *result = 0 ;
    9595           0 :   VALUE vresult = Qnil;
    9596             :   
    9597           0 :   if ((argc < 0) || (argc > 0)) {
    9598           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9599             :   }
    9600           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendCheckException, 0 |  0 );
    9601           0 :   if (!SWIG_IsOK(res1)) {
    9602           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendCheckException const *","what", 1, self )); 
    9603             :   }
    9604           0 :   arg1 = reinterpret_cast< kdb::tools::BackendCheckException * >(argp1);
    9605           0 :   result = (char *)((kdb::tools::BackendCheckException const *)arg1)->what();
    9606           0 :   vresult = SWIG_FromCharPtr((const char *)result);
    9607             :   return vresult;
    9608             : fail:
    9609             :   return Qnil;
    9610             : }
    9611             : 
    9612             : 
    9613             : SWIGINTERN VALUE
    9614             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
    9615           0 : _wrap_BackendCheckException_allocate(VALUE self)
    9616             : #else
    9617             : _wrap_BackendCheckException_allocate(int argc, VALUE *argv, VALUE self)
    9618             : #endif
    9619             : {
    9620           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__BackendCheckException);
    9621             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    9622             :   rb_obj_call_init(vresult, argc, argv);
    9623             : #endif
    9624           0 :   return vresult;
    9625             : }
    9626             : 
    9627             : 
    9628             : 
    9629             : /*
    9630             :   Document-method: Kdbtools::BackendCheckException.new
    9631             : 
    9632             :   call-seq:
    9633             :     BackendCheckException.new
    9634             : 
    9635             : Class constructor.
    9636             : 
    9637             : */
    9638             : SWIGINTERN VALUE
    9639           0 : _wrap_new_BackendCheckException(int argc, VALUE *argv, VALUE self) {
    9640           0 :   kdb::tools::BackendCheckException *result = 0 ;
    9641             :   
    9642           0 :   if ((argc < 0) || (argc > 0)) {
    9643           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9644             :   }
    9645           0 :   result = (kdb::tools::BackendCheckException *)new kdb::tools::BackendCheckException();
    9646           0 :   DATA_PTR(self) = result;
    9647             :   return self;
    9648             : fail:
    9649             :   return Qnil;
    9650             : }
    9651             : 
    9652             : 
    9653             : SWIGINTERN void
    9654           0 : free_kdb_tools_BackendCheckException(void *self) {
    9655           0 :     kdb::tools::BackendCheckException *arg1 = (kdb::tools::BackendCheckException *)self;
    9656           0 :     delete arg1;
    9657           0 : }
    9658             : 
    9659             : 
    9660             : /*
    9661             :   Document-class: Kdbtools::FileNotValidException < Kdbtools::kdb::tools::BackendCheckException
    9662             : 
    9663             :   Proxy of C++ Kdbtools::FileNotValidException class
    9664             : 
    9665             : 
    9666             : */
    9667             : static swig_class SwigClassFileNotValidException;
    9668             : 
    9669             : SWIGINTERN VALUE
    9670             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
    9671           0 : _wrap_FileNotValidException_allocate(VALUE self)
    9672             : #else
    9673             : _wrap_FileNotValidException_allocate(int argc, VALUE *argv, VALUE self)
    9674             : #endif
    9675             : {
    9676           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__FileNotValidException);
    9677             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    9678             :   rb_obj_call_init(vresult, argc, argv);
    9679             : #endif
    9680           0 :   return vresult;
    9681             : }
    9682             : 
    9683             : 
    9684             : 
    9685             : /*
    9686             :   Document-method: Kdbtools::FileNotValidException.new
    9687             : 
    9688             :   call-seq:
    9689             :     FileNotValidException.new
    9690             : 
    9691             : Class constructor.
    9692             : 
    9693             : */
    9694             : SWIGINTERN VALUE
    9695           0 : _wrap_new_FileNotValidException(int argc, VALUE *argv, VALUE self) {
    9696           0 :   kdb::tools::FileNotValidException *result = 0 ;
    9697             :   
    9698           0 :   if ((argc < 0) || (argc > 0)) {
    9699           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9700             :   }
    9701           0 :   result = (kdb::tools::FileNotValidException *)new kdb::tools::FileNotValidException();
    9702           0 :   DATA_PTR(self) = result;
    9703             :   return self;
    9704             : fail:
    9705             :   return Qnil;
    9706             : }
    9707             : 
    9708             : 
    9709             : SWIGINTERN void
    9710           0 : free_kdb_tools_FileNotValidException(void *self) {
    9711           0 :     kdb::tools::FileNotValidException *arg1 = (kdb::tools::FileNotValidException *)self;
    9712           0 :     delete arg1;
    9713           0 : }
    9714             : 
    9715             : 
    9716             : /*
    9717             :   Document-class: Kdbtools::MountpointInvalidException < Kdbtools::kdb::tools::BackendCheckException
    9718             : 
    9719             :   Proxy of C++ Kdbtools::MountpointInvalidException class
    9720             : 
    9721             : 
    9722             : */
    9723             : static swig_class SwigClassMountpointInvalidException;
    9724             : 
    9725             : SWIGINTERN VALUE
    9726             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
    9727           0 : _wrap_MountpointInvalidException_allocate(VALUE self)
    9728             : #else
    9729             : _wrap_MountpointInvalidException_allocate(int argc, VALUE *argv, VALUE self)
    9730             : #endif
    9731             : {
    9732           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__MountpointInvalidException);
    9733             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    9734             :   rb_obj_call_init(vresult, argc, argv);
    9735             : #endif
    9736           0 :   return vresult;
    9737             : }
    9738             : 
    9739             : 
    9740             : 
    9741             : /*
    9742             :   Document-method: Kdbtools::MountpointInvalidException.new
    9743             : 
    9744             :   call-seq:
    9745             :     MountpointInvalidException.new
    9746             : 
    9747             : Class constructor.
    9748             : 
    9749             : */
    9750             : SWIGINTERN VALUE
    9751           0 : _wrap_new_MountpointInvalidException(int argc, VALUE *argv, VALUE self) {
    9752           0 :   kdb::tools::MountpointInvalidException *result = 0 ;
    9753             :   
    9754           0 :   if ((argc < 0) || (argc > 0)) {
    9755           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9756             :   }
    9757           0 :   result = (kdb::tools::MountpointInvalidException *)new kdb::tools::MountpointInvalidException();
    9758           0 :   DATA_PTR(self) = result;
    9759             :   return self;
    9760             : fail:
    9761             :   return Qnil;
    9762             : }
    9763             : 
    9764             : 
    9765             : SWIGINTERN void
    9766           0 : free_kdb_tools_MountpointInvalidException(void *self) {
    9767           0 :     kdb::tools::MountpointInvalidException *arg1 = (kdb::tools::MountpointInvalidException *)self;
    9768           0 :     delete arg1;
    9769           0 : }
    9770             : 
    9771             : 
    9772             : /*
    9773             :   Document-class: Kdbtools::MountpointAlreadyInUseException < Kdbtools::kdb::tools::BackendCheckException
    9774             : 
    9775             :   Proxy of C++ Kdbtools::MountpointAlreadyInUseException class
    9776             : 
    9777             : 
    9778             : */
    9779             : static swig_class SwigClassMountpointAlreadyInUseException;
    9780             : 
    9781             : SWIGINTERN VALUE
    9782             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
    9783           0 : _wrap_MountpointAlreadyInUseException_allocate(VALUE self)
    9784             : #else
    9785             : _wrap_MountpointAlreadyInUseException_allocate(int argc, VALUE *argv, VALUE self)
    9786             : #endif
    9787             : {
    9788           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__MountpointAlreadyInUseException);
    9789             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    9790             :   rb_obj_call_init(vresult, argc, argv);
    9791             : #endif
    9792           0 :   return vresult;
    9793             : }
    9794             : 
    9795             : 
    9796             : 
    9797             : /*
    9798             :   Document-method: Kdbtools::MountpointAlreadyInUseException.new
    9799             : 
    9800             :   call-seq:
    9801             :     MountpointAlreadyInUseException.new(std::string str)
    9802             : 
    9803             : Class constructor.
    9804             : 
    9805             : */
    9806             : SWIGINTERN VALUE
    9807           0 : _wrap_new_MountpointAlreadyInUseException(int argc, VALUE *argv, VALUE self) {
    9808           0 :   std::string arg1 ;
    9809           0 :   kdb::tools::MountpointAlreadyInUseException *result = 0 ;
    9810             :   
    9811           0 :   if ((argc < 1) || (argc > 1)) {
    9812           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    9813             :   }
    9814             :   {
    9815           0 :     std::string *ptr = (std::string *)0;
    9816           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    9817           0 :     if (!SWIG_IsOK(res) || !ptr) {
    9818           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","MountpointAlreadyInUseException", 1, argv[0] )); 
    9819             :     }
    9820           0 :     arg1 = *ptr;
    9821           0 :     if (SWIG_IsNewObj(res)) delete ptr;
    9822             :   }
    9823           0 :   result = (kdb::tools::MountpointAlreadyInUseException *)new kdb::tools::MountpointAlreadyInUseException(arg1);
    9824           0 :   DATA_PTR(self) = result;
    9825           0 :   return self;
    9826             : fail:
    9827             :   return Qnil;
    9828             : }
    9829             : 
    9830             : 
    9831             : SWIGINTERN void
    9832           0 : free_kdb_tools_MountpointAlreadyInUseException(void *self) {
    9833           0 :     kdb::tools::MountpointAlreadyInUseException *arg1 = (kdb::tools::MountpointAlreadyInUseException *)self;
    9834           0 :     delete arg1;
    9835           0 : }
    9836             : 
    9837             : 
    9838             : /*
    9839             :   Document-method: Kdbtools::MountpointAlreadyInUseException.m_str
    9840             : 
    9841             :   call-seq:
    9842             :     m_str -> std::string
    9843             : 
    9844             : Get value of attribute.
    9845             : 
    9846             : */
    9847             : 
    9848             : /*
    9849             :   Document-method: Kdbtools::MountpointAlreadyInUseException.m_str=
    9850             : 
    9851             :   call-seq:
    9852             :     m_str=(x) -> std::string
    9853             : 
    9854             : Set new value for attribute.
    9855             : 
    9856             : */
    9857             : SWIGINTERN VALUE
    9858           0 : _wrap_MountpointAlreadyInUseException_m_str_set(int argc, VALUE *argv, VALUE self) {
    9859           0 :   kdb::tools::MountpointAlreadyInUseException *arg1 = (kdb::tools::MountpointAlreadyInUseException *) 0 ;
    9860           0 :   std::string *arg2 = 0 ;
    9861           0 :   void *argp1 = 0 ;
    9862           0 :   int res1 = 0 ;
    9863           0 :   int res2 = SWIG_OLDOBJ ;
    9864             :   
    9865           0 :   if ((argc < 1) || (argc > 1)) {
    9866           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    9867             :   }
    9868           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MountpointAlreadyInUseException, 0 |  0 );
    9869           0 :   if (!SWIG_IsOK(res1)) {
    9870           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MountpointAlreadyInUseException *","m_str", 1, self )); 
    9871             :   }
    9872           0 :   arg1 = reinterpret_cast< kdb::tools::MountpointAlreadyInUseException * >(argp1);
    9873             :   {
    9874           0 :     std::string *ptr = (std::string *)0;
    9875           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
    9876           0 :     if (!SWIG_IsOK(res2)) {
    9877           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","m_str", 2, argv[0] )); 
    9878             :     }
    9879           0 :     if (!ptr) {
    9880           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","m_str", 2, argv[0])); 
    9881             :     }
    9882           0 :     arg2 = ptr;
    9883             :   }
    9884           0 :   if (arg1) (arg1)->m_str = *arg2;
    9885           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
    9886             :   return Qnil;
    9887             : fail:
    9888             :   if (SWIG_IsNewObj(res2)) delete arg2;
    9889             :   return Qnil;
    9890             : }
    9891             : 
    9892             : 
    9893             : SWIGINTERN VALUE
    9894           0 : _wrap_MountpointAlreadyInUseException_m_str_get(int argc, VALUE *argv, VALUE self) {
    9895           0 :   kdb::tools::MountpointAlreadyInUseException *arg1 = (kdb::tools::MountpointAlreadyInUseException *) 0 ;
    9896           0 :   void *argp1 = 0 ;
    9897           0 :   int res1 = 0 ;
    9898           0 :   std::string *result = 0 ;
    9899           0 :   VALUE vresult = Qnil;
    9900             :   
    9901           0 :   if ((argc < 0) || (argc > 0)) {
    9902           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
    9903             :   }
    9904           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MountpointAlreadyInUseException, 0 |  0 );
    9905           0 :   if (!SWIG_IsOK(res1)) {
    9906           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MountpointAlreadyInUseException *","m_str", 1, self )); 
    9907             :   }
    9908           0 :   arg1 = reinterpret_cast< kdb::tools::MountpointAlreadyInUseException * >(argp1);
    9909           0 :   result = (std::string *) & ((arg1)->m_str);
    9910           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
    9911             :   return vresult;
    9912             : fail:
    9913             :   return Qnil;
    9914             : }
    9915             : 
    9916             : 
    9917             : 
    9918             : /*
    9919             :   Document-class: Kdbtools::NoSuchBackend < Kdbtools::kdb::tools::BackendCheckException
    9920             : 
    9921             :   Proxy of C++ Kdbtools::NoSuchBackend class
    9922             : 
    9923             : 
    9924             : */
    9925             : static swig_class SwigClassNoSuchBackend;
    9926             : 
    9927             : SWIGINTERN VALUE
    9928             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
    9929           0 : _wrap_NoSuchBackend_allocate(VALUE self)
    9930             : #else
    9931             : _wrap_NoSuchBackend_allocate(int argc, VALUE *argv, VALUE self)
    9932             : #endif
    9933             : {
    9934           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__NoSuchBackend);
    9935             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    9936             :   rb_obj_call_init(vresult, argc, argv);
    9937             : #endif
    9938           0 :   return vresult;
    9939             : }
    9940             : 
    9941             : 
    9942             : 
    9943             : /*
    9944             :   Document-method: Kdbtools::NoSuchBackend.new
    9945             : 
    9946             :   call-seq:
    9947             :     NoSuchBackend.new(std::string const & message)
    9948             : 
    9949             : Class constructor.
    9950             : 
    9951             : */
    9952             : SWIGINTERN VALUE
    9953           0 : _wrap_new_NoSuchBackend(int argc, VALUE *argv, VALUE self) {
    9954           0 :   std::string *arg1 = 0 ;
    9955           0 :   int res1 = SWIG_OLDOBJ ;
    9956           0 :   kdb::tools::NoSuchBackend *result = 0 ;
    9957             :   
    9958           0 :   if ((argc < 1) || (argc > 1)) {
    9959           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
    9960             :   }
    9961             :   {
    9962           0 :     std::string *ptr = (std::string *)0;
    9963           0 :     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    9964           0 :     if (!SWIG_IsOK(res1)) {
    9965           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","NoSuchBackend", 1, argv[0] )); 
    9966             :     }
    9967           0 :     if (!ptr) {
    9968           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","NoSuchBackend", 1, argv[0])); 
    9969             :     }
    9970           0 :     arg1 = ptr;
    9971             :   }
    9972           0 :   result = (kdb::tools::NoSuchBackend *)new kdb::tools::NoSuchBackend((std::string const &)*arg1);
    9973           0 :   DATA_PTR(self) = result;
    9974           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
    9975             :   return self;
    9976             : fail:
    9977             :   if (SWIG_IsNewObj(res1)) delete arg1;
    9978             :   return Qnil;
    9979             : }
    9980             : 
    9981             : 
    9982             : SWIGINTERN void
    9983           0 : free_kdb_tools_NoSuchBackend(void *self) {
    9984           0 :     kdb::tools::NoSuchBackend *arg1 = (kdb::tools::NoSuchBackend *)self;
    9985           0 :     delete arg1;
    9986           0 : }
    9987             : 
    9988             : 
    9989             : /*
    9990             :   Document-class: Kdbtools::PluginAlreadyInserted < Kdbtools::kdb::tools::PluginCheckException
    9991             : 
    9992             :   Proxy of C++ Kdbtools::PluginAlreadyInserted class
    9993             : 
    9994             : 
    9995             : */
    9996             : static swig_class SwigClassPluginAlreadyInserted;
    9997             : 
    9998             : SWIGINTERN VALUE
    9999             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   10000           0 : _wrap_PluginAlreadyInserted_allocate(VALUE self)
   10001             : #else
   10002             : _wrap_PluginAlreadyInserted_allocate(int argc, VALUE *argv, VALUE self)
   10003             : #endif
   10004             : {
   10005           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__PluginAlreadyInserted);
   10006             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   10007             :   rb_obj_call_init(vresult, argc, argv);
   10008             : #endif
   10009           0 :   return vresult;
   10010             : }
   10011             : 
   10012             : 
   10013             : 
   10014             : /*
   10015             :   Document-method: Kdbtools::PluginAlreadyInserted.new
   10016             : 
   10017             :   call-seq:
   10018             :     PluginAlreadyInserted.new(std::string name)
   10019             : 
   10020             : Class constructor.
   10021             : 
   10022             : */
   10023             : SWIGINTERN VALUE
   10024           0 : _wrap_new_PluginAlreadyInserted(int argc, VALUE *argv, VALUE self) {
   10025           0 :   std::string arg1 ;
   10026           0 :   kdb::tools::PluginAlreadyInserted *result = 0 ;
   10027             :   
   10028           0 :   if ((argc < 1) || (argc > 1)) {
   10029           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   10030             :   }
   10031             :   {
   10032           0 :     std::string *ptr = (std::string *)0;
   10033           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   10034           0 :     if (!SWIG_IsOK(res) || !ptr) {
   10035           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","PluginAlreadyInserted", 1, argv[0] )); 
   10036             :     }
   10037           0 :     arg1 = *ptr;
   10038           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   10039             :   }
   10040           0 :   result = (kdb::tools::PluginAlreadyInserted *)new kdb::tools::PluginAlreadyInserted(arg1);
   10041           0 :   DATA_PTR(self) = result;
   10042           0 :   return self;
   10043             : fail:
   10044             :   return Qnil;
   10045             : }
   10046             : 
   10047             : 
   10048             : 
   10049             : /*
   10050             :   Document-method: Kdbtools::PluginAlreadyInserted.m_str
   10051             : 
   10052             :   call-seq:
   10053             :     m_str -> std::string
   10054             : 
   10055             : Get value of attribute.
   10056             : 
   10057             : */
   10058             : 
   10059             : /*
   10060             :   Document-method: Kdbtools::PluginAlreadyInserted.m_str=
   10061             : 
   10062             :   call-seq:
   10063             :     m_str=(x) -> std::string
   10064             : 
   10065             : Set new value for attribute.
   10066             : 
   10067             : */
   10068             : SWIGINTERN VALUE
   10069           0 : _wrap_PluginAlreadyInserted_m_str_set(int argc, VALUE *argv, VALUE self) {
   10070           0 :   kdb::tools::PluginAlreadyInserted *arg1 = (kdb::tools::PluginAlreadyInserted *) 0 ;
   10071           0 :   std::string *arg2 = 0 ;
   10072           0 :   void *argp1 = 0 ;
   10073           0 :   int res1 = 0 ;
   10074           0 :   int res2 = SWIG_OLDOBJ ;
   10075             :   
   10076           0 :   if ((argc < 1) || (argc > 1)) {
   10077           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   10078             :   }
   10079           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginAlreadyInserted, 0 |  0 );
   10080           0 :   if (!SWIG_IsOK(res1)) {
   10081           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginAlreadyInserted *","m_str", 1, self )); 
   10082             :   }
   10083           0 :   arg1 = reinterpret_cast< kdb::tools::PluginAlreadyInserted * >(argp1);
   10084             :   {
   10085           0 :     std::string *ptr = (std::string *)0;
   10086           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   10087           0 :     if (!SWIG_IsOK(res2)) {
   10088           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","m_str", 2, argv[0] )); 
   10089             :     }
   10090           0 :     if (!ptr) {
   10091           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","m_str", 2, argv[0])); 
   10092             :     }
   10093           0 :     arg2 = ptr;
   10094             :   }
   10095           0 :   if (arg1) (arg1)->m_str = *arg2;
   10096           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   10097             :   return Qnil;
   10098             : fail:
   10099             :   if (SWIG_IsNewObj(res2)) delete arg2;
   10100             :   return Qnil;
   10101             : }
   10102             : 
   10103             : 
   10104             : SWIGINTERN VALUE
   10105           0 : _wrap_PluginAlreadyInserted_m_str_get(int argc, VALUE *argv, VALUE self) {
   10106           0 :   kdb::tools::PluginAlreadyInserted *arg1 = (kdb::tools::PluginAlreadyInserted *) 0 ;
   10107           0 :   void *argp1 = 0 ;
   10108           0 :   int res1 = 0 ;
   10109           0 :   std::string *result = 0 ;
   10110           0 :   VALUE vresult = Qnil;
   10111             :   
   10112           0 :   if ((argc < 0) || (argc > 0)) {
   10113           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   10114             :   }
   10115           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginAlreadyInserted, 0 |  0 );
   10116           0 :   if (!SWIG_IsOK(res1)) {
   10117           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginAlreadyInserted *","m_str", 1, self )); 
   10118             :   }
   10119           0 :   arg1 = reinterpret_cast< kdb::tools::PluginAlreadyInserted * >(argp1);
   10120           0 :   result = (std::string *) & ((arg1)->m_str);
   10121           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   10122             :   return vresult;
   10123             : fail:
   10124             :   return Qnil;
   10125             : }
   10126             : 
   10127             : 
   10128             : SWIGINTERN void
   10129           0 : free_kdb_tools_PluginAlreadyInserted(void *self) {
   10130           0 :     kdb::tools::PluginAlreadyInserted *arg1 = (kdb::tools::PluginAlreadyInserted *)self;
   10131           0 :     delete arg1;
   10132           0 : }
   10133             : 
   10134             : 
   10135             : /*
   10136             :   Document-class: Kdbtools::PluginConfigInvalid < Kdbtools::kdb::tools::PluginCheckException
   10137             : 
   10138             :   Proxy of C++ Kdbtools::PluginConfigInvalid class
   10139             : 
   10140             : 
   10141             : */
   10142             : static swig_class SwigClassPluginConfigInvalid;
   10143             : 
   10144             : 
   10145             : /*
   10146             :   Document-method: Kdbtools::PluginConfigInvalid.new
   10147             : 
   10148             :   call-seq:
   10149             :     PluginConfigInvalid.new(Key key)
   10150             :     PluginConfigInvalid.new(std::string const & message)
   10151             : 
   10152             : Class constructor.
   10153             : 
   10154             : */
   10155             : SWIGINTERN VALUE
   10156           0 : _wrap_new_PluginConfigInvalid__SWIG_0(int argc, VALUE *argv, VALUE self) {
   10157           0 :   kdb::Key arg1 ;
   10158             :   void *argp1 ;
   10159           0 :   int res1 = 0 ;
   10160           0 :   kdb::tools::PluginConfigInvalid *result = 0 ;
   10161             :   
   10162           0 :   if ((argc < 1) || (argc > 1)) {
   10163           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   10164             :   }
   10165             :   {
   10166           0 :     res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__Key,  0 );
   10167           0 :     if (!SWIG_IsOK(res1)) {
   10168           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::Key","PluginConfigInvalid", 1, argv[0] )); 
   10169             :     }  
   10170           0 :     if (!argp1) {
   10171           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key","PluginConfigInvalid", 1, argv[0]));
   10172             :     } else {
   10173           0 :       arg1 = *(reinterpret_cast< kdb::Key * >(argp1));
   10174             :     }
   10175             :   }
   10176           0 :   result = (kdb::tools::PluginConfigInvalid *)new kdb::tools::PluginConfigInvalid(arg1);
   10177           0 :   DATA_PTR(self) = result;
   10178           0 :   return self;
   10179             : fail:
   10180             :   return Qnil;
   10181             : }
   10182             : 
   10183             : 
   10184             : SWIGINTERN VALUE
   10185             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   10186           0 : _wrap_PluginConfigInvalid_allocate(VALUE self)
   10187             : #else
   10188             : _wrap_PluginConfigInvalid_allocate(int argc, VALUE *argv, VALUE self)
   10189             : #endif
   10190             : {
   10191           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__PluginConfigInvalid);
   10192             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   10193             :   rb_obj_call_init(vresult, argc, argv);
   10194             : #endif
   10195           0 :   return vresult;
   10196             : }
   10197             : 
   10198             : 
   10199             : SWIGINTERN VALUE
   10200           0 : _wrap_new_PluginConfigInvalid__SWIG_1(int argc, VALUE *argv, VALUE self) {
   10201           0 :   std::string *arg1 = 0 ;
   10202           0 :   int res1 = SWIG_OLDOBJ ;
   10203           0 :   kdb::tools::PluginConfigInvalid *result = 0 ;
   10204             :   
   10205           0 :   if ((argc < 1) || (argc > 1)) {
   10206           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   10207             :   }
   10208             :   {
   10209           0 :     std::string *ptr = (std::string *)0;
   10210           0 :     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
   10211           0 :     if (!SWIG_IsOK(res1)) {
   10212           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","PluginConfigInvalid", 1, argv[0] )); 
   10213             :     }
   10214           0 :     if (!ptr) {
   10215           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","PluginConfigInvalid", 1, argv[0])); 
   10216             :     }
   10217           0 :     arg1 = ptr;
   10218             :   }
   10219           0 :   result = (kdb::tools::PluginConfigInvalid *)new kdb::tools::PluginConfigInvalid((std::string const &)*arg1);
   10220           0 :   DATA_PTR(self) = result;
   10221           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
   10222             :   return self;
   10223             : fail:
   10224             :   if (SWIG_IsNewObj(res1)) delete arg1;
   10225             :   return Qnil;
   10226             : }
   10227             : 
   10228             : 
   10229           0 : SWIGINTERN VALUE _wrap_new_PluginConfigInvalid(int nargs, VALUE *args, VALUE self) {
   10230             :   int argc;
   10231             :   VALUE argv[1];
   10232             :   int ii;
   10233             :   
   10234           0 :   argc = nargs;
   10235           0 :   if (argc > 1) SWIG_fail;
   10236           0 :   for (ii = 0; (ii < argc); ++ii) {
   10237           0 :     argv[ii] = args[ii];
   10238             :   }
   10239           0 :   if (argc == 1) {
   10240           0 :     int _v = 0;
   10241             :     {
   10242           0 :       void *vptr = 0;
   10243           0 :       int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_kdb__Key, 0);
   10244           0 :       _v = SWIG_CheckState(res);
   10245             :     }
   10246           0 :     if (!_v) goto check_1;
   10247           0 :     return _wrap_new_PluginConfigInvalid__SWIG_0(nargs, args, self);
   10248             :   }
   10249             : check_1:
   10250             :   
   10251           0 :   if (argc == 1) {
   10252           0 :     return _wrap_new_PluginConfigInvalid__SWIG_1(nargs, args, self);
   10253             :   }
   10254             :   
   10255             : fail:
   10256             :   Ruby_Format_OverloadedError( argc, 1, "PluginConfigInvalid.new", 
   10257             :     "    PluginConfigInvalid.new(kdb::Key key)\n"
   10258           0 :     "    PluginConfigInvalid.new(std::string const &message)\n");
   10259             :   
   10260             :   return Qnil;
   10261             : }
   10262             : 
   10263             : 
   10264             : SWIGINTERN void
   10265           0 : free_kdb_tools_PluginConfigInvalid(void *self) {
   10266           0 :     kdb::tools::PluginConfigInvalid *arg1 = (kdb::tools::PluginConfigInvalid *)self;
   10267           0 :     delete arg1;
   10268           0 : }
   10269             : 
   10270             : 
   10271             : /*
   10272             :   Document-class: Kdbtools::BadPluginName < Kdbtools::kdb::tools::PluginCheckException
   10273             : 
   10274             :   Proxy of C++ Kdbtools::BadPluginName class
   10275             : 
   10276             : 
   10277             : */
   10278             : static swig_class SwigClassBadPluginName;
   10279             : 
   10280             : SWIGINTERN VALUE
   10281             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   10282           0 : _wrap_BadPluginName_allocate(VALUE self)
   10283             : #else
   10284             : _wrap_BadPluginName_allocate(int argc, VALUE *argv, VALUE self)
   10285             : #endif
   10286             : {
   10287           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__BadPluginName);
   10288             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   10289             :   rb_obj_call_init(vresult, argc, argv);
   10290             : #endif
   10291           0 :   return vresult;
   10292             : }
   10293             : 
   10294             : 
   10295             : 
   10296             : /*
   10297             :   Document-method: Kdbtools::BadPluginName.new
   10298             : 
   10299             :   call-seq:
   10300             :     BadPluginName.new(std::string name)
   10301             : 
   10302             : Class constructor.
   10303             : 
   10304             : */
   10305             : SWIGINTERN VALUE
   10306           0 : _wrap_new_BadPluginName(int argc, VALUE *argv, VALUE self) {
   10307           0 :   std::string arg1 ;
   10308           0 :   kdb::tools::BadPluginName *result = 0 ;
   10309             :   
   10310           0 :   if ((argc < 1) || (argc > 1)) {
   10311           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   10312             :   }
   10313             :   {
   10314           0 :     std::string *ptr = (std::string *)0;
   10315           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   10316           0 :     if (!SWIG_IsOK(res) || !ptr) {
   10317           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","BadPluginName", 1, argv[0] )); 
   10318             :     }
   10319           0 :     arg1 = *ptr;
   10320           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   10321             :   }
   10322           0 :   result = (kdb::tools::BadPluginName *)new kdb::tools::BadPluginName(arg1);
   10323           0 :   DATA_PTR(self) = result;
   10324           0 :   return self;
   10325             : fail:
   10326             :   return Qnil;
   10327             : }
   10328             : 
   10329             : 
   10330             : 
   10331             : /*
   10332             :   Document-method: Kdbtools::BadPluginName.m_str
   10333             : 
   10334             :   call-seq:
   10335             :     m_str -> std::string
   10336             : 
   10337             : Get value of attribute.
   10338             : 
   10339             : */
   10340             : 
   10341             : /*
   10342             :   Document-method: Kdbtools::BadPluginName.m_str=
   10343             : 
   10344             :   call-seq:
   10345             :     m_str=(x) -> std::string
   10346             : 
   10347             : Set new value for attribute.
   10348             : 
   10349             : */
   10350             : SWIGINTERN VALUE
   10351           0 : _wrap_BadPluginName_m_str_set(int argc, VALUE *argv, VALUE self) {
   10352           0 :   kdb::tools::BadPluginName *arg1 = (kdb::tools::BadPluginName *) 0 ;
   10353           0 :   std::string *arg2 = 0 ;
   10354           0 :   void *argp1 = 0 ;
   10355           0 :   int res1 = 0 ;
   10356           0 :   int res2 = SWIG_OLDOBJ ;
   10357             :   
   10358           0 :   if ((argc < 1) || (argc > 1)) {
   10359           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   10360             :   }
   10361           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BadPluginName, 0 |  0 );
   10362           0 :   if (!SWIG_IsOK(res1)) {
   10363           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BadPluginName *","m_str", 1, self )); 
   10364             :   }
   10365           0 :   arg1 = reinterpret_cast< kdb::tools::BadPluginName * >(argp1);
   10366             :   {
   10367           0 :     std::string *ptr = (std::string *)0;
   10368           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   10369           0 :     if (!SWIG_IsOK(res2)) {
   10370           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","m_str", 2, argv[0] )); 
   10371             :     }
   10372           0 :     if (!ptr) {
   10373           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","m_str", 2, argv[0])); 
   10374             :     }
   10375           0 :     arg2 = ptr;
   10376             :   }
   10377           0 :   if (arg1) (arg1)->m_str = *arg2;
   10378           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   10379             :   return Qnil;
   10380             : fail:
   10381             :   if (SWIG_IsNewObj(res2)) delete arg2;
   10382             :   return Qnil;
   10383             : }
   10384             : 
   10385             : 
   10386             : SWIGINTERN VALUE
   10387           0 : _wrap_BadPluginName_m_str_get(int argc, VALUE *argv, VALUE self) {
   10388           0 :   kdb::tools::BadPluginName *arg1 = (kdb::tools::BadPluginName *) 0 ;
   10389           0 :   void *argp1 = 0 ;
   10390           0 :   int res1 = 0 ;
   10391           0 :   std::string *result = 0 ;
   10392           0 :   VALUE vresult = Qnil;
   10393             :   
   10394           0 :   if ((argc < 0) || (argc > 0)) {
   10395           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   10396             :   }
   10397           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BadPluginName, 0 |  0 );
   10398           0 :   if (!SWIG_IsOK(res1)) {
   10399           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BadPluginName *","m_str", 1, self )); 
   10400             :   }
   10401           0 :   arg1 = reinterpret_cast< kdb::tools::BadPluginName * >(argp1);
   10402           0 :   result = (std::string *) & ((arg1)->m_str);
   10403           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   10404             :   return vresult;
   10405             : fail:
   10406             :   return Qnil;
   10407             : }
   10408             : 
   10409             : 
   10410             : SWIGINTERN void
   10411           2 : free_kdb_tools_BadPluginName(void *self) {
   10412           2 :     kdb::tools::BadPluginName *arg1 = (kdb::tools::BadPluginName *)self;
   10413           2 :     delete arg1;
   10414           2 : }
   10415             : 
   10416             : 
   10417             : /*
   10418             :   Document-class: Kdbtools::TooManyPlugins < Kdbtools::kdb::tools::PluginCheckException
   10419             : 
   10420             :   Proxy of C++ Kdbtools::TooManyPlugins class
   10421             : 
   10422             : 
   10423             : */
   10424             : static swig_class SwigClassTooManyPlugins;
   10425             : 
   10426             : SWIGINTERN VALUE
   10427             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   10428           0 : _wrap_TooManyPlugins_allocate(VALUE self)
   10429             : #else
   10430             : _wrap_TooManyPlugins_allocate(int argc, VALUE *argv, VALUE self)
   10431             : #endif
   10432             : {
   10433           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__TooManyPlugins);
   10434             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   10435             :   rb_obj_call_init(vresult, argc, argv);
   10436             : #endif
   10437           0 :   return vresult;
   10438             : }
   10439             : 
   10440             : 
   10441             : 
   10442             : /*
   10443             :   Document-method: Kdbtools::TooManyPlugins.new
   10444             : 
   10445             :   call-seq:
   10446             :     TooManyPlugins.new(std::string str)
   10447             : 
   10448             : Class constructor.
   10449             : 
   10450             : */
   10451             : SWIGINTERN VALUE
   10452           0 : _wrap_new_TooManyPlugins(int argc, VALUE *argv, VALUE self) {
   10453           0 :   std::string arg1 ;
   10454           0 :   kdb::tools::TooManyPlugins *result = 0 ;
   10455             :   
   10456           0 :   if ((argc < 1) || (argc > 1)) {
   10457           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   10458             :   }
   10459             :   {
   10460           0 :     std::string *ptr = (std::string *)0;
   10461           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   10462           0 :     if (!SWIG_IsOK(res) || !ptr) {
   10463           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","TooManyPlugins", 1, argv[0] )); 
   10464             :     }
   10465           0 :     arg1 = *ptr;
   10466           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   10467             :   }
   10468           0 :   result = (kdb::tools::TooManyPlugins *)new kdb::tools::TooManyPlugins(arg1);
   10469           0 :   DATA_PTR(self) = result;
   10470           0 :   return self;
   10471             : fail:
   10472             :   return Qnil;
   10473             : }
   10474             : 
   10475             : 
   10476             : SWIGINTERN void
   10477           0 : free_kdb_tools_TooManyPlugins(void *self) {
   10478           0 :     kdb::tools::TooManyPlugins *arg1 = (kdb::tools::TooManyPlugins *)self;
   10479           0 :     delete arg1;
   10480           0 : }
   10481             : 
   10482             : 
   10483             : /*
   10484             :   Document-method: Kdbtools::TooManyPlugins.m_str
   10485             : 
   10486             :   call-seq:
   10487             :     m_str -> std::string
   10488             : 
   10489             : Get value of attribute.
   10490             : 
   10491             : */
   10492             : 
   10493             : /*
   10494             :   Document-method: Kdbtools::TooManyPlugins.m_str=
   10495             : 
   10496             :   call-seq:
   10497             :     m_str=(x) -> std::string
   10498             : 
   10499             : Set new value for attribute.
   10500             : 
   10501             : */
   10502             : SWIGINTERN VALUE
   10503           0 : _wrap_TooManyPlugins_m_str_set(int argc, VALUE *argv, VALUE self) {
   10504           0 :   kdb::tools::TooManyPlugins *arg1 = (kdb::tools::TooManyPlugins *) 0 ;
   10505           0 :   std::string *arg2 = 0 ;
   10506           0 :   void *argp1 = 0 ;
   10507           0 :   int res1 = 0 ;
   10508           0 :   int res2 = SWIG_OLDOBJ ;
   10509             :   
   10510           0 :   if ((argc < 1) || (argc > 1)) {
   10511           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   10512             :   }
   10513           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__TooManyPlugins, 0 |  0 );
   10514           0 :   if (!SWIG_IsOK(res1)) {
   10515           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::TooManyPlugins *","m_str", 1, self )); 
   10516             :   }
   10517           0 :   arg1 = reinterpret_cast< kdb::tools::TooManyPlugins * >(argp1);
   10518             :   {
   10519           0 :     std::string *ptr = (std::string *)0;
   10520           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   10521           0 :     if (!SWIG_IsOK(res2)) {
   10522           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","m_str", 2, argv[0] )); 
   10523             :     }
   10524           0 :     if (!ptr) {
   10525           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","m_str", 2, argv[0])); 
   10526             :     }
   10527           0 :     arg2 = ptr;
   10528             :   }
   10529           0 :   if (arg1) (arg1)->m_str = *arg2;
   10530           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   10531             :   return Qnil;
   10532             : fail:
   10533             :   if (SWIG_IsNewObj(res2)) delete arg2;
   10534             :   return Qnil;
   10535             : }
   10536             : 
   10537             : 
   10538             : SWIGINTERN VALUE
   10539           0 : _wrap_TooManyPlugins_m_str_get(int argc, VALUE *argv, VALUE self) {
   10540           0 :   kdb::tools::TooManyPlugins *arg1 = (kdb::tools::TooManyPlugins *) 0 ;
   10541           0 :   void *argp1 = 0 ;
   10542           0 :   int res1 = 0 ;
   10543           0 :   std::string *result = 0 ;
   10544           0 :   VALUE vresult = Qnil;
   10545             :   
   10546           0 :   if ((argc < 0) || (argc > 0)) {
   10547           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   10548             :   }
   10549           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__TooManyPlugins, 0 |  0 );
   10550           0 :   if (!SWIG_IsOK(res1)) {
   10551           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::TooManyPlugins *","m_str", 1, self )); 
   10552             :   }
   10553           0 :   arg1 = reinterpret_cast< kdb::tools::TooManyPlugins * >(argp1);
   10554           0 :   result = (std::string *) & ((arg1)->m_str);
   10555           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   10556             :   return vresult;
   10557             : fail:
   10558             :   return Qnil;
   10559             : }
   10560             : 
   10561             : 
   10562             : 
   10563             : /*
   10564             :   Document-class: Kdbtools::OrderingViolation < Kdbtools::kdb::tools::PluginCheckException
   10565             : 
   10566             :   Proxy of C++ Kdbtools::OrderingViolation class
   10567             : 
   10568             : 
   10569             : */
   10570             : static swig_class SwigClassOrderingViolation;
   10571             : 
   10572             : SWIGINTERN VALUE
   10573             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   10574           0 : _wrap_OrderingViolation_allocate(VALUE self)
   10575             : #else
   10576             : _wrap_OrderingViolation_allocate(int argc, VALUE *argv, VALUE self)
   10577             : #endif
   10578             : {
   10579           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__OrderingViolation);
   10580             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   10581             :   rb_obj_call_init(vresult, argc, argv);
   10582             : #endif
   10583           0 :   return vresult;
   10584             : }
   10585             : 
   10586             : 
   10587             : 
   10588             : /*
   10589             :   Document-method: Kdbtools::OrderingViolation.new
   10590             : 
   10591             :   call-seq:
   10592             :     OrderingViolation.new
   10593             : 
   10594             : Class constructor.
   10595             : 
   10596             : */
   10597             : SWIGINTERN VALUE
   10598           0 : _wrap_new_OrderingViolation(int argc, VALUE *argv, VALUE self) {
   10599           0 :   kdb::tools::OrderingViolation *result = 0 ;
   10600             :   
   10601           0 :   if ((argc < 0) || (argc > 0)) {
   10602           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   10603             :   }
   10604           0 :   result = (kdb::tools::OrderingViolation *)new kdb::tools::OrderingViolation();
   10605           0 :   DATA_PTR(self) = result;
   10606             :   return self;
   10607             : fail:
   10608             :   return Qnil;
   10609             : }
   10610             : 
   10611             : 
   10612             : SWIGINTERN void
   10613           0 : free_kdb_tools_OrderingViolation(void *self) {
   10614           0 :     kdb::tools::OrderingViolation *arg1 = (kdb::tools::OrderingViolation *)self;
   10615           0 :     delete arg1;
   10616           0 : }
   10617             : 
   10618             : 
   10619             : /*
   10620             :   Document-class: Kdbtools::CyclicOrderingViolation < Kdbtools::kdb::tools::OrderingViolation
   10621             : 
   10622             :   Proxy of C++ Kdbtools::CyclicOrderingViolation class
   10623             : 
   10624             : 
   10625             : */
   10626             : static swig_class SwigClassCyclicOrderingViolation;
   10627             : 
   10628             : SWIGINTERN VALUE
   10629             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   10630           0 : _wrap_CyclicOrderingViolation_allocate(VALUE self)
   10631             : #else
   10632             : _wrap_CyclicOrderingViolation_allocate(int argc, VALUE *argv, VALUE self)
   10633             : #endif
   10634             : {
   10635           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__CyclicOrderingViolation);
   10636             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   10637             :   rb_obj_call_init(vresult, argc, argv);
   10638             : #endif
   10639           0 :   return vresult;
   10640             : }
   10641             : 
   10642             : 
   10643             : 
   10644             : /*
   10645             :   Document-method: Kdbtools::CyclicOrderingViolation.new
   10646             : 
   10647             :   call-seq:
   10648             :     CyclicOrderingViolation.new
   10649             : 
   10650             : Class constructor.
   10651             : 
   10652             : */
   10653             : SWIGINTERN VALUE
   10654           0 : _wrap_new_CyclicOrderingViolation(int argc, VALUE *argv, VALUE self) {
   10655           0 :   kdb::tools::CyclicOrderingViolation *result = 0 ;
   10656             :   
   10657           0 :   if ((argc < 0) || (argc > 0)) {
   10658           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   10659             :   }
   10660           0 :   result = (kdb::tools::CyclicOrderingViolation *)new kdb::tools::CyclicOrderingViolation();
   10661           0 :   DATA_PTR(self) = result;
   10662             :   return self;
   10663             : fail:
   10664             :   return Qnil;
   10665             : }
   10666             : 
   10667             : 
   10668             : SWIGINTERN void
   10669           0 : free_kdb_tools_CyclicOrderingViolation(void *self) {
   10670           0 :     kdb::tools::CyclicOrderingViolation *arg1 = (kdb::tools::CyclicOrderingViolation *)self;
   10671           0 :     delete arg1;
   10672           0 : }
   10673             : 
   10674             : 
   10675             : /*
   10676             :   Document-class: Kdbtools::ConflictViolation < Kdbtools::kdb::tools::PluginCheckException
   10677             : 
   10678             :   Proxy of C++ Kdbtools::ConflictViolation class
   10679             : 
   10680             : 
   10681             : */
   10682             : static swig_class SwigClassConflictViolation;
   10683             : 
   10684             : SWIGINTERN VALUE
   10685             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   10686           0 : _wrap_ConflictViolation_allocate(VALUE self)
   10687             : #else
   10688             : _wrap_ConflictViolation_allocate(int argc, VALUE *argv, VALUE self)
   10689             : #endif
   10690             : {
   10691           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__ConflictViolation);
   10692             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   10693             :   rb_obj_call_init(vresult, argc, argv);
   10694             : #endif
   10695           0 :   return vresult;
   10696             : }
   10697             : 
   10698             : 
   10699             : 
   10700             : /*
   10701             :   Document-method: Kdbtools::ConflictViolation.new
   10702             : 
   10703             :   call-seq:
   10704             :     ConflictViolation.new
   10705             : 
   10706             : Class constructor.
   10707             : 
   10708             : */
   10709             : SWIGINTERN VALUE
   10710           0 : _wrap_new_ConflictViolation(int argc, VALUE *argv, VALUE self) {
   10711           0 :   kdb::tools::ConflictViolation *result = 0 ;
   10712             :   
   10713           0 :   if ((argc < 0) || (argc > 0)) {
   10714           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   10715             :   }
   10716           0 :   result = (kdb::tools::ConflictViolation *)new kdb::tools::ConflictViolation();
   10717           0 :   DATA_PTR(self) = result;
   10718             :   return self;
   10719             : fail:
   10720             :   return Qnil;
   10721             : }
   10722             : 
   10723             : 
   10724             : SWIGINTERN void
   10725           0 : free_kdb_tools_ConflictViolation(void *self) {
   10726           0 :     kdb::tools::ConflictViolation *arg1 = (kdb::tools::ConflictViolation *)self;
   10727           0 :     delete arg1;
   10728           0 : }
   10729             : 
   10730             : 
   10731             : /*
   10732             :   Document-class: Kdbtools::NoPlugin < Kdbtools::kdb::tools::PluginCheckException
   10733             : 
   10734             :   Proxy of C++ Kdbtools::NoPlugin class
   10735             : 
   10736             : 
   10737             : */
   10738             : static swig_class SwigClassNoPlugin;
   10739             : 
   10740             : 
   10741             : /*
   10742             :   Document-method: Kdbtools::NoPlugin.new
   10743             : 
   10744             :   call-seq:
   10745             :     NoPlugin.new(Key key)
   10746             :     NoPlugin.new(std::string const & message)
   10747             : 
   10748             : Class constructor.
   10749             : 
   10750             : */
   10751             : SWIGINTERN VALUE
   10752           0 : _wrap_new_NoPlugin__SWIG_0(int argc, VALUE *argv, VALUE self) {
   10753           0 :   kdb::Key arg1 ;
   10754             :   void *argp1 ;
   10755           0 :   int res1 = 0 ;
   10756           0 :   kdb::tools::NoPlugin *result = 0 ;
   10757             :   
   10758           0 :   if ((argc < 1) || (argc > 1)) {
   10759           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   10760             :   }
   10761             :   {
   10762           0 :     res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__Key,  0 );
   10763           0 :     if (!SWIG_IsOK(res1)) {
   10764           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::Key","NoPlugin", 1, argv[0] )); 
   10765             :     }  
   10766           0 :     if (!argp1) {
   10767           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key","NoPlugin", 1, argv[0]));
   10768             :     } else {
   10769           0 :       arg1 = *(reinterpret_cast< kdb::Key * >(argp1));
   10770             :     }
   10771             :   }
   10772           0 :   result = (kdb::tools::NoPlugin *)new kdb::tools::NoPlugin(arg1);
   10773           0 :   DATA_PTR(self) = result;
   10774           0 :   return self;
   10775             : fail:
   10776             :   return Qnil;
   10777             : }
   10778             : 
   10779             : 
   10780             : SWIGINTERN VALUE
   10781             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   10782           0 : _wrap_NoPlugin_allocate(VALUE self)
   10783             : #else
   10784             : _wrap_NoPlugin_allocate(int argc, VALUE *argv, VALUE self)
   10785             : #endif
   10786             : {
   10787           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__NoPlugin);
   10788             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   10789             :   rb_obj_call_init(vresult, argc, argv);
   10790             : #endif
   10791           0 :   return vresult;
   10792             : }
   10793             : 
   10794             : 
   10795             : SWIGINTERN VALUE
   10796           0 : _wrap_new_NoPlugin__SWIG_1(int argc, VALUE *argv, VALUE self) {
   10797           0 :   std::string *arg1 = 0 ;
   10798           0 :   int res1 = SWIG_OLDOBJ ;
   10799           0 :   kdb::tools::NoPlugin *result = 0 ;
   10800             :   
   10801           0 :   if ((argc < 1) || (argc > 1)) {
   10802           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   10803             :   }
   10804             :   {
   10805           0 :     std::string *ptr = (std::string *)0;
   10806           0 :     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
   10807           0 :     if (!SWIG_IsOK(res1)) {
   10808           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","NoPlugin", 1, argv[0] )); 
   10809             :     }
   10810           0 :     if (!ptr) {
   10811           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","NoPlugin", 1, argv[0])); 
   10812             :     }
   10813           0 :     arg1 = ptr;
   10814             :   }
   10815           0 :   result = (kdb::tools::NoPlugin *)new kdb::tools::NoPlugin((std::string const &)*arg1);
   10816           0 :   DATA_PTR(self) = result;
   10817           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
   10818             :   return self;
   10819             : fail:
   10820             :   if (SWIG_IsNewObj(res1)) delete arg1;
   10821             :   return Qnil;
   10822             : }
   10823             : 
   10824             : 
   10825           0 : SWIGINTERN VALUE _wrap_new_NoPlugin(int nargs, VALUE *args, VALUE self) {
   10826             :   int argc;
   10827             :   VALUE argv[1];
   10828             :   int ii;
   10829             :   
   10830           0 :   argc = nargs;
   10831           0 :   if (argc > 1) SWIG_fail;
   10832           0 :   for (ii = 0; (ii < argc); ++ii) {
   10833           0 :     argv[ii] = args[ii];
   10834             :   }
   10835           0 :   if (argc == 1) {
   10836           0 :     int _v = 0;
   10837             :     {
   10838           0 :       void *vptr = 0;
   10839           0 :       int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_kdb__Key, 0);
   10840           0 :       _v = SWIG_CheckState(res);
   10841             :     }
   10842           0 :     if (!_v) goto check_1;
   10843           0 :     return _wrap_new_NoPlugin__SWIG_0(nargs, args, self);
   10844             :   }
   10845             : check_1:
   10846             :   
   10847           0 :   if (argc == 1) {
   10848           0 :     return _wrap_new_NoPlugin__SWIG_1(nargs, args, self);
   10849             :   }
   10850             :   
   10851             : fail:
   10852             :   Ruby_Format_OverloadedError( argc, 1, "NoPlugin.new", 
   10853             :     "    NoPlugin.new(kdb::Key key)\n"
   10854           0 :     "    NoPlugin.new(std::string const &message)\n");
   10855             :   
   10856             :   return Qnil;
   10857             : }
   10858             : 
   10859             : 
   10860             : SWIGINTERN void
   10861           1 : free_kdb_tools_NoPlugin(void *self) {
   10862           1 :     kdb::tools::NoPlugin *arg1 = (kdb::tools::NoPlugin *)self;
   10863           1 :     delete arg1;
   10864           1 : }
   10865             : 
   10866             : 
   10867             : /*
   10868             :   Document-class: Kdbtools::ReferenceNotFound < Kdbtools::kdb::tools::PluginCheckException
   10869             : 
   10870             :   Proxy of C++ Kdbtools::ReferenceNotFound class
   10871             : 
   10872             : 
   10873             : */
   10874             : static swig_class SwigClassReferenceNotFound;
   10875             : 
   10876             : SWIGINTERN VALUE
   10877             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   10878           0 : _wrap_ReferenceNotFound_allocate(VALUE self)
   10879             : #else
   10880             : _wrap_ReferenceNotFound_allocate(int argc, VALUE *argv, VALUE self)
   10881             : #endif
   10882             : {
   10883           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__ReferenceNotFound);
   10884             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   10885             :   rb_obj_call_init(vresult, argc, argv);
   10886             : #endif
   10887           0 :   return vresult;
   10888             : }
   10889             : 
   10890             : 
   10891             : 
   10892             : /*
   10893             :   Document-method: Kdbtools::ReferenceNotFound.new
   10894             : 
   10895             :   call-seq:
   10896             :     ReferenceNotFound.new
   10897             : 
   10898             : Class constructor.
   10899             : 
   10900             : */
   10901             : SWIGINTERN VALUE
   10902           0 : _wrap_new_ReferenceNotFound(int argc, VALUE *argv, VALUE self) {
   10903           0 :   kdb::tools::ReferenceNotFound *result = 0 ;
   10904             :   
   10905           0 :   if ((argc < 0) || (argc > 0)) {
   10906           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   10907             :   }
   10908           0 :   result = (kdb::tools::ReferenceNotFound *)new kdb::tools::ReferenceNotFound();
   10909           0 :   DATA_PTR(self) = result;
   10910             :   return self;
   10911             : fail:
   10912             :   return Qnil;
   10913             : }
   10914             : 
   10915             : 
   10916             : SWIGINTERN void
   10917           0 : free_kdb_tools_ReferenceNotFound(void *self) {
   10918           0 :     kdb::tools::ReferenceNotFound *arg1 = (kdb::tools::ReferenceNotFound *)self;
   10919           0 :     delete arg1;
   10920           0 : }
   10921             : 
   10922             : 
   10923             : /*
   10924             :   Document-class: Kdbtools::MissingNeeded < Kdbtools::kdb::tools::PluginCheckException
   10925             : 
   10926             :   Proxy of C++ Kdbtools::MissingNeeded class
   10927             : 
   10928             : 
   10929             : */
   10930             : static swig_class SwigClassMissingNeeded;
   10931             : 
   10932             : 
   10933             : /*
   10934             :   Document-method: Kdbtools::MissingNeeded.msg
   10935             : 
   10936             :   call-seq:
   10937             :     msg -> std::string
   10938             : 
   10939             : Get value of attribute.
   10940             : 
   10941             : */
   10942             : 
   10943             : /*
   10944             :   Document-method: Kdbtools::MissingNeeded.msg=
   10945             : 
   10946             :   call-seq:
   10947             :     msg=(x) -> std::string
   10948             : 
   10949             : Set new value for attribute.
   10950             : 
   10951             : */
   10952             : SWIGINTERN VALUE
   10953           0 : _wrap_MissingNeeded_msg_set(int argc, VALUE *argv, VALUE self) {
   10954           0 :   kdb::tools::MissingNeeded *arg1 = (kdb::tools::MissingNeeded *) 0 ;
   10955           0 :   std::string *arg2 = 0 ;
   10956           0 :   void *argp1 = 0 ;
   10957           0 :   int res1 = 0 ;
   10958           0 :   int res2 = SWIG_OLDOBJ ;
   10959             :   
   10960           0 :   if ((argc < 1) || (argc > 1)) {
   10961           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   10962             :   }
   10963           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MissingNeeded, 0 |  0 );
   10964           0 :   if (!SWIG_IsOK(res1)) {
   10965           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MissingNeeded *","msg", 1, self )); 
   10966             :   }
   10967           0 :   arg1 = reinterpret_cast< kdb::tools::MissingNeeded * >(argp1);
   10968             :   {
   10969           0 :     std::string *ptr = (std::string *)0;
   10970           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   10971           0 :     if (!SWIG_IsOK(res2)) {
   10972           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","msg", 2, argv[0] )); 
   10973             :     }
   10974           0 :     if (!ptr) {
   10975           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","msg", 2, argv[0])); 
   10976             :     }
   10977           0 :     arg2 = ptr;
   10978             :   }
   10979           0 :   if (arg1) (arg1)->msg = *arg2;
   10980           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   10981             :   return Qnil;
   10982             : fail:
   10983             :   if (SWIG_IsNewObj(res2)) delete arg2;
   10984             :   return Qnil;
   10985             : }
   10986             : 
   10987             : 
   10988             : SWIGINTERN VALUE
   10989           0 : _wrap_MissingNeeded_msg_get(int argc, VALUE *argv, VALUE self) {
   10990           0 :   kdb::tools::MissingNeeded *arg1 = (kdb::tools::MissingNeeded *) 0 ;
   10991           0 :   void *argp1 = 0 ;
   10992           0 :   int res1 = 0 ;
   10993           0 :   std::string *result = 0 ;
   10994           0 :   VALUE vresult = Qnil;
   10995             :   
   10996           0 :   if ((argc < 0) || (argc > 0)) {
   10997           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   10998             :   }
   10999           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MissingNeeded, 0 |  0 );
   11000           0 :   if (!SWIG_IsOK(res1)) {
   11001           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MissingNeeded *","msg", 1, self )); 
   11002             :   }
   11003           0 :   arg1 = reinterpret_cast< kdb::tools::MissingNeeded * >(argp1);
   11004           0 :   result = (std::string *) & ((arg1)->msg);
   11005           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   11006             :   return vresult;
   11007             : fail:
   11008             :   return Qnil;
   11009             : }
   11010             : 
   11011             : 
   11012             : SWIGINTERN VALUE
   11013             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   11014           0 : _wrap_MissingNeeded_allocate(VALUE self)
   11015             : #else
   11016             : _wrap_MissingNeeded_allocate(int argc, VALUE *argv, VALUE self)
   11017             : #endif
   11018             : {
   11019           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__MissingNeeded);
   11020             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   11021             :   rb_obj_call_init(vresult, argc, argv);
   11022             : #endif
   11023           0 :   return vresult;
   11024             : }
   11025             : 
   11026             : 
   11027             : 
   11028             : /*
   11029             :   Document-method: Kdbtools::MissingNeeded.new
   11030             : 
   11031             :   call-seq:
   11032             :     MissingNeeded.new(std::string need)
   11033             : 
   11034             : Class constructor.
   11035             : 
   11036             : */
   11037             : SWIGINTERN VALUE
   11038           0 : _wrap_new_MissingNeeded(int argc, VALUE *argv, VALUE self) {
   11039           0 :   std::string arg1 ;
   11040           0 :   kdb::tools::MissingNeeded *result = 0 ;
   11041             :   
   11042           0 :   if ((argc < 1) || (argc > 1)) {
   11043           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   11044             :   }
   11045             :   {
   11046           0 :     std::string *ptr = (std::string *)0;
   11047           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   11048           0 :     if (!SWIG_IsOK(res) || !ptr) {
   11049           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","MissingNeeded", 1, argv[0] )); 
   11050             :     }
   11051           0 :     arg1 = *ptr;
   11052           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   11053             :   }
   11054           0 :   result = (kdb::tools::MissingNeeded *)new kdb::tools::MissingNeeded(arg1);
   11055           0 :   DATA_PTR(self) = result;
   11056           0 :   return self;
   11057             : fail:
   11058             :   return Qnil;
   11059             : }
   11060             : 
   11061             : 
   11062             : SWIGINTERN void
   11063           0 : free_kdb_tools_MissingNeeded(void *self) {
   11064           0 :     kdb::tools::MissingNeeded *arg1 = (kdb::tools::MissingNeeded *)self;
   11065           0 :     delete arg1;
   11066           0 : }
   11067             : 
   11068             : 
   11069             : /*
   11070             :   Document-class: Kdbtools::MissingSymbol < Kdbtools::kdb::tools::PluginCheckException
   11071             : 
   11072             :   Proxy of C++ Kdbtools::MissingSymbol class
   11073             : 
   11074             : 
   11075             : */
   11076             : static swig_class SwigClassMissingSymbol;
   11077             : 
   11078             : 
   11079             : /*
   11080             :   Document-method: Kdbtools::MissingSymbol.msg
   11081             : 
   11082             :   call-seq:
   11083             :     msg -> std::string
   11084             : 
   11085             : Get value of attribute.
   11086             : 
   11087             : */
   11088             : 
   11089             : /*
   11090             :   Document-method: Kdbtools::MissingSymbol.msg=
   11091             : 
   11092             :   call-seq:
   11093             :     msg=(x) -> std::string
   11094             : 
   11095             : Set new value for attribute.
   11096             : 
   11097             : */
   11098             : SWIGINTERN VALUE
   11099           0 : _wrap_MissingSymbol_msg_set(int argc, VALUE *argv, VALUE self) {
   11100           0 :   kdb::tools::MissingSymbol *arg1 = (kdb::tools::MissingSymbol *) 0 ;
   11101           0 :   std::string *arg2 = 0 ;
   11102           0 :   void *argp1 = 0 ;
   11103           0 :   int res1 = 0 ;
   11104           0 :   int res2 = SWIG_OLDOBJ ;
   11105             :   
   11106           0 :   if ((argc < 1) || (argc > 1)) {
   11107           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   11108             :   }
   11109           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MissingSymbol, 0 |  0 );
   11110           0 :   if (!SWIG_IsOK(res1)) {
   11111           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MissingSymbol *","msg", 1, self )); 
   11112             :   }
   11113           0 :   arg1 = reinterpret_cast< kdb::tools::MissingSymbol * >(argp1);
   11114             :   {
   11115           0 :     std::string *ptr = (std::string *)0;
   11116           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   11117           0 :     if (!SWIG_IsOK(res2)) {
   11118           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","msg", 2, argv[0] )); 
   11119             :     }
   11120           0 :     if (!ptr) {
   11121           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","msg", 2, argv[0])); 
   11122             :     }
   11123           0 :     arg2 = ptr;
   11124             :   }
   11125           0 :   if (arg1) (arg1)->msg = *arg2;
   11126           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   11127             :   return Qnil;
   11128             : fail:
   11129             :   if (SWIG_IsNewObj(res2)) delete arg2;
   11130             :   return Qnil;
   11131             : }
   11132             : 
   11133             : 
   11134             : SWIGINTERN VALUE
   11135           0 : _wrap_MissingSymbol_msg_get(int argc, VALUE *argv, VALUE self) {
   11136           0 :   kdb::tools::MissingSymbol *arg1 = (kdb::tools::MissingSymbol *) 0 ;
   11137           0 :   void *argp1 = 0 ;
   11138           0 :   int res1 = 0 ;
   11139           0 :   std::string *result = 0 ;
   11140           0 :   VALUE vresult = Qnil;
   11141             :   
   11142           0 :   if ((argc < 0) || (argc > 0)) {
   11143           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   11144             :   }
   11145           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MissingSymbol, 0 |  0 );
   11146           0 :   if (!SWIG_IsOK(res1)) {
   11147           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MissingSymbol *","msg", 1, self )); 
   11148             :   }
   11149           0 :   arg1 = reinterpret_cast< kdb::tools::MissingSymbol * >(argp1);
   11150           0 :   result = (std::string *) & ((arg1)->msg);
   11151           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   11152             :   return vresult;
   11153             : fail:
   11154             :   return Qnil;
   11155             : }
   11156             : 
   11157             : 
   11158             : SWIGINTERN VALUE
   11159             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   11160           0 : _wrap_MissingSymbol_allocate(VALUE self)
   11161             : #else
   11162             : _wrap_MissingSymbol_allocate(int argc, VALUE *argv, VALUE self)
   11163             : #endif
   11164             : {
   11165           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__MissingSymbol);
   11166             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   11167             :   rb_obj_call_init(vresult, argc, argv);
   11168             : #endif
   11169           0 :   return vresult;
   11170             : }
   11171             : 
   11172             : 
   11173             : 
   11174             : /*
   11175             :   Document-method: Kdbtools::MissingSymbol.new
   11176             : 
   11177             :   call-seq:
   11178             :     MissingSymbol.new(std::string symbol)
   11179             : 
   11180             : Class constructor.
   11181             : 
   11182             : */
   11183             : SWIGINTERN VALUE
   11184           0 : _wrap_new_MissingSymbol(int argc, VALUE *argv, VALUE self) {
   11185           0 :   std::string arg1 ;
   11186           0 :   kdb::tools::MissingSymbol *result = 0 ;
   11187             :   
   11188           0 :   if ((argc < 1) || (argc > 1)) {
   11189           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   11190             :   }
   11191             :   {
   11192           0 :     std::string *ptr = (std::string *)0;
   11193           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   11194           0 :     if (!SWIG_IsOK(res) || !ptr) {
   11195           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","MissingSymbol", 1, argv[0] )); 
   11196             :     }
   11197           0 :     arg1 = *ptr;
   11198           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   11199             :   }
   11200           0 :   result = (kdb::tools::MissingSymbol *)new kdb::tools::MissingSymbol(arg1);
   11201           0 :   DATA_PTR(self) = result;
   11202           0 :   return self;
   11203             : fail:
   11204             :   return Qnil;
   11205             : }
   11206             : 
   11207             : 
   11208             : SWIGINTERN void
   11209           0 : free_kdb_tools_MissingSymbol(void *self) {
   11210           0 :     kdb::tools::MissingSymbol *arg1 = (kdb::tools::MissingSymbol *)self;
   11211           0 :     delete arg1;
   11212           0 : }
   11213             : 
   11214             : 
   11215             : /*
   11216             :   Document-class: Kdbtools::WrongStatus < Kdbtools::kdb::tools::PluginCheckException
   11217             : 
   11218             :   Proxy of C++ Kdbtools::WrongStatus class
   11219             : 
   11220             : 
   11221             : */
   11222             : static swig_class SwigClassWrongStatus;
   11223             : 
   11224             : 
   11225             : /*
   11226             :   Document-method: Kdbtools::WrongStatus.msg
   11227             : 
   11228             :   call-seq:
   11229             :     msg -> std::string
   11230             : 
   11231             : Get value of attribute.
   11232             : 
   11233             : */
   11234             : 
   11235             : /*
   11236             :   Document-method: Kdbtools::WrongStatus.msg=
   11237             : 
   11238             :   call-seq:
   11239             :     msg=(x) -> std::string
   11240             : 
   11241             : Set new value for attribute.
   11242             : 
   11243             : */
   11244             : SWIGINTERN VALUE
   11245           0 : _wrap_WrongStatus_msg_set(int argc, VALUE *argv, VALUE self) {
   11246           0 :   kdb::tools::WrongStatus *arg1 = (kdb::tools::WrongStatus *) 0 ;
   11247           0 :   std::string *arg2 = 0 ;
   11248           0 :   void *argp1 = 0 ;
   11249           0 :   int res1 = 0 ;
   11250           0 :   int res2 = SWIG_OLDOBJ ;
   11251             :   
   11252           0 :   if ((argc < 1) || (argc > 1)) {
   11253           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   11254             :   }
   11255           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__WrongStatus, 0 |  0 );
   11256           0 :   if (!SWIG_IsOK(res1)) {
   11257           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::WrongStatus *","msg", 1, self )); 
   11258             :   }
   11259           0 :   arg1 = reinterpret_cast< kdb::tools::WrongStatus * >(argp1);
   11260             :   {
   11261           0 :     std::string *ptr = (std::string *)0;
   11262           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   11263           0 :     if (!SWIG_IsOK(res2)) {
   11264           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","msg", 2, argv[0] )); 
   11265             :     }
   11266           0 :     if (!ptr) {
   11267           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","msg", 2, argv[0])); 
   11268             :     }
   11269           0 :     arg2 = ptr;
   11270             :   }
   11271           0 :   if (arg1) (arg1)->msg = *arg2;
   11272           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   11273             :   return Qnil;
   11274             : fail:
   11275             :   if (SWIG_IsNewObj(res2)) delete arg2;
   11276             :   return Qnil;
   11277             : }
   11278             : 
   11279             : 
   11280             : SWIGINTERN VALUE
   11281           0 : _wrap_WrongStatus_msg_get(int argc, VALUE *argv, VALUE self) {
   11282           0 :   kdb::tools::WrongStatus *arg1 = (kdb::tools::WrongStatus *) 0 ;
   11283           0 :   void *argp1 = 0 ;
   11284           0 :   int res1 = 0 ;
   11285           0 :   std::string *result = 0 ;
   11286           0 :   VALUE vresult = Qnil;
   11287             :   
   11288           0 :   if ((argc < 0) || (argc > 0)) {
   11289           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   11290             :   }
   11291           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__WrongStatus, 0 |  0 );
   11292           0 :   if (!SWIG_IsOK(res1)) {
   11293           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::WrongStatus *","msg", 1, self )); 
   11294             :   }
   11295           0 :   arg1 = reinterpret_cast< kdb::tools::WrongStatus * >(argp1);
   11296           0 :   result = (std::string *) & ((arg1)->msg);
   11297           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   11298             :   return vresult;
   11299             : fail:
   11300             :   return Qnil;
   11301             : }
   11302             : 
   11303             : 
   11304             : SWIGINTERN VALUE
   11305             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   11306           0 : _wrap_WrongStatus_allocate(VALUE self)
   11307             : #else
   11308             : _wrap_WrongStatus_allocate(int argc, VALUE *argv, VALUE self)
   11309             : #endif
   11310             : {
   11311           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__WrongStatus);
   11312             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   11313             :   rb_obj_call_init(vresult, argc, argv);
   11314             : #endif
   11315           0 :   return vresult;
   11316             : }
   11317             : 
   11318             : 
   11319             : 
   11320             : /*
   11321             :   Document-method: Kdbtools::WrongStatus.new
   11322             : 
   11323             :   call-seq:
   11324             :     WrongStatus.new(std::string status)
   11325             : 
   11326             : Class constructor.
   11327             : 
   11328             : */
   11329             : SWIGINTERN VALUE
   11330           0 : _wrap_new_WrongStatus(int argc, VALUE *argv, VALUE self) {
   11331           0 :   std::string arg1 ;
   11332           0 :   kdb::tools::WrongStatus *result = 0 ;
   11333             :   
   11334           0 :   if ((argc < 1) || (argc > 1)) {
   11335           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   11336             :   }
   11337             :   {
   11338           0 :     std::string *ptr = (std::string *)0;
   11339           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   11340           0 :     if (!SWIG_IsOK(res) || !ptr) {
   11341           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","WrongStatus", 1, argv[0] )); 
   11342             :     }
   11343           0 :     arg1 = *ptr;
   11344           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   11345             :   }
   11346           0 :   result = (kdb::tools::WrongStatus *)new kdb::tools::WrongStatus(arg1);
   11347           0 :   DATA_PTR(self) = result;
   11348           0 :   return self;
   11349             : fail:
   11350             :   return Qnil;
   11351             : }
   11352             : 
   11353             : 
   11354             : SWIGINTERN void
   11355           0 : free_kdb_tools_WrongStatus(void *self) {
   11356           0 :     kdb::tools::WrongStatus *arg1 = (kdb::tools::WrongStatus *)self;
   11357           0 :     delete arg1;
   11358           0 : }
   11359             : 
   11360             : 
   11361             : /*
   11362             :   Document-class: Kdbtools::SymbolMismatch < Kdbtools::kdb::tools::PluginCheckException
   11363             : 
   11364             :   Proxy of C++ Kdbtools::SymbolMismatch class
   11365             : 
   11366             : 
   11367             : */
   11368             : static swig_class SwigClassSymbolMismatch;
   11369             : 
   11370             : 
   11371             : /*
   11372             :   Document-method: Kdbtools::SymbolMismatch.msg
   11373             : 
   11374             :   call-seq:
   11375             :     msg -> std::string
   11376             : 
   11377             : Get value of attribute.
   11378             : 
   11379             : */
   11380             : 
   11381             : /*
   11382             :   Document-method: Kdbtools::SymbolMismatch.msg=
   11383             : 
   11384             :   call-seq:
   11385             :     msg=(x) -> std::string
   11386             : 
   11387             : Set new value for attribute.
   11388             : 
   11389             : */
   11390             : SWIGINTERN VALUE
   11391           0 : _wrap_SymbolMismatch_msg_set(int argc, VALUE *argv, VALUE self) {
   11392           0 :   kdb::tools::SymbolMismatch *arg1 = (kdb::tools::SymbolMismatch *) 0 ;
   11393           0 :   std::string *arg2 = 0 ;
   11394           0 :   void *argp1 = 0 ;
   11395           0 :   int res1 = 0 ;
   11396           0 :   int res2 = SWIG_OLDOBJ ;
   11397             :   
   11398           0 :   if ((argc < 1) || (argc > 1)) {
   11399           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   11400             :   }
   11401           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SymbolMismatch, 0 |  0 );
   11402           0 :   if (!SWIG_IsOK(res1)) {
   11403           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SymbolMismatch *","msg", 1, self )); 
   11404             :   }
   11405           0 :   arg1 = reinterpret_cast< kdb::tools::SymbolMismatch * >(argp1);
   11406             :   {
   11407           0 :     std::string *ptr = (std::string *)0;
   11408           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   11409           0 :     if (!SWIG_IsOK(res2)) {
   11410           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","msg", 2, argv[0] )); 
   11411             :     }
   11412           0 :     if (!ptr) {
   11413           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","msg", 2, argv[0])); 
   11414             :     }
   11415           0 :     arg2 = ptr;
   11416             :   }
   11417           0 :   if (arg1) (arg1)->msg = *arg2;
   11418           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   11419             :   return Qnil;
   11420             : fail:
   11421             :   if (SWIG_IsNewObj(res2)) delete arg2;
   11422             :   return Qnil;
   11423             : }
   11424             : 
   11425             : 
   11426             : SWIGINTERN VALUE
   11427           0 : _wrap_SymbolMismatch_msg_get(int argc, VALUE *argv, VALUE self) {
   11428           0 :   kdb::tools::SymbolMismatch *arg1 = (kdb::tools::SymbolMismatch *) 0 ;
   11429           0 :   void *argp1 = 0 ;
   11430           0 :   int res1 = 0 ;
   11431           0 :   std::string *result = 0 ;
   11432           0 :   VALUE vresult = Qnil;
   11433             :   
   11434           0 :   if ((argc < 0) || (argc > 0)) {
   11435           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   11436             :   }
   11437           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SymbolMismatch, 0 |  0 );
   11438           0 :   if (!SWIG_IsOK(res1)) {
   11439           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SymbolMismatch *","msg", 1, self )); 
   11440             :   }
   11441           0 :   arg1 = reinterpret_cast< kdb::tools::SymbolMismatch * >(argp1);
   11442           0 :   result = (std::string *) & ((arg1)->msg);
   11443           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   11444             :   return vresult;
   11445             : fail:
   11446             :   return Qnil;
   11447             : }
   11448             : 
   11449             : 
   11450             : SWIGINTERN VALUE
   11451             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   11452           0 : _wrap_SymbolMismatch_allocate(VALUE self)
   11453             : #else
   11454             : _wrap_SymbolMismatch_allocate(int argc, VALUE *argv, VALUE self)
   11455             : #endif
   11456             : {
   11457           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__SymbolMismatch);
   11458             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   11459             :   rb_obj_call_init(vresult, argc, argv);
   11460             : #endif
   11461           0 :   return vresult;
   11462             : }
   11463             : 
   11464             : 
   11465             : 
   11466             : /*
   11467             :   Document-method: Kdbtools::SymbolMismatch.new
   11468             : 
   11469             :   call-seq:
   11470             :     SymbolMismatch.new(std::string symbol)
   11471             : 
   11472             : Class constructor.
   11473             : 
   11474             : */
   11475             : SWIGINTERN VALUE
   11476           0 : _wrap_new_SymbolMismatch(int argc, VALUE *argv, VALUE self) {
   11477           0 :   std::string arg1 ;
   11478           0 :   kdb::tools::SymbolMismatch *result = 0 ;
   11479             :   
   11480           0 :   if ((argc < 1) || (argc > 1)) {
   11481           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   11482             :   }
   11483             :   {
   11484           0 :     std::string *ptr = (std::string *)0;
   11485           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   11486           0 :     if (!SWIG_IsOK(res) || !ptr) {
   11487           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","SymbolMismatch", 1, argv[0] )); 
   11488             :     }
   11489           0 :     arg1 = *ptr;
   11490           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   11491             :   }
   11492           0 :   result = (kdb::tools::SymbolMismatch *)new kdb::tools::SymbolMismatch(arg1);
   11493           0 :   DATA_PTR(self) = result;
   11494           0 :   return self;
   11495             : fail:
   11496             :   return Qnil;
   11497             : }
   11498             : 
   11499             : 
   11500             : SWIGINTERN void
   11501           0 : free_kdb_tools_SymbolMismatch(void *self) {
   11502           0 :     kdb::tools::SymbolMismatch *arg1 = (kdb::tools::SymbolMismatch *)self;
   11503           0 :     delete arg1;
   11504           0 : }
   11505             : 
   11506             : 
   11507             : /*
   11508             :   Document-class: Kdbtools::NoGlobalPlugin < Kdbtools::kdb::tools::PluginCheckException
   11509             : 
   11510             :   Proxy of C++ Kdbtools::NoGlobalPlugin class
   11511             : 
   11512             : 
   11513             : */
   11514             : static swig_class SwigClassNoGlobalPlugin;
   11515             : 
   11516             : 
   11517             : /*
   11518             :   Document-method: Kdbtools::NoGlobalPlugin.msg
   11519             : 
   11520             :   call-seq:
   11521             :     msg -> std::string
   11522             : 
   11523             : Get value of attribute.
   11524             : 
   11525             : */
   11526             : 
   11527             : /*
   11528             :   Document-method: Kdbtools::NoGlobalPlugin.msg=
   11529             : 
   11530             :   call-seq:
   11531             :     msg=(x) -> std::string
   11532             : 
   11533             : Set new value for attribute.
   11534             : 
   11535             : */
   11536             : SWIGINTERN VALUE
   11537           0 : _wrap_NoGlobalPlugin_msg_set(int argc, VALUE *argv, VALUE self) {
   11538           0 :   kdb::tools::NoGlobalPlugin *arg1 = (kdb::tools::NoGlobalPlugin *) 0 ;
   11539           0 :   std::string *arg2 = 0 ;
   11540           0 :   void *argp1 = 0 ;
   11541           0 :   int res1 = 0 ;
   11542           0 :   int res2 = SWIG_OLDOBJ ;
   11543             :   
   11544           0 :   if ((argc < 1) || (argc > 1)) {
   11545           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   11546             :   }
   11547           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__NoGlobalPlugin, 0 |  0 );
   11548           0 :   if (!SWIG_IsOK(res1)) {
   11549           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::NoGlobalPlugin *","msg", 1, self )); 
   11550             :   }
   11551           0 :   arg1 = reinterpret_cast< kdb::tools::NoGlobalPlugin * >(argp1);
   11552             :   {
   11553           0 :     std::string *ptr = (std::string *)0;
   11554           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   11555           0 :     if (!SWIG_IsOK(res2)) {
   11556           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","msg", 2, argv[0] )); 
   11557             :     }
   11558           0 :     if (!ptr) {
   11559           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","msg", 2, argv[0])); 
   11560             :     }
   11561           0 :     arg2 = ptr;
   11562             :   }
   11563           0 :   if (arg1) (arg1)->msg = *arg2;
   11564           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   11565             :   return Qnil;
   11566             : fail:
   11567             :   if (SWIG_IsNewObj(res2)) delete arg2;
   11568             :   return Qnil;
   11569             : }
   11570             : 
   11571             : 
   11572             : SWIGINTERN VALUE
   11573           0 : _wrap_NoGlobalPlugin_msg_get(int argc, VALUE *argv, VALUE self) {
   11574           0 :   kdb::tools::NoGlobalPlugin *arg1 = (kdb::tools::NoGlobalPlugin *) 0 ;
   11575           0 :   void *argp1 = 0 ;
   11576           0 :   int res1 = 0 ;
   11577           0 :   std::string *result = 0 ;
   11578           0 :   VALUE vresult = Qnil;
   11579             :   
   11580           0 :   if ((argc < 0) || (argc > 0)) {
   11581           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   11582             :   }
   11583           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__NoGlobalPlugin, 0 |  0 );
   11584           0 :   if (!SWIG_IsOK(res1)) {
   11585           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::NoGlobalPlugin *","msg", 1, self )); 
   11586             :   }
   11587           0 :   arg1 = reinterpret_cast< kdb::tools::NoGlobalPlugin * >(argp1);
   11588           0 :   result = (std::string *) & ((arg1)->msg);
   11589           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   11590             :   return vresult;
   11591             : fail:
   11592             :   return Qnil;
   11593             : }
   11594             : 
   11595             : 
   11596             : SWIGINTERN VALUE
   11597             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   11598           0 : _wrap_NoGlobalPlugin_allocate(VALUE self)
   11599             : #else
   11600             : _wrap_NoGlobalPlugin_allocate(int argc, VALUE *argv, VALUE self)
   11601             : #endif
   11602             : {
   11603           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__NoGlobalPlugin);
   11604             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   11605             :   rb_obj_call_init(vresult, argc, argv);
   11606             : #endif
   11607           0 :   return vresult;
   11608             : }
   11609             : 
   11610             : 
   11611             : 
   11612             : /*
   11613             :   Document-method: Kdbtools::NoGlobalPlugin.new
   11614             : 
   11615             :   call-seq:
   11616             :     NoGlobalPlugin.new(std::string plugin)
   11617             : 
   11618             : Class constructor.
   11619             : 
   11620             : */
   11621             : SWIGINTERN VALUE
   11622           0 : _wrap_new_NoGlobalPlugin(int argc, VALUE *argv, VALUE self) {
   11623           0 :   std::string arg1 ;
   11624           0 :   kdb::tools::NoGlobalPlugin *result = 0 ;
   11625             :   
   11626           0 :   if ((argc < 1) || (argc > 1)) {
   11627           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   11628             :   }
   11629             :   {
   11630           0 :     std::string *ptr = (std::string *)0;
   11631           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   11632           0 :     if (!SWIG_IsOK(res) || !ptr) {
   11633           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","NoGlobalPlugin", 1, argv[0] )); 
   11634             :     }
   11635           0 :     arg1 = *ptr;
   11636           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   11637             :   }
   11638           0 :   result = (kdb::tools::NoGlobalPlugin *)new kdb::tools::NoGlobalPlugin(arg1);
   11639           0 :   DATA_PTR(self) = result;
   11640           0 :   return self;
   11641             : fail:
   11642             :   return Qnil;
   11643             : }
   11644             : 
   11645             : 
   11646             : SWIGINTERN void
   11647           0 : free_kdb_tools_NoGlobalPlugin(void *self) {
   11648           0 :     kdb::tools::NoGlobalPlugin *arg1 = (kdb::tools::NoGlobalPlugin *)self;
   11649           0 :     delete arg1;
   11650           0 : }
   11651             : 
   11652             : 
   11653             : /*
   11654             :   Document-class: Kdbtools::SymbolDuplicate < Kdbtools::kdb::tools::PluginCheckException
   11655             : 
   11656             :   Proxy of C++ Kdbtools::SymbolDuplicate class
   11657             : 
   11658             : 
   11659             : */
   11660             : static swig_class SwigClassSymbolDuplicate;
   11661             : 
   11662             : 
   11663             : /*
   11664             :   Document-method: Kdbtools::SymbolDuplicate.msg
   11665             : 
   11666             :   call-seq:
   11667             :     msg -> std::string
   11668             : 
   11669             : Get value of attribute.
   11670             : 
   11671             : */
   11672             : 
   11673             : /*
   11674             :   Document-method: Kdbtools::SymbolDuplicate.msg=
   11675             : 
   11676             :   call-seq:
   11677             :     msg=(x) -> std::string
   11678             : 
   11679             : Set new value for attribute.
   11680             : 
   11681             : */
   11682             : SWIGINTERN VALUE
   11683           0 : _wrap_SymbolDuplicate_msg_set(int argc, VALUE *argv, VALUE self) {
   11684           0 :   kdb::tools::SymbolDuplicate *arg1 = (kdb::tools::SymbolDuplicate *) 0 ;
   11685           0 :   std::string *arg2 = 0 ;
   11686           0 :   void *argp1 = 0 ;
   11687           0 :   int res1 = 0 ;
   11688           0 :   int res2 = SWIG_OLDOBJ ;
   11689             :   
   11690           0 :   if ((argc < 1) || (argc > 1)) {
   11691           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   11692             :   }
   11693           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SymbolDuplicate, 0 |  0 );
   11694           0 :   if (!SWIG_IsOK(res1)) {
   11695           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SymbolDuplicate *","msg", 1, self )); 
   11696             :   }
   11697           0 :   arg1 = reinterpret_cast< kdb::tools::SymbolDuplicate * >(argp1);
   11698             :   {
   11699           0 :     std::string *ptr = (std::string *)0;
   11700           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   11701           0 :     if (!SWIG_IsOK(res2)) {
   11702           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","msg", 2, argv[0] )); 
   11703             :     }
   11704           0 :     if (!ptr) {
   11705           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","msg", 2, argv[0])); 
   11706             :     }
   11707           0 :     arg2 = ptr;
   11708             :   }
   11709           0 :   if (arg1) (arg1)->msg = *arg2;
   11710           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   11711             :   return Qnil;
   11712             : fail:
   11713             :   if (SWIG_IsNewObj(res2)) delete arg2;
   11714             :   return Qnil;
   11715             : }
   11716             : 
   11717             : 
   11718             : SWIGINTERN VALUE
   11719           0 : _wrap_SymbolDuplicate_msg_get(int argc, VALUE *argv, VALUE self) {
   11720           0 :   kdb::tools::SymbolDuplicate *arg1 = (kdb::tools::SymbolDuplicate *) 0 ;
   11721           0 :   void *argp1 = 0 ;
   11722           0 :   int res1 = 0 ;
   11723           0 :   std::string *result = 0 ;
   11724           0 :   VALUE vresult = Qnil;
   11725             :   
   11726           0 :   if ((argc < 0) || (argc > 0)) {
   11727           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   11728             :   }
   11729           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SymbolDuplicate, 0 |  0 );
   11730           0 :   if (!SWIG_IsOK(res1)) {
   11731           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SymbolDuplicate *","msg", 1, self )); 
   11732             :   }
   11733           0 :   arg1 = reinterpret_cast< kdb::tools::SymbolDuplicate * >(argp1);
   11734           0 :   result = (std::string *) & ((arg1)->msg);
   11735           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   11736             :   return vresult;
   11737             : fail:
   11738             :   return Qnil;
   11739             : }
   11740             : 
   11741             : 
   11742             : SWIGINTERN VALUE
   11743             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   11744           0 : _wrap_SymbolDuplicate_allocate(VALUE self)
   11745             : #else
   11746             : _wrap_SymbolDuplicate_allocate(int argc, VALUE *argv, VALUE self)
   11747             : #endif
   11748             : {
   11749           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__SymbolDuplicate);
   11750             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   11751             :   rb_obj_call_init(vresult, argc, argv);
   11752             : #endif
   11753           0 :   return vresult;
   11754             : }
   11755             : 
   11756             : 
   11757             : 
   11758             : /*
   11759             :   Document-method: Kdbtools::SymbolDuplicate.new
   11760             : 
   11761             :   call-seq:
   11762             :     SymbolDuplicate.new(std::string symbol)
   11763             : 
   11764             : Class constructor.
   11765             : 
   11766             : */
   11767             : SWIGINTERN VALUE
   11768           0 : _wrap_new_SymbolDuplicate(int argc, VALUE *argv, VALUE self) {
   11769           0 :   std::string arg1 ;
   11770           0 :   kdb::tools::SymbolDuplicate *result = 0 ;
   11771             :   
   11772           0 :   if ((argc < 1) || (argc > 1)) {
   11773           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   11774             :   }
   11775             :   {
   11776           0 :     std::string *ptr = (std::string *)0;
   11777           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   11778           0 :     if (!SWIG_IsOK(res) || !ptr) {
   11779           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","SymbolDuplicate", 1, argv[0] )); 
   11780             :     }
   11781           0 :     arg1 = *ptr;
   11782           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   11783             :   }
   11784           0 :   result = (kdb::tools::SymbolDuplicate *)new kdb::tools::SymbolDuplicate(arg1);
   11785           0 :   DATA_PTR(self) = result;
   11786           0 :   return self;
   11787             : fail:
   11788             :   return Qnil;
   11789             : }
   11790             : 
   11791             : 
   11792             : SWIGINTERN void
   11793           0 : free_kdb_tools_SymbolDuplicate(void *self) {
   11794           0 :     kdb::tools::SymbolDuplicate *arg1 = (kdb::tools::SymbolDuplicate *)self;
   11795           0 :     delete arg1;
   11796           0 : }
   11797             : 
   11798             : 
   11799             : /*
   11800             :   Document-class: Kdbtools::StoragePlugin < Kdbtools::kdb::tools::PluginCheckException
   11801             : 
   11802             :   Proxy of C++ Kdbtools::StoragePlugin class
   11803             : 
   11804             : 
   11805             : */
   11806             : static swig_class SwigClassStoragePlugin;
   11807             : 
   11808             : SWIGINTERN VALUE
   11809             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   11810           0 : _wrap_StoragePlugin_allocate(VALUE self)
   11811             : #else
   11812             : _wrap_StoragePlugin_allocate(int argc, VALUE *argv, VALUE self)
   11813             : #endif
   11814             : {
   11815           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__StoragePlugin);
   11816             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   11817             :   rb_obj_call_init(vresult, argc, argv);
   11818             : #endif
   11819           0 :   return vresult;
   11820             : }
   11821             : 
   11822             : 
   11823             : 
   11824             : /*
   11825             :   Document-method: Kdbtools::StoragePlugin.new
   11826             : 
   11827             :   call-seq:
   11828             :     StoragePlugin.new
   11829             : 
   11830             : Class constructor.
   11831             : 
   11832             : */
   11833             : SWIGINTERN VALUE
   11834           0 : _wrap_new_StoragePlugin(int argc, VALUE *argv, VALUE self) {
   11835           0 :   kdb::tools::StoragePlugin *result = 0 ;
   11836             :   
   11837           0 :   if ((argc < 0) || (argc > 0)) {
   11838           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   11839             :   }
   11840           0 :   result = (kdb::tools::StoragePlugin *)new kdb::tools::StoragePlugin();
   11841           0 :   DATA_PTR(self) = result;
   11842             :   return self;
   11843             : fail:
   11844             :   return Qnil;
   11845             : }
   11846             : 
   11847             : 
   11848             : SWIGINTERN void
   11849           0 : free_kdb_tools_StoragePlugin(void *self) {
   11850           0 :     kdb::tools::StoragePlugin *arg1 = (kdb::tools::StoragePlugin *)self;
   11851           0 :     delete arg1;
   11852           0 : }
   11853             : 
   11854             : 
   11855             : /*
   11856             :   Document-class: Kdbtools::ResolverPlugin < Kdbtools::kdb::tools::PluginCheckException
   11857             : 
   11858             :   Proxy of C++ Kdbtools::ResolverPlugin class
   11859             : 
   11860             : 
   11861             : */
   11862             : static swig_class SwigClassResolverPlugin;
   11863             : 
   11864             : SWIGINTERN VALUE
   11865             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   11866           0 : _wrap_ResolverPlugin_allocate(VALUE self)
   11867             : #else
   11868             : _wrap_ResolverPlugin_allocate(int argc, VALUE *argv, VALUE self)
   11869             : #endif
   11870             : {
   11871           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__ResolverPlugin);
   11872             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   11873             :   rb_obj_call_init(vresult, argc, argv);
   11874             : #endif
   11875           0 :   return vresult;
   11876             : }
   11877             : 
   11878             : 
   11879             : 
   11880             : /*
   11881             :   Document-method: Kdbtools::ResolverPlugin.new
   11882             : 
   11883             :   call-seq:
   11884             :     ResolverPlugin.new
   11885             : 
   11886             : Class constructor.
   11887             : 
   11888             : */
   11889             : SWIGINTERN VALUE
   11890           0 : _wrap_new_ResolverPlugin(int argc, VALUE *argv, VALUE self) {
   11891           0 :   kdb::tools::ResolverPlugin *result = 0 ;
   11892             :   
   11893           0 :   if ((argc < 0) || (argc > 0)) {
   11894           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   11895             :   }
   11896           0 :   result = (kdb::tools::ResolverPlugin *)new kdb::tools::ResolverPlugin();
   11897           0 :   DATA_PTR(self) = result;
   11898             :   return self;
   11899             : fail:
   11900             :   return Qnil;
   11901             : }
   11902             : 
   11903             : 
   11904             : SWIGINTERN void
   11905           0 : free_kdb_tools_ResolverPlugin(void *self) {
   11906           0 :     kdb::tools::ResolverPlugin *arg1 = (kdb::tools::ResolverPlugin *)self;
   11907           0 :     delete arg1;
   11908           0 : }
   11909             : 
   11910             : 
   11911             : /*
   11912             :   Document-class: Kdbtools::PluginNoContract < Kdbtools::kdb::tools::PluginCheckException
   11913             : 
   11914             :   Proxy of C++ Kdbtools::PluginNoContract class
   11915             : 
   11916             : 
   11917             : */
   11918             : static swig_class SwigClassPluginNoContract;
   11919             : 
   11920             : SWIGINTERN VALUE
   11921             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   11922           0 : _wrap_PluginNoContract_allocate(VALUE self)
   11923             : #else
   11924             : _wrap_PluginNoContract_allocate(int argc, VALUE *argv, VALUE self)
   11925             : #endif
   11926             : {
   11927           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__PluginNoContract);
   11928             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   11929             :   rb_obj_call_init(vresult, argc, argv);
   11930             : #endif
   11931           0 :   return vresult;
   11932             : }
   11933             : 
   11934             : 
   11935             : 
   11936             : /*
   11937             :   Document-method: Kdbtools::PluginNoContract.new
   11938             : 
   11939             :   call-seq:
   11940             :     PluginNoContract.new
   11941             : 
   11942             : Class constructor.
   11943             : 
   11944             : */
   11945             : SWIGINTERN VALUE
   11946           0 : _wrap_new_PluginNoContract(int argc, VALUE *argv, VALUE self) {
   11947           0 :   kdb::tools::PluginNoContract *result = 0 ;
   11948             :   
   11949           0 :   if ((argc < 0) || (argc > 0)) {
   11950           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   11951             :   }
   11952           0 :   result = (kdb::tools::PluginNoContract *)new kdb::tools::PluginNoContract();
   11953           0 :   DATA_PTR(self) = result;
   11954             :   return self;
   11955             : fail:
   11956             :   return Qnil;
   11957             : }
   11958             : 
   11959             : 
   11960             : SWIGINTERN void
   11961           0 : free_kdb_tools_PluginNoContract(void *self) {
   11962           0 :     kdb::tools::PluginNoContract *arg1 = (kdb::tools::PluginNoContract *)self;
   11963           0 :     delete arg1;
   11964           0 : }
   11965             : 
   11966             : 
   11967             : /*
   11968             :   Document-class: Kdbtools::PluginNoInfo < Kdbtools::kdb::tools::PluginCheckException
   11969             : 
   11970             :   Proxy of C++ Kdbtools::PluginNoInfo class
   11971             : 
   11972             : 
   11973             : */
   11974             : static swig_class SwigClassPluginNoInfo;
   11975             : 
   11976             : SWIGINTERN VALUE
   11977             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   11978           0 : _wrap_PluginNoInfo_allocate(VALUE self)
   11979             : #else
   11980             : _wrap_PluginNoInfo_allocate(int argc, VALUE *argv, VALUE self)
   11981             : #endif
   11982             : {
   11983           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__PluginNoInfo);
   11984             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   11985             :   rb_obj_call_init(vresult, argc, argv);
   11986             : #endif
   11987           0 :   return vresult;
   11988             : }
   11989             : 
   11990             : 
   11991             : 
   11992             : /*
   11993             :   Document-method: Kdbtools::PluginNoInfo.new
   11994             : 
   11995             :   call-seq:
   11996             :     PluginNoInfo.new
   11997             : 
   11998             : Class constructor.
   11999             : 
   12000             : */
   12001             : SWIGINTERN VALUE
   12002           0 : _wrap_new_PluginNoInfo(int argc, VALUE *argv, VALUE self) {
   12003           0 :   kdb::tools::PluginNoInfo *result = 0 ;
   12004             :   
   12005           0 :   if ((argc < 0) || (argc > 0)) {
   12006           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12007             :   }
   12008           0 :   result = (kdb::tools::PluginNoInfo *)new kdb::tools::PluginNoInfo();
   12009           0 :   DATA_PTR(self) = result;
   12010             :   return self;
   12011             : fail:
   12012             :   return Qnil;
   12013             : }
   12014             : 
   12015             : 
   12016             : SWIGINTERN void
   12017           0 : free_kdb_tools_PluginNoInfo(void *self) {
   12018           0 :     kdb::tools::PluginNoInfo *arg1 = (kdb::tools::PluginNoInfo *)self;
   12019           0 :     delete arg1;
   12020           0 : }
   12021             : 
   12022             : 
   12023             : /*
   12024             :   Document-class: Kdbtools::VersionInfoMismatch < Kdbtools::kdb::tools::PluginCheckException
   12025             : 
   12026             :   Proxy of C++ Kdbtools::VersionInfoMismatch class
   12027             : 
   12028             : 
   12029             : */
   12030             : static swig_class SwigClassVersionInfoMismatch;
   12031             : 
   12032             : SWIGINTERN VALUE
   12033             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   12034           0 : _wrap_VersionInfoMismatch_allocate(VALUE self)
   12035             : #else
   12036             : _wrap_VersionInfoMismatch_allocate(int argc, VALUE *argv, VALUE self)
   12037             : #endif
   12038             : {
   12039           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__VersionInfoMismatch);
   12040             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   12041             :   rb_obj_call_init(vresult, argc, argv);
   12042             : #endif
   12043           0 :   return vresult;
   12044             : }
   12045             : 
   12046             : 
   12047             : 
   12048             : /*
   12049             :   Document-method: Kdbtools::VersionInfoMismatch.new
   12050             : 
   12051             :   call-seq:
   12052             :     VersionInfoMismatch.new
   12053             : 
   12054             : Class constructor.
   12055             : 
   12056             : */
   12057             : SWIGINTERN VALUE
   12058           0 : _wrap_new_VersionInfoMismatch(int argc, VALUE *argv, VALUE self) {
   12059           0 :   kdb::tools::VersionInfoMismatch *result = 0 ;
   12060             :   
   12061           0 :   if ((argc < 0) || (argc > 0)) {
   12062           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12063             :   }
   12064           0 :   result = (kdb::tools::VersionInfoMismatch *)new kdb::tools::VersionInfoMismatch();
   12065           0 :   DATA_PTR(self) = result;
   12066             :   return self;
   12067             : fail:
   12068             :   return Qnil;
   12069             : }
   12070             : 
   12071             : 
   12072             : SWIGINTERN void
   12073           0 : free_kdb_tools_VersionInfoMismatch(void *self) {
   12074           0 :     kdb::tools::VersionInfoMismatch *arg1 = (kdb::tools::VersionInfoMismatch *)self;
   12075           0 :     delete arg1;
   12076           0 : }
   12077             : 
   12078             : 
   12079             : /*
   12080             :   Document-class: Kdbtools::PluginSpecVector
   12081             : 
   12082             :   Proxy of C++ Kdbtools::PluginSpecVector class
   12083             : 
   12084             : 
   12085             : */
   12086             : static swig_class SwigClassPluginSpecVector;
   12087             : 
   12088             : 
   12089             : /*
   12090             :   Document-method: Kdbtools::PluginSpecVector.dup
   12091             : 
   12092             :   call-seq:
   12093             :     dup -> PluginSpecVector
   12094             : 
   12095             : Create a duplicate of the class and unfreeze it if needed.
   12096             : */
   12097             : SWIGINTERN VALUE
   12098           0 : _wrap_PluginSpecVector_dup(int argc, VALUE *argv, VALUE self) {
   12099           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12100           0 :   void *argp1 = 0 ;
   12101           0 :   int res1 = 0 ;
   12102           0 :   std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *result = 0 ;
   12103           0 :   VALUE vresult = Qnil;
   12104             :   
   12105           0 :   if ((argc < 0) || (argc > 0)) {
   12106           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12107             :   }
   12108           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12109           0 :   if (!SWIG_IsOK(res1)) {
   12110           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","dup", 1, self )); 
   12111             :   }
   12112           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12113           0 :   result = (std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *)std_vector_Sl_kdb_tools_PluginSpec_Sg__dup(arg1);
   12114           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, SWIG_POINTER_OWN |  0 );
   12115             :   return vresult;
   12116             : fail:
   12117             :   return Qnil;
   12118             : }
   12119             : 
   12120             : 
   12121             : 
   12122             : /*
   12123             :   Document-method: Kdbtools::PluginSpecVector.inspect
   12124             : 
   12125             :   call-seq:
   12126             :     inspect -> VALUE
   12127             : 
   12128             : Inspect class and its contents.
   12129             : */
   12130             : SWIGINTERN VALUE
   12131           0 : _wrap_PluginSpecVector_inspect(int argc, VALUE *argv, VALUE self) {
   12132           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12133           0 :   void *argp1 = 0 ;
   12134           0 :   int res1 = 0 ;
   12135             :   VALUE result;
   12136           0 :   VALUE vresult = Qnil;
   12137             :   
   12138           0 :   if ((argc < 0) || (argc > 0)) {
   12139           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12140             :   }
   12141           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12142           0 :   if (!SWIG_IsOK(res1)) {
   12143           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","inspect", 1, self )); 
   12144             :   }
   12145           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12146           0 :   result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg__inspect(arg1);
   12147           0 :   vresult = result;
   12148             :   return vresult;
   12149             : fail:
   12150             :   return Qnil;
   12151             : }
   12152             : 
   12153             : 
   12154             : 
   12155             : /*
   12156             :   Document-method: Kdbtools::PluginSpecVector.to_a
   12157             : 
   12158             :   call-seq:
   12159             :     to_a -> VALUE
   12160             : 
   12161             : Convert PluginSpecVector to an Array.
   12162             : */
   12163             : SWIGINTERN VALUE
   12164           0 : _wrap_PluginSpecVector_to_a(int argc, VALUE *argv, VALUE self) {
   12165           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12166           0 :   void *argp1 = 0 ;
   12167           0 :   int res1 = 0 ;
   12168             :   VALUE result;
   12169           0 :   VALUE vresult = Qnil;
   12170             :   
   12171           0 :   if ((argc < 0) || (argc > 0)) {
   12172           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12173             :   }
   12174           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12175           0 :   if (!SWIG_IsOK(res1)) {
   12176           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","to_a", 1, self )); 
   12177             :   }
   12178           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12179           0 :   result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg__to_a(arg1);
   12180           0 :   vresult = result;
   12181             :   return vresult;
   12182             : fail:
   12183             :   return Qnil;
   12184             : }
   12185             : 
   12186             : 
   12187             : 
   12188             : /*
   12189             :   Document-method: Kdbtools::PluginSpecVector.to_s
   12190             : 
   12191             :   call-seq:
   12192             :     to_s -> VALUE
   12193             : 
   12194             : Convert class to a String representation.
   12195             : */
   12196             : SWIGINTERN VALUE
   12197           0 : _wrap_PluginSpecVector_to_s(int argc, VALUE *argv, VALUE self) {
   12198           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12199           0 :   void *argp1 = 0 ;
   12200           0 :   int res1 = 0 ;
   12201             :   VALUE result;
   12202           0 :   VALUE vresult = Qnil;
   12203             :   
   12204           0 :   if ((argc < 0) || (argc > 0)) {
   12205           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12206             :   }
   12207           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12208           0 :   if (!SWIG_IsOK(res1)) {
   12209           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","to_s", 1, self )); 
   12210             :   }
   12211           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12212           0 :   result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg__to_s(arg1);
   12213           0 :   vresult = result;
   12214             :   return vresult;
   12215             : fail:
   12216             :   return Qnil;
   12217             : }
   12218             : 
   12219             : 
   12220             : 
   12221             : /*
   12222             :   Document-method: Kdbtools::PluginSpecVector.slice
   12223             : 
   12224             :   call-seq:
   12225             :     slice(i, length) -> VALUE
   12226             : 
   12227             : Return a slice (portion of) the PluginSpecVector.
   12228             : */
   12229             : SWIGINTERN VALUE
   12230           0 : _wrap_PluginSpecVector_slice(int argc, VALUE *argv, VALUE self) {
   12231           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12232             :   std::vector< kdb::tools::PluginSpec >::difference_type arg2 ;
   12233             :   std::vector< kdb::tools::PluginSpec >::difference_type arg3 ;
   12234           0 :   void *argp1 = 0 ;
   12235           0 :   int res1 = 0 ;
   12236             :   ptrdiff_t val2 ;
   12237           0 :   int ecode2 = 0 ;
   12238             :   ptrdiff_t val3 ;
   12239           0 :   int ecode3 = 0 ;
   12240             :   VALUE result;
   12241           0 :   VALUE vresult = Qnil;
   12242             :   
   12243           0 :   if ((argc < 2) || (argc > 2)) {
   12244           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   12245             :   }
   12246           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12247           0 :   if (!SWIG_IsOK(res1)) {
   12248           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","slice", 1, self )); 
   12249             :   }
   12250           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12251           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   12252           0 :   if (!SWIG_IsOK(ecode2)) {
   12253           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::difference_type","slice", 2, argv[0] ));
   12254             :   } 
   12255           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::difference_type >(val2);
   12256           0 :   ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
   12257           0 :   if (!SWIG_IsOK(ecode3)) {
   12258           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::difference_type","slice", 3, argv[1] ));
   12259             :   } 
   12260           0 :   arg3 = static_cast< std::vector< kdb::tools::PluginSpec >::difference_type >(val3);
   12261             :   try {
   12262           0 :     result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg__slice(arg1,arg2,arg3);
   12263             :   }
   12264           0 :   catch(std::invalid_argument &_e) {
   12265           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
   12266             :   }
   12267             :   
   12268           0 :   vresult = result;
   12269             :   return vresult;
   12270             : fail:
   12271             :   return Qnil;
   12272             : }
   12273             : 
   12274             : 
   12275             : 
   12276             : /*
   12277             :   Document-method: Kdbtools::PluginSpecVector.each
   12278             : 
   12279             :   call-seq:
   12280             :     each -> PluginSpecVector
   12281             : 
   12282             : Iterate thru each element in the PluginSpecVector.  A block must be provided.
   12283             : */
   12284             : SWIGINTERN VALUE
   12285           0 : _wrap_PluginSpecVector_each(int argc, VALUE *argv, VALUE self) {
   12286           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12287           0 :   void *argp1 = 0 ;
   12288           0 :   int res1 = 0 ;
   12289           0 :   std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *result = 0 ;
   12290           0 :   VALUE vresult = Qnil;
   12291             :   
   12292           0 :   if ((argc < 0) || (argc > 0)) {
   12293           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12294             :   }
   12295           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12296           0 :   if (!SWIG_IsOK(res1)) {
   12297           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","each", 1, self )); 
   12298             :   }
   12299           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12300           0 :   result = (std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *)std_vector_Sl_kdb_tools_PluginSpec_Sg__each(arg1);
   12301           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12302             :   return vresult;
   12303             : fail:
   12304             :   return Qnil;
   12305             : }
   12306             : 
   12307             : 
   12308             : 
   12309             : /*
   12310             :   Document-method: Kdbtools::PluginSpecVector.__delete_2__
   12311             : 
   12312             :   call-seq:
   12313             :     __delete_2__(PluginSpec i) -> VALUE
   12314             : 
   12315             : An instance method.
   12316             : 
   12317             : */
   12318             : SWIGINTERN VALUE
   12319           0 : _wrap_PluginSpecVector___delete_2__(int argc, VALUE *argv, VALUE self) {
   12320           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12321           0 :   std::vector< kdb::tools::PluginSpec >::value_type *arg2 = 0 ;
   12322           0 :   void *argp1 = 0 ;
   12323           0 :   int res1 = 0 ;
   12324             :   void *argp2 ;
   12325           0 :   int res2 = 0 ;
   12326             :   VALUE result;
   12327           0 :   VALUE vresult = Qnil;
   12328             :   
   12329           0 :   if ((argc < 1) || (argc > 1)) {
   12330           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   12331             :   }
   12332           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12333           0 :   if (!SWIG_IsOK(res1)) {
   12334           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","__delete2__", 1, self )); 
   12335             :   }
   12336           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12337           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   12338           0 :   if (!SWIG_IsOK(res2)) {
   12339           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::value_type const &","__delete2__", 2, argv[0] )); 
   12340             :   }
   12341           0 :   if (!argp2) {
   12342           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::PluginSpec >::value_type const &","__delete2__", 2, argv[0])); 
   12343             :   }
   12344           0 :   arg2 = reinterpret_cast< std::vector< kdb::tools::PluginSpec >::value_type * >(argp2);
   12345           0 :   result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg____delete2__(arg1,(kdb::tools::PluginSpec const &)*arg2);
   12346           0 :   vresult = result;
   12347             :   return vresult;
   12348             : fail:
   12349             :   return Qnil;
   12350             : }
   12351             : 
   12352             : 
   12353             : 
   12354             : /*
   12355             :   Document-method: Kdbtools::PluginSpecVector.select
   12356             : 
   12357             :   call-seq:
   12358             :     select -> PluginSpecVector
   12359             : 
   12360             : Iterate thru each element in the PluginSpecVector and select those that match a condition.  A block must be provided.
   12361             : */
   12362             : SWIGINTERN VALUE
   12363           0 : _wrap_PluginSpecVector_select(int argc, VALUE *argv, VALUE self) {
   12364           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12365           0 :   void *argp1 = 0 ;
   12366           0 :   int res1 = 0 ;
   12367           0 :   std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *result = 0 ;
   12368           0 :   VALUE vresult = Qnil;
   12369             :   
   12370           0 :   if ((argc < 0) || (argc > 0)) {
   12371           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12372             :   }
   12373           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12374           0 :   if (!SWIG_IsOK(res1)) {
   12375           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","select", 1, self )); 
   12376             :   }
   12377           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12378           0 :   result = (std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *)std_vector_Sl_kdb_tools_PluginSpec_Sg__select(arg1);
   12379           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, SWIG_POINTER_OWN |  0 );
   12380             :   return vresult;
   12381             : fail:
   12382             :   return Qnil;
   12383             : }
   12384             : 
   12385             : 
   12386             : 
   12387             : /*
   12388             :   Document-method: Kdbtools::PluginSpecVector.delete_at
   12389             : 
   12390             :   call-seq:
   12391             :     delete_at(i) -> VALUE
   12392             : 
   12393             : Delete an element at a certain index.
   12394             : */
   12395             : SWIGINTERN VALUE
   12396           0 : _wrap_PluginSpecVector_delete_at(int argc, VALUE *argv, VALUE self) {
   12397           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12398             :   std::vector< kdb::tools::PluginSpec >::difference_type arg2 ;
   12399           0 :   void *argp1 = 0 ;
   12400           0 :   int res1 = 0 ;
   12401             :   ptrdiff_t val2 ;
   12402           0 :   int ecode2 = 0 ;
   12403             :   VALUE result;
   12404           0 :   VALUE vresult = Qnil;
   12405             :   
   12406           0 :   if ((argc < 1) || (argc > 1)) {
   12407           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   12408             :   }
   12409           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12410           0 :   if (!SWIG_IsOK(res1)) {
   12411           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","delete_at", 1, self )); 
   12412             :   }
   12413           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12414           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   12415           0 :   if (!SWIG_IsOK(ecode2)) {
   12416           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::difference_type","delete_at", 2, argv[0] ));
   12417             :   } 
   12418           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::difference_type >(val2);
   12419           0 :   result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg__delete_at(arg1,arg2);
   12420           0 :   vresult = result;
   12421             :   return vresult;
   12422             : fail:
   12423             :   return Qnil;
   12424             : }
   12425             : 
   12426             : 
   12427             : 
   12428             : /*
   12429             :   Document-method: Kdbtools::PluginSpecVector.at
   12430             : 
   12431             :   call-seq:
   12432             :     at(i) -> VALUE
   12433             : 
   12434             : Return element at a certain index.
   12435             : */
   12436             : SWIGINTERN VALUE
   12437           0 : _wrap_PluginSpecVector_at(int argc, VALUE *argv, VALUE self) {
   12438           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12439             :   std::vector< kdb::tools::PluginSpec >::difference_type arg2 ;
   12440           0 :   void *argp1 = 0 ;
   12441           0 :   int res1 = 0 ;
   12442             :   ptrdiff_t val2 ;
   12443           0 :   int ecode2 = 0 ;
   12444             :   VALUE result;
   12445           0 :   VALUE vresult = Qnil;
   12446             :   
   12447           0 :   if ((argc < 1) || (argc > 1)) {
   12448           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   12449             :   }
   12450           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12451           0 :   if (!SWIG_IsOK(res1)) {
   12452           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > const *","at", 1, self )); 
   12453             :   }
   12454           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12455           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   12456           0 :   if (!SWIG_IsOK(ecode2)) {
   12457           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::difference_type","at", 2, argv[0] ));
   12458             :   } 
   12459           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::difference_type >(val2);
   12460           0 :   result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg__at((std::vector< kdb::tools::PluginSpec > const *)arg1,arg2);
   12461           0 :   vresult = result;
   12462             :   return vresult;
   12463             : fail:
   12464             :   return Qnil;
   12465             : }
   12466             : 
   12467             : 
   12468             : 
   12469             : /*
   12470             :   Document-method: Kdbtools::PluginSpecVector.[]
   12471             : 
   12472             :   call-seq:
   12473             :     [](i, length) -> VALUE
   12474             :     [](i) -> VALUE
   12475             :     [](i) -> VALUE
   12476             : 
   12477             : Element accessor/slicing.
   12478             : */
   12479             : SWIGINTERN VALUE
   12480           0 : _wrap_PluginSpecVector___getitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
   12481           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12482             :   std::vector< kdb::tools::PluginSpec >::difference_type arg2 ;
   12483             :   std::vector< kdb::tools::PluginSpec >::difference_type arg3 ;
   12484           0 :   void *argp1 = 0 ;
   12485           0 :   int res1 = 0 ;
   12486             :   ptrdiff_t val2 ;
   12487           0 :   int ecode2 = 0 ;
   12488             :   ptrdiff_t val3 ;
   12489           0 :   int ecode3 = 0 ;
   12490             :   VALUE result;
   12491           0 :   VALUE vresult = Qnil;
   12492             :   
   12493           0 :   if ((argc < 2) || (argc > 2)) {
   12494           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   12495             :   }
   12496           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12497           0 :   if (!SWIG_IsOK(res1)) {
   12498           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > const *","__getitem__", 1, self )); 
   12499             :   }
   12500           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12501           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   12502           0 :   if (!SWIG_IsOK(ecode2)) {
   12503           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::difference_type","__getitem__", 2, argv[0] ));
   12504             :   } 
   12505           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::difference_type >(val2);
   12506           0 :   ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
   12507           0 :   if (!SWIG_IsOK(ecode3)) {
   12508           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::difference_type","__getitem__", 3, argv[1] ));
   12509             :   } 
   12510           0 :   arg3 = static_cast< std::vector< kdb::tools::PluginSpec >::difference_type >(val3);
   12511             :   try {
   12512           0 :     result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg____getitem____SWIG_0((std::vector< kdb::tools::PluginSpec > const *)arg1,arg2,arg3);
   12513             :   }
   12514           0 :   catch(std::invalid_argument &_e) {
   12515           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
   12516             :   }
   12517             :   
   12518           0 :   vresult = result;
   12519             :   return vresult;
   12520             : fail:
   12521             :   return Qnil;
   12522             : }
   12523             : 
   12524             : 
   12525             : SWIGINTERN VALUE
   12526           0 : _wrap_PluginSpecVector___getitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
   12527           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12528             :   std::vector< kdb::tools::PluginSpec >::difference_type arg2 ;
   12529           0 :   void *argp1 = 0 ;
   12530           0 :   int res1 = 0 ;
   12531             :   ptrdiff_t val2 ;
   12532           0 :   int ecode2 = 0 ;
   12533             :   VALUE result;
   12534           0 :   VALUE vresult = Qnil;
   12535             :   
   12536           0 :   if ((argc < 1) || (argc > 1)) {
   12537           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   12538             :   }
   12539           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12540           0 :   if (!SWIG_IsOK(res1)) {
   12541           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > const *","__getitem__", 1, self )); 
   12542             :   }
   12543           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12544           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   12545           0 :   if (!SWIG_IsOK(ecode2)) {
   12546           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::difference_type","__getitem__", 2, argv[0] ));
   12547             :   } 
   12548           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::difference_type >(val2);
   12549           0 :   result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg____getitem____SWIG_1((std::vector< kdb::tools::PluginSpec > const *)arg1,arg2);
   12550           0 :   vresult = result;
   12551             :   return vresult;
   12552             : fail:
   12553             :   return Qnil;
   12554             : }
   12555             : 
   12556             : 
   12557             : SWIGINTERN VALUE
   12558           0 : _wrap_PluginSpecVector___getitem____SWIG_2(int argc, VALUE *argv, VALUE self) {
   12559           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12560           0 :   VALUE arg2 = (VALUE) 0 ;
   12561           0 :   void *argp1 = 0 ;
   12562           0 :   int res1 = 0 ;
   12563             :   VALUE result;
   12564           0 :   VALUE vresult = Qnil;
   12565             :   
   12566           0 :   if ((argc < 1) || (argc > 1)) {
   12567           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   12568             :   }
   12569           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12570           0 :   if (!SWIG_IsOK(res1)) {
   12571           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > const *","__getitem__", 1, self )); 
   12572             :   }
   12573           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12574           0 :   arg2 = argv[0];
   12575             :   try {
   12576           0 :     result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg____getitem____SWIG_2((std::vector< kdb::tools::PluginSpec > const *)arg1,arg2);
   12577             :   }
   12578           0 :   catch(std::invalid_argument &_e) {
   12579           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
   12580             :   }
   12581             :   
   12582           0 :   vresult = result;
   12583             :   return vresult;
   12584             : fail:
   12585             :   return Qnil;
   12586             : }
   12587             : 
   12588             : 
   12589           0 : SWIGINTERN VALUE _wrap_PluginSpecVector___getitem__(int nargs, VALUE *args, VALUE self) {
   12590             :   int argc;
   12591             :   VALUE argv[4];
   12592             :   int ii;
   12593             :   
   12594           0 :   argc = nargs + 1;
   12595             :   argv[0] = self;
   12596           0 :   if (argc > 4) SWIG_fail;
   12597           0 :   for (ii = 1; (ii < argc); ++ii) {
   12598           0 :     argv[ii] = args[ii-1];
   12599             :   }
   12600           0 :   if (argc == 2) {
   12601           0 :     int _v = 0;
   12602             :     {
   12603             :       {
   12604           0 :         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
   12605           0 :         _v = SWIG_CheckState(res);
   12606             :       }
   12607             :     }
   12608           0 :     if (!_v) goto check_1;
   12609           0 :     return _wrap_PluginSpecVector___getitem____SWIG_1(nargs, args, self);
   12610             :   }
   12611             : check_1:
   12612             :   
   12613           0 :   if (argc == 2) {
   12614           0 :     return _wrap_PluginSpecVector___getitem____SWIG_2(nargs, args, self);
   12615             :   }
   12616           0 :   if (argc == 3) {
   12617           0 :     return _wrap_PluginSpecVector___getitem____SWIG_0(nargs, args, self);
   12618             :   }
   12619             :   
   12620             : fail:
   12621             :   Ruby_Format_OverloadedError( argc, 4, "__getitem__", 
   12622             :     "    VALUE __getitem__(std::vector< kdb::tools::PluginSpec >::difference_type i, std::vector< kdb::tools::PluginSpec >::difference_type length)\n"
   12623             :     "    VALUE __getitem__(std::vector< kdb::tools::PluginSpec >::difference_type i)\n"
   12624           0 :     "    VALUE __getitem__(VALUE i)\n");
   12625             :   
   12626             :   return Qnil;
   12627             : }
   12628             : 
   12629             : 
   12630             : 
   12631             : /*
   12632             :   Document-method: Kdbtools::PluginSpecVector.[]=
   12633             : 
   12634             :   call-seq:
   12635             :     []=(i, x) -> VALUE
   12636             :     []=(i, length, v) -> VALUE
   12637             : 
   12638             : Element setter/slicing.
   12639             : */
   12640             : SWIGINTERN VALUE
   12641           0 : _wrap_PluginSpecVector___setitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
   12642           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12643             :   std::vector< kdb::tools::PluginSpec >::difference_type arg2 ;
   12644           0 :   std::vector< kdb::tools::PluginSpec >::value_type *arg3 = 0 ;
   12645           0 :   void *argp1 = 0 ;
   12646           0 :   int res1 = 0 ;
   12647             :   ptrdiff_t val2 ;
   12648           0 :   int ecode2 = 0 ;
   12649             :   void *argp3 ;
   12650           0 :   int res3 = 0 ;
   12651             :   VALUE result;
   12652           0 :   VALUE vresult = Qnil;
   12653             :   
   12654           0 :   if ((argc < 2) || (argc > 2)) {
   12655           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   12656             :   }
   12657           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12658           0 :   if (!SWIG_IsOK(res1)) {
   12659           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","__setitem__", 1, self )); 
   12660             :   }
   12661           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12662           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   12663           0 :   if (!SWIG_IsOK(ecode2)) {
   12664           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::difference_type","__setitem__", 2, argv[0] ));
   12665             :   } 
   12666           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::difference_type >(val2);
   12667           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   12668           0 :   if (!SWIG_IsOK(res3)) {
   12669           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::value_type const &","__setitem__", 3, argv[1] )); 
   12670             :   }
   12671           0 :   if (!argp3) {
   12672           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::PluginSpec >::value_type const &","__setitem__", 3, argv[1])); 
   12673             :   }
   12674           0 :   arg3 = reinterpret_cast< std::vector< kdb::tools::PluginSpec >::value_type * >(argp3);
   12675             :   try {
   12676           0 :     result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg____setitem____SWIG_0(arg1,arg2,(kdb::tools::PluginSpec const &)*arg3);
   12677             :   }
   12678           0 :   catch(std::invalid_argument &_e) {
   12679           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
   12680             :   }
   12681           0 :   catch(std::out_of_range &_e) {
   12682           0 :     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   12683             :   }
   12684             :   
   12685           0 :   vresult = result;
   12686             :   return vresult;
   12687             : fail:
   12688             :   return Qnil;
   12689             : }
   12690             : 
   12691             : 
   12692             : SWIGINTERN VALUE
   12693           0 : _wrap_PluginSpecVector___setitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
   12694           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12695             :   std::vector< kdb::tools::PluginSpec >::difference_type arg2 ;
   12696             :   std::vector< kdb::tools::PluginSpec >::difference_type arg3 ;
   12697           0 :   std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *arg4 = 0 ;
   12698           0 :   void *argp1 = 0 ;
   12699           0 :   int res1 = 0 ;
   12700             :   ptrdiff_t val2 ;
   12701           0 :   int ecode2 = 0 ;
   12702             :   ptrdiff_t val3 ;
   12703           0 :   int ecode3 = 0 ;
   12704           0 :   int res4 = SWIG_OLDOBJ ;
   12705             :   VALUE result;
   12706           0 :   VALUE vresult = Qnil;
   12707             :   
   12708           0 :   if ((argc < 3) || (argc > 3)) {
   12709           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   12710             :   }
   12711           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12712           0 :   if (!SWIG_IsOK(res1)) {
   12713           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","__setitem__", 1, self )); 
   12714             :   }
   12715           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12716           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   12717           0 :   if (!SWIG_IsOK(ecode2)) {
   12718           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::difference_type","__setitem__", 2, argv[0] ));
   12719             :   } 
   12720           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::difference_type >(val2);
   12721           0 :   ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
   12722           0 :   if (!SWIG_IsOK(ecode3)) {
   12723           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::difference_type","__setitem__", 3, argv[1] ));
   12724             :   } 
   12725           0 :   arg3 = static_cast< std::vector< kdb::tools::PluginSpec >::difference_type >(val3);
   12726             :   {
   12727           0 :     std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *ptr = (std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *)0;
   12728           0 :     res4 = swig::asptr(argv[2], &ptr);
   12729           0 :     if (!SWIG_IsOK(res4)) {
   12730           0 :       SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > const &","__setitem__", 4, argv[2] )); 
   12731             :     }
   12732           0 :     if (!ptr) {
   12733           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > const &","__setitem__", 4, argv[2])); 
   12734             :     }
   12735           0 :     arg4 = ptr;
   12736             :   }
   12737             :   try {
   12738           0 :     result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg____setitem____SWIG_1(arg1,arg2,arg3,(std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > const &)*arg4);
   12739             :   }
   12740           0 :   catch(std::invalid_argument &_e) {
   12741           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
   12742             :   }
   12743             :   
   12744           0 :   vresult = result;
   12745           0 :   if (SWIG_IsNewObj(res4)) delete arg4;
   12746             :   return vresult;
   12747             : fail:
   12748             :   if (SWIG_IsNewObj(res4)) delete arg4;
   12749             :   return Qnil;
   12750             : }
   12751             : 
   12752             : 
   12753           0 : SWIGINTERN VALUE _wrap_PluginSpecVector___setitem__(int nargs, VALUE *args, VALUE self) {
   12754             :   int argc;
   12755             :   VALUE argv[5];
   12756             :   int ii;
   12757             :   
   12758           0 :   argc = nargs + 1;
   12759             :   argv[0] = self;
   12760           0 :   if (argc > 5) SWIG_fail;
   12761             :   for (ii = 1; (ii < argc); ++ii) {
   12762             :     argv[ii] = args[ii-1];
   12763             :   }
   12764           0 :   if (argc == 3) {
   12765           0 :     return _wrap_PluginSpecVector___setitem____SWIG_0(nargs, args, self);
   12766             :   }
   12767           0 :   if (argc == 4) {
   12768           0 :     return _wrap_PluginSpecVector___setitem____SWIG_1(nargs, args, self);
   12769             :   }
   12770             :   
   12771             : fail:
   12772             :   Ruby_Format_OverloadedError( argc, 5, "__setitem__", 
   12773             :     "    VALUE __setitem__(std::vector< kdb::tools::PluginSpec >::difference_type i, std::vector< kdb::tools::PluginSpec >::value_type const &x)\n"
   12774           0 :     "    VALUE __setitem__(std::vector< kdb::tools::PluginSpec >::difference_type i, std::vector< kdb::tools::PluginSpec >::difference_type length, std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > const &v)\n");
   12775             :   
   12776             :   return Qnil;
   12777             : }
   12778             : 
   12779             : 
   12780             : 
   12781             : /*
   12782             :   Document-method: Kdbtools::PluginSpecVector.reject_bang
   12783             : 
   12784             :   call-seq:
   12785             :     reject_bang -> PluginSpecVector
   12786             : 
   12787             : Iterate thru each element in the PluginSpecVector and reject those that fail a condition.  A block must be provided.  PluginSpecVector is modified in place.
   12788             : */
   12789             : SWIGINTERN VALUE
   12790           0 : _wrap_PluginSpecVector_reject_bang(int argc, VALUE *argv, VALUE self) {
   12791           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12792           0 :   void *argp1 = 0 ;
   12793           0 :   int res1 = 0 ;
   12794           0 :   std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *result = 0 ;
   12795           0 :   VALUE vresult = Qnil;
   12796             :   
   12797           0 :   if ((argc < 0) || (argc > 0)) {
   12798           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12799             :   }
   12800           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12801           0 :   if (!SWIG_IsOK(res1)) {
   12802           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","reject_bang", 1, self )); 
   12803             :   }
   12804           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12805           0 :   result = (std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *)std_vector_Sl_kdb_tools_PluginSpec_Sg__reject_bang(arg1);
   12806           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12807             :   return vresult;
   12808             : fail:
   12809             :   return Qnil;
   12810             : }
   12811             : 
   12812             : 
   12813             : 
   12814             : /*
   12815             :   Document-method: Kdbtools::PluginSpecVector.pop
   12816             : 
   12817             :   call-seq:
   12818             :     pop -> VALUE
   12819             : 
   12820             : Remove and return element at the end of the PluginSpecVector.
   12821             : */
   12822             : SWIGINTERN VALUE
   12823           0 : _wrap_PluginSpecVector_pop(int argc, VALUE *argv, VALUE self) {
   12824           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12825           0 :   void *argp1 = 0 ;
   12826           0 :   int res1 = 0 ;
   12827             :   VALUE result;
   12828           0 :   VALUE vresult = Qnil;
   12829             :   
   12830           0 :   if ((argc < 0) || (argc > 0)) {
   12831           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12832             :   }
   12833           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12834           0 :   if (!SWIG_IsOK(res1)) {
   12835           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","pop", 1, self )); 
   12836             :   }
   12837           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12838           0 :   result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg__pop(arg1);
   12839           0 :   vresult = result;
   12840             :   return vresult;
   12841             : fail:
   12842             :   return Qnil;
   12843             : }
   12844             : 
   12845             : 
   12846             : 
   12847             : /*
   12848             :   Document-method: Kdbtools::PluginSpecVector.push
   12849             : 
   12850             :   call-seq:
   12851             :     push(e) -> PluginSpec
   12852             : 
   12853             : Add an element at the end of the PluginSpecVector.
   12854             : */
   12855             : SWIGINTERN VALUE
   12856           0 : _wrap_PluginSpecVector_push(int argc, VALUE *argv, VALUE self) {
   12857           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12858           0 :   std::vector< kdb::tools::PluginSpec >::value_type *arg2 = 0 ;
   12859           0 :   void *argp1 = 0 ;
   12860           0 :   int res1 = 0 ;
   12861             :   void *argp2 ;
   12862           0 :   int res2 = 0 ;
   12863           0 :   std::vector< kdb::tools::PluginSpec >::value_type result;
   12864           0 :   VALUE vresult = Qnil;
   12865             :   
   12866           0 :   if ((argc < 1) || (argc > 1)) {
   12867           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   12868             :   }
   12869           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12870           0 :   if (!SWIG_IsOK(res1)) {
   12871           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","push", 1, self )); 
   12872             :   }
   12873           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12874           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   12875           0 :   if (!SWIG_IsOK(res2)) {
   12876           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::value_type const &","push", 2, argv[0] )); 
   12877             :   }
   12878           0 :   if (!argp2) {
   12879           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::PluginSpec >::value_type const &","push", 2, argv[0])); 
   12880             :   }
   12881           0 :   arg2 = reinterpret_cast< std::vector< kdb::tools::PluginSpec >::value_type * >(argp2);
   12882           0 :   result = std_vector_Sl_kdb_tools_PluginSpec_Sg__push(arg1,(kdb::tools::PluginSpec const &)*arg2);
   12883           0 :   vresult = SWIG_NewPointerObj((new std::vector< kdb::tools::PluginSpec >::value_type(static_cast< const std::vector< kdb::tools::PluginSpec >::value_type& >(result))), SWIGTYPE_p_kdb__tools__PluginSpec, SWIG_POINTER_OWN |  0 );
   12884             :   return vresult;
   12885             : fail:
   12886             :   return Qnil;
   12887             : }
   12888             : 
   12889             : 
   12890             : 
   12891             : /*
   12892             :   Document-method: Kdbtools::PluginSpecVector.reject
   12893             : 
   12894             :   call-seq:
   12895             :     reject -> PluginSpecVector
   12896             : 
   12897             : Iterate thru each element in the PluginSpecVector and reject those that fail a condition returning a new PluginSpecVector.  A block must be provided.
   12898             : */
   12899             : SWIGINTERN VALUE
   12900           0 : _wrap_PluginSpecVector_reject(int argc, VALUE *argv, VALUE self) {
   12901           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12902           0 :   void *argp1 = 0 ;
   12903           0 :   int res1 = 0 ;
   12904           0 :   std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *result = 0 ;
   12905           0 :   VALUE vresult = Qnil;
   12906             :   
   12907           0 :   if ((argc < 0) || (argc > 0)) {
   12908           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12909             :   }
   12910           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12911           0 :   if (!SWIG_IsOK(res1)) {
   12912           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","reject", 1, self )); 
   12913             :   }
   12914           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12915           0 :   result = (std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *)std_vector_Sl_kdb_tools_PluginSpec_Sg__reject(arg1);
   12916           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, SWIG_POINTER_OWN |  0 );
   12917             :   return vresult;
   12918             : fail:
   12919             :   return Qnil;
   12920             : }
   12921             : 
   12922             : 
   12923             : 
   12924             : /*
   12925             :   Document-method: Kdbtools::PluginSpecVector.shift
   12926             : 
   12927             :   call-seq:
   12928             :     shift -> VALUE
   12929             : 
   12930             : Remove and return element at the beginning of the PluginSpecVector.
   12931             : */
   12932             : SWIGINTERN VALUE
   12933           0 : _wrap_PluginSpecVector_shift(int argc, VALUE *argv, VALUE self) {
   12934           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12935           0 :   void *argp1 = 0 ;
   12936           0 :   int res1 = 0 ;
   12937             :   VALUE result;
   12938           0 :   VALUE vresult = Qnil;
   12939             :   
   12940           0 :   if ((argc < 0) || (argc > 0)) {
   12941           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   12942             :   }
   12943           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12944           0 :   if (!SWIG_IsOK(res1)) {
   12945           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","shift", 1, self )); 
   12946             :   }
   12947           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12948           0 :   result = (VALUE)std_vector_Sl_kdb_tools_PluginSpec_Sg__shift(arg1);
   12949           0 :   vresult = result;
   12950             :   return vresult;
   12951             : fail:
   12952             :   return Qnil;
   12953             : }
   12954             : 
   12955             : 
   12956             : 
   12957             : /*
   12958             :   Document-method: Kdbtools::PluginSpecVector.insert
   12959             : 
   12960             :   call-seq:
   12961             :     insert(pos, argc) -> PluginSpecVector
   12962             : 
   12963             : Insert one or more new elements in the PluginSpecVector.
   12964             : */
   12965             : SWIGINTERN VALUE
   12966           0 : _wrap_PluginSpecVector_insert(int argc, VALUE *argv, VALUE self) {
   12967           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   12968             :   std::vector< kdb::tools::PluginSpec >::difference_type arg2 ;
   12969             :   int arg3 ;
   12970           0 :   VALUE *arg4 = (VALUE *) 0 ;
   12971           0 :   void *arg5 = 0 ;
   12972           0 :   void *argp1 = 0 ;
   12973           0 :   int res1 = 0 ;
   12974             :   ptrdiff_t val2 ;
   12975           0 :   int ecode2 = 0 ;
   12976           0 :   std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *result = 0 ;
   12977           0 :   VALUE vresult = Qnil;
   12978             :   
   12979           0 :   if (argc < 2) {
   12980           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   12981             :   }
   12982           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12983           0 :   if (!SWIG_IsOK(res1)) {
   12984           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","insert", 1, self )); 
   12985             :   }
   12986           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   12987           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   12988           0 :   if (!SWIG_IsOK(ecode2)) {
   12989           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::difference_type","insert", 2, argv[0] ));
   12990             :   } 
   12991           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::difference_type >(val2);
   12992             :   {
   12993           0 :     arg3 = argc - 1;
   12994           0 :     arg4 = argv + 1;
   12995             :   }
   12996           0 :   result = (std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *)std_vector_Sl_kdb_tools_PluginSpec_Sg__insert(arg1,arg2,arg3,arg4,arg5);
   12997           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   12998             :   return vresult;
   12999             : fail:
   13000             :   return Qnil;
   13001             : }
   13002             : 
   13003             : 
   13004             : 
   13005             : /*
   13006             :   Document-method: Kdbtools::PluginSpecVector.unshift
   13007             : 
   13008             :   call-seq:
   13009             :     unshift(argc) -> PluginSpecVector
   13010             : 
   13011             : Add one or more elements at the beginning of the PluginSpecVector.
   13012             : */
   13013             : SWIGINTERN VALUE
   13014           0 : _wrap_PluginSpecVector_unshift(int argc, VALUE *argv, VALUE self) {
   13015           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13016             :   int arg2 ;
   13017           0 :   VALUE *arg3 = (VALUE *) 0 ;
   13018           0 :   void *arg4 = 0 ;
   13019           0 :   void *argp1 = 0 ;
   13020           0 :   int res1 = 0 ;
   13021           0 :   std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *result = 0 ;
   13022           0 :   VALUE vresult = Qnil;
   13023             :   
   13024           0 :   if (argc < 1) {
   13025           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   13026             :   }
   13027           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13028           0 :   if (!SWIG_IsOK(res1)) {
   13029           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","unshift", 1, self )); 
   13030             :   }
   13031           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13032             :   {
   13033           0 :     arg2 = argc;
   13034           0 :     arg3 = argv;
   13035             :   }
   13036           0 :   result = (std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *)std_vector_Sl_kdb_tools_PluginSpec_Sg__unshift(arg1,arg2,arg3,arg4);
   13037           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13038             :   return vresult;
   13039             : fail:
   13040             :   return Qnil;
   13041             : }
   13042             : 
   13043             : 
   13044             : 
   13045             : /*
   13046             :   Document-method: Kdbtools::PluginSpecVector.new
   13047             : 
   13048             :   call-seq:
   13049             :     PluginSpecVector.new
   13050             :     PluginSpecVector.new(PluginSpecVector arg2)
   13051             :     PluginSpecVector.new(std::vector< kdb::tools::PluginSpec >::size_type size)
   13052             :     PluginSpecVector.new(std::vector< kdb::tools::PluginSpec >::size_type size, PluginSpec value)
   13053             : 
   13054             : Class constructor.
   13055             : 
   13056             : */
   13057             : SWIGINTERN VALUE
   13058           0 : _wrap_new_PluginSpecVector__SWIG_0(int argc, VALUE *argv, VALUE self) {
   13059           0 :   std::vector< kdb::tools::PluginSpec > *result = 0 ;
   13060             :   
   13061           0 :   if ((argc < 0) || (argc > 0)) {
   13062           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   13063             :   }
   13064           0 :   result = (std::vector< kdb::tools::PluginSpec > *)new std::vector< kdb::tools::PluginSpec >();
   13065           0 :   DATA_PTR(self) = result;
   13066             :   return self;
   13067             : fail:
   13068             :   return Qnil;
   13069             : }
   13070             : 
   13071             : 
   13072             : SWIGINTERN VALUE
   13073           0 : _wrap_new_PluginSpecVector__SWIG_1(int argc, VALUE *argv, VALUE self) {
   13074           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = 0 ;
   13075           0 :   int res1 = SWIG_OLDOBJ ;
   13076           0 :   std::vector< kdb::tools::PluginSpec > *result = 0 ;
   13077             :   
   13078           0 :   if ((argc < 1) || (argc > 1)) {
   13079           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   13080             :   }
   13081             :   {
   13082           0 :     std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *ptr = (std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *)0;
   13083           0 :     res1 = swig::asptr(argv[0], &ptr);
   13084           0 :     if (!SWIG_IsOK(res1)) {
   13085           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > const &","vector<(kdb::tools::PluginSpec)>", 1, argv[0] )); 
   13086             :     }
   13087           0 :     if (!ptr) {
   13088           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::PluginSpec > const &","vector<(kdb::tools::PluginSpec)>", 1, argv[0])); 
   13089             :     }
   13090           0 :     arg1 = ptr;
   13091             :   }
   13092           0 :   result = (std::vector< kdb::tools::PluginSpec > *)new std::vector< kdb::tools::PluginSpec >((std::vector< kdb::tools::PluginSpec > const &)*arg1);
   13093           0 :   DATA_PTR(self) = result;
   13094           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
   13095             :   return self;
   13096             : fail:
   13097             :   if (SWIG_IsNewObj(res1)) delete arg1;
   13098             :   return Qnil;
   13099             : }
   13100             : 
   13101             : 
   13102             : 
   13103             : /*
   13104             :   Document-method: Kdbtools::PluginSpecVector.empty
   13105             : 
   13106             :   call-seq:
   13107             :     empty -> bool
   13108             : 
   13109             : Check if the PluginSpecVector is empty or not.
   13110             : */
   13111             : SWIGINTERN VALUE
   13112           0 : _wrap_PluginSpecVector_empty(int argc, VALUE *argv, VALUE self) {
   13113           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13114           0 :   void *argp1 = 0 ;
   13115           0 :   int res1 = 0 ;
   13116             :   bool result;
   13117           0 :   VALUE vresult = Qnil;
   13118             :   
   13119           0 :   if ((argc < 0) || (argc > 0)) {
   13120           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   13121             :   }
   13122           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13123           0 :   if (!SWIG_IsOK(res1)) {
   13124           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > const *","empty", 1, self )); 
   13125             :   }
   13126           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13127           0 :   result = (bool)((std::vector< kdb::tools::PluginSpec > const *)arg1)->empty();
   13128           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   13129             :   return vresult;
   13130             : fail:
   13131             :   return Qnil;
   13132             : }
   13133             : 
   13134             : 
   13135             : 
   13136             : /*
   13137             :   Document-method: Kdbtools::PluginSpecVector.size
   13138             : 
   13139             :   call-seq:
   13140             :     size -> std::vector< kdb::tools::PluginSpec >::size_type
   13141             : 
   13142             : Size or Length of the PluginSpecVector.
   13143             : */
   13144             : SWIGINTERN VALUE
   13145           0 : _wrap_PluginSpecVector_size(int argc, VALUE *argv, VALUE self) {
   13146           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13147           0 :   void *argp1 = 0 ;
   13148           0 :   int res1 = 0 ;
   13149             :   std::vector< kdb::tools::PluginSpec >::size_type result;
   13150           0 :   VALUE vresult = Qnil;
   13151             :   
   13152           0 :   if ((argc < 0) || (argc > 0)) {
   13153           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   13154             :   }
   13155           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13156           0 :   if (!SWIG_IsOK(res1)) {
   13157           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > const *","size", 1, self )); 
   13158             :   }
   13159           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13160           0 :   result = ((std::vector< kdb::tools::PluginSpec > const *)arg1)->size();
   13161           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
   13162             :   return vresult;
   13163             : fail:
   13164             :   return Qnil;
   13165             : }
   13166             : 
   13167             : 
   13168             : 
   13169             : /*
   13170             :   Document-method: Kdbtools::PluginSpecVector.swap
   13171             : 
   13172             :   call-seq:
   13173             :     swap(PluginSpecVector v)
   13174             : 
   13175             : An instance method.
   13176             : 
   13177             : */
   13178             : SWIGINTERN VALUE
   13179           0 : _wrap_PluginSpecVector_swap(int argc, VALUE *argv, VALUE self) {
   13180           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13181           0 :   std::vector< kdb::tools::PluginSpec > *arg2 = 0 ;
   13182           0 :   void *argp1 = 0 ;
   13183           0 :   int res1 = 0 ;
   13184           0 :   void *argp2 = 0 ;
   13185           0 :   int res2 = 0 ;
   13186             :   
   13187           0 :   if ((argc < 1) || (argc > 1)) {
   13188           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   13189             :   }
   13190           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13191           0 :   if (!SWIG_IsOK(res1)) {
   13192           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","swap", 1, self )); 
   13193             :   }
   13194           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13195           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t,  0 );
   13196           0 :   if (!SWIG_IsOK(res2)) {
   13197           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > &","swap", 2, argv[0] )); 
   13198             :   }
   13199           0 :   if (!argp2) {
   13200           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::PluginSpec > &","swap", 2, argv[0])); 
   13201             :   }
   13202           0 :   arg2 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp2);
   13203           0 :   (arg1)->swap(*arg2);
   13204             :   return Qnil;
   13205             : fail:
   13206             :   return Qnil;
   13207             : }
   13208             : 
   13209             : 
   13210             : 
   13211             : /*
   13212             :   Document-method: Kdbtools::PluginSpecVector.clear
   13213             : 
   13214             :   call-seq:
   13215             :     clear
   13216             : 
   13217             : Clear PluginSpecVector contents.
   13218             : */
   13219             : SWIGINTERN VALUE
   13220           0 : _wrap_PluginSpecVector_clear(int argc, VALUE *argv, VALUE self) {
   13221           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13222           0 :   void *argp1 = 0 ;
   13223           0 :   int res1 = 0 ;
   13224             :   
   13225           0 :   if ((argc < 0) || (argc > 0)) {
   13226           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   13227             :   }
   13228           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13229           0 :   if (!SWIG_IsOK(res1)) {
   13230           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","clear", 1, self )); 
   13231             :   }
   13232           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13233           0 :   (arg1)->clear();
   13234             :   return Qnil;
   13235             : fail:
   13236             :   return Qnil;
   13237             : }
   13238             : 
   13239             : 
   13240             : 
   13241             : /*
   13242             :   Document-method: Kdbtools::PluginSpecVector.get_allocator
   13243             : 
   13244             :   call-seq:
   13245             :     get_allocator -> std::vector< kdb::tools::PluginSpec >::allocator_type
   13246             : 
   13247             : An instance method.
   13248             : 
   13249             : */
   13250             : SWIGINTERN VALUE
   13251           0 : _wrap_PluginSpecVector_get_allocator(int argc, VALUE *argv, VALUE self) {
   13252           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13253           0 :   void *argp1 = 0 ;
   13254           0 :   int res1 = 0 ;
   13255           0 :   SwigValueWrapper< std::allocator< kdb::tools::PluginSpec > > result;
   13256           0 :   VALUE vresult = Qnil;
   13257             :   
   13258           0 :   if ((argc < 0) || (argc > 0)) {
   13259           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   13260             :   }
   13261           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13262           0 :   if (!SWIG_IsOK(res1)) {
   13263           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > const *","get_allocator", 1, self )); 
   13264             :   }
   13265           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13266           0 :   result = ((std::vector< kdb::tools::PluginSpec > const *)arg1)->get_allocator();
   13267           0 :   vresult = SWIG_NewPointerObj((new std::vector< kdb::tools::PluginSpec >::allocator_type(static_cast< const std::vector< kdb::tools::PluginSpec >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_kdb__tools__PluginSpec_t, SWIG_POINTER_OWN |  0 );
   13268           0 :   return vresult;
   13269             : fail:
   13270             :   return Qnil;
   13271             : }
   13272             : 
   13273             : 
   13274             : 
   13275             : /*
   13276             :   Document-method: Kdbtools::PluginSpecVector.new
   13277             : 
   13278             :   call-seq:
   13279             :     PluginSpecVector.new
   13280             :     PluginSpecVector.new(PluginSpecVector arg2)
   13281             :     PluginSpecVector.new(std::vector< kdb::tools::PluginSpec >::size_type size)
   13282             :     PluginSpecVector.new(std::vector< kdb::tools::PluginSpec >::size_type size, PluginSpec value)
   13283             : 
   13284             : Class constructor.
   13285             : 
   13286             : */
   13287             : SWIGINTERN VALUE
   13288           0 : _wrap_new_PluginSpecVector__SWIG_2(int argc, VALUE *argv, VALUE self) {
   13289             :   std::vector< kdb::tools::PluginSpec >::size_type arg1 ;
   13290             :   size_t val1 ;
   13291           0 :   int ecode1 = 0 ;
   13292           0 :   std::vector< kdb::tools::PluginSpec > *result = 0 ;
   13293             :   
   13294           0 :   if ((argc < 1) || (argc > 1)) {
   13295           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   13296             :   }
   13297           0 :   ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
   13298           0 :   if (!SWIG_IsOK(ecode1)) {
   13299           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::size_type","vector<(kdb::tools::PluginSpec)>", 1, argv[0] ));
   13300             :   } 
   13301           0 :   arg1 = static_cast< std::vector< kdb::tools::PluginSpec >::size_type >(val1);
   13302           0 :   result = (std::vector< kdb::tools::PluginSpec > *)new std::vector< kdb::tools::PluginSpec >(arg1);
   13303           0 :   DATA_PTR(self) = result;
   13304             :   return self;
   13305             : fail:
   13306             :   return Qnil;
   13307             : }
   13308             : 
   13309             : 
   13310             : 
   13311             : /*
   13312             :   Document-method: Kdbtools::PluginSpecVector.resize
   13313             : 
   13314             :   call-seq:
   13315             :     resize(new_size)
   13316             :     resize(new_size, x)
   13317             : 
   13318             : Resize the size of the PluginSpecVector.
   13319             : */
   13320             : SWIGINTERN VALUE
   13321           0 : _wrap_PluginSpecVector_resize__SWIG_0(int argc, VALUE *argv, VALUE self) {
   13322           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13323             :   std::vector< kdb::tools::PluginSpec >::size_type arg2 ;
   13324           0 :   void *argp1 = 0 ;
   13325           0 :   int res1 = 0 ;
   13326             :   size_t val2 ;
   13327           0 :   int ecode2 = 0 ;
   13328             :   
   13329           0 :   if ((argc < 1) || (argc > 1)) {
   13330           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   13331             :   }
   13332           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13333           0 :   if (!SWIG_IsOK(res1)) {
   13334           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","resize", 1, self )); 
   13335             :   }
   13336           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13337           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
   13338           0 :   if (!SWIG_IsOK(ecode2)) {
   13339           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::size_type","resize", 2, argv[0] ));
   13340             :   } 
   13341           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::size_type >(val2);
   13342           0 :   (arg1)->resize(arg2);
   13343             :   return Qnil;
   13344             : fail:
   13345             :   return Qnil;
   13346             : }
   13347             : 
   13348             : 
   13349             : SWIGINTERN VALUE
   13350             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   13351           0 : _wrap_PluginSpecVector_allocate(VALUE self)
   13352             : #else
   13353             : _wrap_PluginSpecVector_allocate(int argc, VALUE *argv, VALUE self)
   13354             : #endif
   13355             : {
   13356           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t);
   13357             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   13358             :   rb_obj_call_init(vresult, argc, argv);
   13359             : #endif
   13360           0 :   return vresult;
   13361             : }
   13362             : 
   13363             : 
   13364             : 
   13365             : /*
   13366             :   Document-method: Kdbtools::PluginSpecVector.new
   13367             : 
   13368             :   call-seq:
   13369             :     PluginSpecVector.new
   13370             :     PluginSpecVector.new(PluginSpecVector arg2)
   13371             :     PluginSpecVector.new(std::vector< kdb::tools::PluginSpec >::size_type size)
   13372             :     PluginSpecVector.new(std::vector< kdb::tools::PluginSpec >::size_type size, PluginSpec value)
   13373             : 
   13374             : Class constructor.
   13375             : 
   13376             : */
   13377             : SWIGINTERN VALUE
   13378           0 : _wrap_new_PluginSpecVector__SWIG_3(int argc, VALUE *argv, VALUE self) {
   13379             :   std::vector< kdb::tools::PluginSpec >::size_type arg1 ;
   13380           0 :   std::vector< kdb::tools::PluginSpec >::value_type *arg2 = 0 ;
   13381             :   size_t val1 ;
   13382           0 :   int ecode1 = 0 ;
   13383             :   void *argp2 ;
   13384           0 :   int res2 = 0 ;
   13385           0 :   std::vector< kdb::tools::PluginSpec > *result = 0 ;
   13386             :   
   13387           0 :   if ((argc < 2) || (argc > 2)) {
   13388           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   13389             :   }
   13390           0 :   ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
   13391           0 :   if (!SWIG_IsOK(ecode1)) {
   13392           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::size_type","vector<(kdb::tools::PluginSpec)>", 1, argv[0] ));
   13393             :   } 
   13394           0 :   arg1 = static_cast< std::vector< kdb::tools::PluginSpec >::size_type >(val1);
   13395           0 :   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   13396           0 :   if (!SWIG_IsOK(res2)) {
   13397           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::value_type const &","vector<(kdb::tools::PluginSpec)>", 2, argv[1] )); 
   13398             :   }
   13399           0 :   if (!argp2) {
   13400           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::PluginSpec >::value_type const &","vector<(kdb::tools::PluginSpec)>", 2, argv[1])); 
   13401             :   }
   13402           0 :   arg2 = reinterpret_cast< std::vector< kdb::tools::PluginSpec >::value_type * >(argp2);
   13403           0 :   result = (std::vector< kdb::tools::PluginSpec > *)new std::vector< kdb::tools::PluginSpec >(arg1,(std::vector< kdb::tools::PluginSpec >::value_type const &)*arg2);
   13404           0 :   DATA_PTR(self) = result;
   13405             :   return self;
   13406             : fail:
   13407             :   return Qnil;
   13408             : }
   13409             : 
   13410             : 
   13411           0 : SWIGINTERN VALUE _wrap_new_PluginSpecVector(int nargs, VALUE *args, VALUE self) {
   13412             :   int argc;
   13413             :   VALUE argv[2];
   13414             :   int ii;
   13415             :   
   13416           0 :   argc = nargs;
   13417           0 :   if (argc > 2) SWIG_fail;
   13418           0 :   for (ii = 0; (ii < argc); ++ii) {
   13419           0 :     argv[ii] = args[ii];
   13420             :   }
   13421           0 :   if (argc == 0) {
   13422           0 :     return _wrap_new_PluginSpecVector__SWIG_0(nargs, args, self);
   13423             :   }
   13424           0 :   if (argc == 1) {
   13425           0 :     int _v = 0;
   13426             :     {
   13427             :       {
   13428           0 :         int res = SWIG_AsVal_size_t(argv[0], NULL);
   13429           0 :         _v = SWIG_CheckState(res);
   13430             :       }
   13431             :     }
   13432           0 :     if (!_v) goto check_2;
   13433           0 :     return _wrap_new_PluginSpecVector__SWIG_2(nargs, args, self);
   13434             :   }
   13435             : check_2:
   13436             :   
   13437           0 :   if (argc == 1) {
   13438           0 :     return _wrap_new_PluginSpecVector__SWIG_1(nargs, args, self);
   13439             :   }
   13440           0 :   if (argc == 2) {
   13441           0 :     return _wrap_new_PluginSpecVector__SWIG_3(nargs, args, self);
   13442             :   }
   13443             :   
   13444             : fail:
   13445             :   Ruby_Format_OverloadedError( argc, 2, "PluginSpecVector.new", 
   13446             :     "    PluginSpecVector.new()\n"
   13447             :     "    PluginSpecVector.new(std::vector< kdb::tools::PluginSpec > const &)\n"
   13448             :     "    PluginSpecVector.new(std::vector< kdb::tools::PluginSpec >::size_type size)\n"
   13449           0 :     "    PluginSpecVector.new(std::vector< kdb::tools::PluginSpec >::size_type size, std::vector< kdb::tools::PluginSpec >::value_type const &value)\n");
   13450             :   
   13451             :   return Qnil;
   13452             : }
   13453             : 
   13454             : 
   13455             : 
   13456             : /*
   13457             :   Document-method: Kdbtools::PluginSpecVector.front
   13458             : 
   13459             :   call-seq:
   13460             :     front -> PluginSpec
   13461             : 
   13462             : Return the first element in PluginSpecVector.
   13463             : */
   13464             : SWIGINTERN VALUE
   13465           0 : _wrap_PluginSpecVector_front(int argc, VALUE *argv, VALUE self) {
   13466           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13467           0 :   void *argp1 = 0 ;
   13468           0 :   int res1 = 0 ;
   13469           0 :   std::vector< kdb::tools::PluginSpec >::value_type *result = 0 ;
   13470           0 :   VALUE vresult = Qnil;
   13471             :   
   13472           0 :   if ((argc < 0) || (argc > 0)) {
   13473           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   13474             :   }
   13475           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13476           0 :   if (!SWIG_IsOK(res1)) {
   13477           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > const *","front", 1, self )); 
   13478             :   }
   13479           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13480           0 :   result = (std::vector< kdb::tools::PluginSpec >::value_type *) &((std::vector< kdb::tools::PluginSpec > const *)arg1)->front();
   13481           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   13482             :   return vresult;
   13483             : fail:
   13484             :   return Qnil;
   13485             : }
   13486             : 
   13487             : 
   13488             : 
   13489             : /*
   13490             :   Document-method: Kdbtools::PluginSpecVector.back
   13491             : 
   13492             :   call-seq:
   13493             :     back -> PluginSpec
   13494             : 
   13495             : Return the last element in PluginSpecVector.
   13496             : */
   13497             : SWIGINTERN VALUE
   13498           0 : _wrap_PluginSpecVector_back(int argc, VALUE *argv, VALUE self) {
   13499           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13500           0 :   void *argp1 = 0 ;
   13501           0 :   int res1 = 0 ;
   13502           0 :   std::vector< kdb::tools::PluginSpec >::value_type *result = 0 ;
   13503           0 :   VALUE vresult = Qnil;
   13504             :   
   13505           0 :   if ((argc < 0) || (argc > 0)) {
   13506           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   13507             :   }
   13508           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13509           0 :   if (!SWIG_IsOK(res1)) {
   13510           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > const *","back", 1, self )); 
   13511             :   }
   13512           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13513           0 :   result = (std::vector< kdb::tools::PluginSpec >::value_type *) &((std::vector< kdb::tools::PluginSpec > const *)arg1)->back();
   13514           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   13515             :   return vresult;
   13516             : fail:
   13517             :   return Qnil;
   13518             : }
   13519             : 
   13520             : 
   13521             : 
   13522             : /*
   13523             :   Document-method: Kdbtools::PluginSpecVector.assign
   13524             : 
   13525             :   call-seq:
   13526             :     assign(n, x)
   13527             : 
   13528             : Assign a new PluginSpecVector or portion of it.
   13529             : */
   13530             : SWIGINTERN VALUE
   13531           0 : _wrap_PluginSpecVector_assign(int argc, VALUE *argv, VALUE self) {
   13532           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13533             :   std::vector< kdb::tools::PluginSpec >::size_type arg2 ;
   13534           0 :   std::vector< kdb::tools::PluginSpec >::value_type *arg3 = 0 ;
   13535           0 :   void *argp1 = 0 ;
   13536           0 :   int res1 = 0 ;
   13537             :   size_t val2 ;
   13538           0 :   int ecode2 = 0 ;
   13539             :   void *argp3 ;
   13540           0 :   int res3 = 0 ;
   13541             :   
   13542           0 :   if ((argc < 2) || (argc > 2)) {
   13543           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   13544             :   }
   13545           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13546           0 :   if (!SWIG_IsOK(res1)) {
   13547           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","assign", 1, self )); 
   13548             :   }
   13549           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13550           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
   13551           0 :   if (!SWIG_IsOK(ecode2)) {
   13552           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::size_type","assign", 2, argv[0] ));
   13553             :   } 
   13554           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::size_type >(val2);
   13555           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   13556           0 :   if (!SWIG_IsOK(res3)) {
   13557           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::value_type const &","assign", 3, argv[1] )); 
   13558             :   }
   13559           0 :   if (!argp3) {
   13560           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::PluginSpec >::value_type const &","assign", 3, argv[1])); 
   13561             :   }
   13562           0 :   arg3 = reinterpret_cast< std::vector< kdb::tools::PluginSpec >::value_type * >(argp3);
   13563           0 :   (arg1)->assign(arg2,(std::vector< kdb::tools::PluginSpec >::value_type const &)*arg3);
   13564             :   return Qnil;
   13565             : fail:
   13566             :   return Qnil;
   13567             : }
   13568             : 
   13569             : 
   13570             : 
   13571             : /*
   13572             :   Document-method: Kdbtools::PluginSpecVector.resize
   13573             : 
   13574             :   call-seq:
   13575             :     resize(new_size)
   13576             :     resize(new_size, x)
   13577             : 
   13578             : Resize the size of the PluginSpecVector.
   13579             : */
   13580             : SWIGINTERN VALUE
   13581           0 : _wrap_PluginSpecVector_resize__SWIG_1(int argc, VALUE *argv, VALUE self) {
   13582           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13583             :   std::vector< kdb::tools::PluginSpec >::size_type arg2 ;
   13584           0 :   std::vector< kdb::tools::PluginSpec >::value_type *arg3 = 0 ;
   13585           0 :   void *argp1 = 0 ;
   13586           0 :   int res1 = 0 ;
   13587             :   size_t val2 ;
   13588           0 :   int ecode2 = 0 ;
   13589             :   void *argp3 ;
   13590           0 :   int res3 = 0 ;
   13591             :   
   13592           0 :   if ((argc < 2) || (argc > 2)) {
   13593           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   13594             :   }
   13595           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13596           0 :   if (!SWIG_IsOK(res1)) {
   13597           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","resize", 1, self )); 
   13598             :   }
   13599           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13600           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
   13601           0 :   if (!SWIG_IsOK(ecode2)) {
   13602           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::size_type","resize", 2, argv[0] ));
   13603             :   } 
   13604           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::size_type >(val2);
   13605           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   13606           0 :   if (!SWIG_IsOK(res3)) {
   13607           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::value_type const &","resize", 3, argv[1] )); 
   13608             :   }
   13609           0 :   if (!argp3) {
   13610           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::PluginSpec >::value_type const &","resize", 3, argv[1])); 
   13611             :   }
   13612           0 :   arg3 = reinterpret_cast< std::vector< kdb::tools::PluginSpec >::value_type * >(argp3);
   13613           0 :   (arg1)->resize(arg2,(std::vector< kdb::tools::PluginSpec >::value_type const &)*arg3);
   13614             :   return Qnil;
   13615             : fail:
   13616             :   return Qnil;
   13617             : }
   13618             : 
   13619             : 
   13620           0 : SWIGINTERN VALUE _wrap_PluginSpecVector_resize(int nargs, VALUE *args, VALUE self) {
   13621             :   int argc;
   13622             :   VALUE argv[4];
   13623             :   int ii;
   13624             :   
   13625           0 :   argc = nargs + 1;
   13626             :   argv[0] = self;
   13627           0 :   if (argc > 4) SWIG_fail;
   13628             :   for (ii = 1; (ii < argc); ++ii) {
   13629             :     argv[ii] = args[ii-1];
   13630             :   }
   13631           0 :   if (argc == 2) {
   13632           0 :     return _wrap_PluginSpecVector_resize__SWIG_0(nargs, args, self);
   13633             :   }
   13634           0 :   if (argc == 3) {
   13635           0 :     return _wrap_PluginSpecVector_resize__SWIG_1(nargs, args, self);
   13636             :   }
   13637             :   
   13638             : fail:
   13639             :   Ruby_Format_OverloadedError( argc, 4, "PluginSpecVector.resize", 
   13640             :     "    void PluginSpecVector.resize(std::vector< kdb::tools::PluginSpec >::size_type new_size)\n"
   13641           0 :     "    void PluginSpecVector.resize(std::vector< kdb::tools::PluginSpec >::size_type new_size, std::vector< kdb::tools::PluginSpec >::value_type const &x)\n");
   13642             :   
   13643             :   return Qnil;
   13644             : }
   13645             : 
   13646             : 
   13647             : 
   13648             : /*
   13649             :   Document-method: Kdbtools::PluginSpecVector.reserve
   13650             : 
   13651             :   call-seq:
   13652             :     reserve(n)
   13653             : 
   13654             : Reserve memory in the PluginSpecVector for a number of elements.
   13655             : */
   13656             : SWIGINTERN VALUE
   13657           0 : _wrap_PluginSpecVector_reserve(int argc, VALUE *argv, VALUE self) {
   13658           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13659             :   std::vector< kdb::tools::PluginSpec >::size_type arg2 ;
   13660           0 :   void *argp1 = 0 ;
   13661           0 :   int res1 = 0 ;
   13662             :   size_t val2 ;
   13663           0 :   int ecode2 = 0 ;
   13664             :   
   13665           0 :   if ((argc < 1) || (argc > 1)) {
   13666           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   13667             :   }
   13668           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13669           0 :   if (!SWIG_IsOK(res1)) {
   13670           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > *","reserve", 1, self )); 
   13671             :   }
   13672           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13673           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
   13674           0 :   if (!SWIG_IsOK(ecode2)) {
   13675           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec >::size_type","reserve", 2, argv[0] ));
   13676             :   } 
   13677           0 :   arg2 = static_cast< std::vector< kdb::tools::PluginSpec >::size_type >(val2);
   13678           0 :   (arg1)->reserve(arg2);
   13679             :   return Qnil;
   13680             : fail:
   13681             :   return Qnil;
   13682             : }
   13683             : 
   13684             : 
   13685             : 
   13686             : /*
   13687             :   Document-method: Kdbtools::PluginSpecVector.capacity
   13688             : 
   13689             :   call-seq:
   13690             :     capacity -> std::vector< kdb::tools::PluginSpec >::size_type
   13691             : 
   13692             : Reserved capacity of the PluginSpecVector.
   13693             : */
   13694             : SWIGINTERN VALUE
   13695           0 : _wrap_PluginSpecVector_capacity(int argc, VALUE *argv, VALUE self) {
   13696           0 :   std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *) 0 ;
   13697           0 :   void *argp1 = 0 ;
   13698           0 :   int res1 = 0 ;
   13699             :   std::vector< kdb::tools::PluginSpec >::size_type result;
   13700           0 :   VALUE vresult = Qnil;
   13701             :   
   13702           0 :   if ((argc < 0) || (argc > 0)) {
   13703           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   13704             :   }
   13705           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0 |  0 );
   13706           0 :   if (!SWIG_IsOK(res1)) {
   13707           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::PluginSpec > const *","capacity", 1, self )); 
   13708             :   }
   13709           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::PluginSpec > * >(argp1);
   13710           0 :   result = ((std::vector< kdb::tools::PluginSpec > const *)arg1)->capacity();
   13711           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
   13712             :   return vresult;
   13713             : fail:
   13714             :   return Qnil;
   13715             : }
   13716             : 
   13717             : 
   13718             : SWIGINTERN void
   13719           0 : free_std_vector_Sl_kdb_tools_PluginSpec_Sg_(void *self) {
   13720           0 :     std::vector< kdb::tools::PluginSpec > *arg1 = (std::vector< kdb::tools::PluginSpec > *)self;
   13721           0 :     delete arg1;
   13722           0 : }
   13723             : 
   13724             : 
   13725             : /*
   13726             :   Document-class: Kdbtools::PluginSpec
   13727             : 
   13728             :   Proxy of C++ Kdbtools::PluginSpec class
   13729             : 
   13730             : 
   13731             : */
   13732             : static swig_class SwigClassPluginSpec;
   13733             : 
   13734             : 
   13735             : /*
   13736             :   Document-method: Kdbtools::PluginSpec.new
   13737             : 
   13738             :   call-seq:
   13739             :     PluginSpec.new
   13740             :     PluginSpec.new(std::string pluginName, KeySet pluginConfig=kdb::KeySet())
   13741             :     PluginSpec.new(std::string pluginName)
   13742             :     PluginSpec.new(std::string pluginName, std::string refName, KeySet pluginConfig=kdb::KeySet())
   13743             :     PluginSpec.new(std::string pluginName, std::string refName)
   13744             :     PluginSpec.new(std::string pluginName, size_t refNumber, KeySet pluginConfig=kdb::KeySet())
   13745             :     PluginSpec.new(std::string pluginName, size_t refNumber)
   13746             : 
   13747             : Class constructor.
   13748             : 
   13749             : */
   13750             : SWIGINTERN VALUE
   13751           0 : _wrap_new_PluginSpec__SWIG_0(int argc, VALUE *argv, VALUE self) {
   13752           0 :   kdb::tools::PluginSpec *result = 0 ;
   13753             :   
   13754           0 :   if ((argc < 0) || (argc > 0)) {
   13755           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   13756             :   }
   13757             :   try {
   13758           0 :     result = (kdb::tools::PluginSpec *)new kdb::tools::PluginSpec();
   13759           0 :     DATA_PTR(self) = result;
   13760             :   }
   13761           0 :   catch(kdb::tools::BadPluginName &_e) {
   13762           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   13763             :   }
   13764           0 :   catch(kdb::tools::PluginCheckException &_e) {
   13765           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   13766             :   }
   13767           0 :   catch(kdb::tools::ToolException &_e) {
   13768           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   13769             :   }
   13770             :   
   13771             :   return self;
   13772             : fail:
   13773             :   return Qnil;
   13774             : }
   13775             : 
   13776             : 
   13777             : SWIGINTERN VALUE
   13778           0 : _wrap_new_PluginSpec__SWIG_1(int argc, VALUE *argv, VALUE self) {
   13779           0 :   std::string arg1 ;
   13780           0 :   kdb::KeySet arg2 ;
   13781             :   void *argp2 ;
   13782           0 :   int res2 = 0 ;
   13783           0 :   kdb::tools::PluginSpec *result = 0 ;
   13784             :   
   13785           0 :   if ((argc < 2) || (argc > 2)) {
   13786           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   13787             :   }
   13788             :   {
   13789           0 :     std::string *ptr = (std::string *)0;
   13790           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   13791           0 :     if (!SWIG_IsOK(res) || !ptr) {
   13792           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","PluginSpec", 1, argv[0] )); 
   13793             :     }
   13794           0 :     arg1 = *ptr;
   13795           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   13796             :   }
   13797             :   {
   13798           0 :     res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   13799           0 :     if (!SWIG_IsOK(res2)) {
   13800           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet","PluginSpec", 2, argv[1] )); 
   13801             :     }  
   13802           0 :     if (!argp2) {
   13803           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet","PluginSpec", 2, argv[1]));
   13804             :     } else {
   13805           0 :       arg2 = *(reinterpret_cast< kdb::KeySet * >(argp2));
   13806             :     }
   13807             :   }
   13808             :   try {
   13809           0 :     result = (kdb::tools::PluginSpec *)new kdb::tools::PluginSpec(arg1,arg2);
   13810           0 :     DATA_PTR(self) = result;
   13811             :   }
   13812           0 :   catch(kdb::tools::BadPluginName &_e) {
   13813           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   13814             :   }
   13815           0 :   catch(kdb::tools::PluginCheckException &_e) {
   13816           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   13817             :   }
   13818           0 :   catch(kdb::tools::ToolException &_e) {
   13819           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   13820             :   }
   13821             :   
   13822           0 :   return self;
   13823             : fail:
   13824             :   return Qnil;
   13825             : }
   13826             : 
   13827             : 
   13828             : SWIGINTERN VALUE
   13829           6 : _wrap_new_PluginSpec__SWIG_2(int argc, VALUE *argv, VALUE self) {
   13830          12 :   std::string arg1 ;
   13831           6 :   kdb::tools::PluginSpec *result = 0 ;
   13832             :   
   13833           6 :   if ((argc < 1) || (argc > 1)) {
   13834           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   13835             :   }
   13836             :   {
   13837           6 :     std::string *ptr = (std::string *)0;
   13838           6 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   13839           6 :     if (!SWIG_IsOK(res) || !ptr) {
   13840           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","PluginSpec", 1, argv[0] )); 
   13841             :     }
   13842          12 :     arg1 = *ptr;
   13843          12 :     if (SWIG_IsNewObj(res)) delete ptr;
   13844             :   }
   13845             :   try {
   13846          24 :     result = (kdb::tools::PluginSpec *)new kdb::tools::PluginSpec(arg1);
   13847           6 :     DATA_PTR(self) = result;
   13848             :   }
   13849           0 :   catch(kdb::tools::BadPluginName &_e) {
   13850           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   13851             :   }
   13852           0 :   catch(kdb::tools::PluginCheckException &_e) {
   13853           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   13854             :   }
   13855           0 :   catch(kdb::tools::ToolException &_e) {
   13856           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   13857             :   }
   13858             :   
   13859           6 :   return self;
   13860             : fail:
   13861             :   return Qnil;
   13862             : }
   13863             : 
   13864             : 
   13865             : SWIGINTERN VALUE
   13866           0 : _wrap_new_PluginSpec__SWIG_3(int argc, VALUE *argv, VALUE self) {
   13867           0 :   std::string arg1 ;
   13868           0 :   std::string arg2 ;
   13869           0 :   kdb::KeySet arg3 ;
   13870             :   void *argp3 ;
   13871           0 :   int res3 = 0 ;
   13872           0 :   kdb::tools::PluginSpec *result = 0 ;
   13873             :   
   13874           0 :   if ((argc < 3) || (argc > 3)) {
   13875           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   13876             :   }
   13877             :   {
   13878           0 :     std::string *ptr = (std::string *)0;
   13879           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   13880           0 :     if (!SWIG_IsOK(res) || !ptr) {
   13881           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","PluginSpec", 1, argv[0] )); 
   13882             :     }
   13883           0 :     arg1 = *ptr;
   13884           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   13885             :   }
   13886             :   {
   13887           0 :     std::string *ptr = (std::string *)0;
   13888           0 :     int res = SWIG_AsPtr_std_string(argv[1], &ptr);
   13889           0 :     if (!SWIG_IsOK(res) || !ptr) {
   13890           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","PluginSpec", 2, argv[1] )); 
   13891             :     }
   13892           0 :     arg2 = *ptr;
   13893           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   13894             :   }
   13895             :   {
   13896           0 :     res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_kdb__KeySet,  0 );
   13897           0 :     if (!SWIG_IsOK(res3)) {
   13898           0 :       SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::KeySet","PluginSpec", 3, argv[2] )); 
   13899             :     }  
   13900           0 :     if (!argp3) {
   13901           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet","PluginSpec", 3, argv[2]));
   13902             :     } else {
   13903           0 :       arg3 = *(reinterpret_cast< kdb::KeySet * >(argp3));
   13904             :     }
   13905             :   }
   13906             :   try {
   13907           0 :     result = (kdb::tools::PluginSpec *)new kdb::tools::PluginSpec(arg1,arg2,arg3);
   13908           0 :     DATA_PTR(self) = result;
   13909             :   }
   13910           0 :   catch(kdb::tools::BadPluginName &_e) {
   13911           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   13912             :   }
   13913           0 :   catch(kdb::tools::PluginCheckException &_e) {
   13914           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   13915             :   }
   13916           0 :   catch(kdb::tools::ToolException &_e) {
   13917           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   13918             :   }
   13919             :   
   13920           0 :   return self;
   13921             : fail:
   13922             :   return Qnil;
   13923             : }
   13924             : 
   13925             : 
   13926             : SWIGINTERN VALUE
   13927           0 : _wrap_new_PluginSpec__SWIG_4(int argc, VALUE *argv, VALUE self) {
   13928           0 :   std::string arg1 ;
   13929           0 :   std::string arg2 ;
   13930           0 :   kdb::tools::PluginSpec *result = 0 ;
   13931             :   
   13932           0 :   if ((argc < 2) || (argc > 2)) {
   13933           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   13934             :   }
   13935             :   {
   13936           0 :     std::string *ptr = (std::string *)0;
   13937           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   13938           0 :     if (!SWIG_IsOK(res) || !ptr) {
   13939           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","PluginSpec", 1, argv[0] )); 
   13940             :     }
   13941           0 :     arg1 = *ptr;
   13942           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   13943             :   }
   13944             :   {
   13945           0 :     std::string *ptr = (std::string *)0;
   13946           0 :     int res = SWIG_AsPtr_std_string(argv[1], &ptr);
   13947           0 :     if (!SWIG_IsOK(res) || !ptr) {
   13948           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","PluginSpec", 2, argv[1] )); 
   13949             :     }
   13950           0 :     arg2 = *ptr;
   13951           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   13952             :   }
   13953             :   try {
   13954           0 :     result = (kdb::tools::PluginSpec *)new kdb::tools::PluginSpec(arg1,arg2);
   13955           0 :     DATA_PTR(self) = result;
   13956             :   }
   13957           0 :   catch(kdb::tools::BadPluginName &_e) {
   13958           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   13959             :   }
   13960           0 :   catch(kdb::tools::PluginCheckException &_e) {
   13961           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   13962             :   }
   13963           0 :   catch(kdb::tools::ToolException &_e) {
   13964           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   13965             :   }
   13966             :   
   13967           0 :   return self;
   13968             : fail:
   13969             :   return Qnil;
   13970             : }
   13971             : 
   13972             : 
   13973             : SWIGINTERN VALUE
   13974           0 : _wrap_new_PluginSpec__SWIG_5(int argc, VALUE *argv, VALUE self) {
   13975           0 :   std::string arg1 ;
   13976             :   size_t arg2 ;
   13977           0 :   kdb::KeySet arg3 ;
   13978             :   size_t val2 ;
   13979           0 :   int ecode2 = 0 ;
   13980             :   void *argp3 ;
   13981           0 :   int res3 = 0 ;
   13982           0 :   kdb::tools::PluginSpec *result = 0 ;
   13983             :   
   13984           0 :   if ((argc < 3) || (argc > 3)) {
   13985           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   13986             :   }
   13987             :   {
   13988           0 :     std::string *ptr = (std::string *)0;
   13989           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   13990           0 :     if (!SWIG_IsOK(res) || !ptr) {
   13991           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","PluginSpec", 1, argv[0] )); 
   13992             :     }
   13993           0 :     arg1 = *ptr;
   13994           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   13995             :   }
   13996           0 :   ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
   13997           0 :   if (!SWIG_IsOK(ecode2)) {
   13998           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","PluginSpec", 2, argv[1] ));
   13999             :   } 
   14000           0 :   arg2 = static_cast< size_t >(val2);
   14001             :   {
   14002           0 :     res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_kdb__KeySet,  0 );
   14003           0 :     if (!SWIG_IsOK(res3)) {
   14004           0 :       SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::KeySet","PluginSpec", 3, argv[2] )); 
   14005             :     }  
   14006           0 :     if (!argp3) {
   14007           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet","PluginSpec", 3, argv[2]));
   14008             :     } else {
   14009           0 :       arg3 = *(reinterpret_cast< kdb::KeySet * >(argp3));
   14010             :     }
   14011             :   }
   14012             :   try {
   14013           0 :     result = (kdb::tools::PluginSpec *)new kdb::tools::PluginSpec(arg1,arg2,arg3);
   14014           0 :     DATA_PTR(self) = result;
   14015             :   }
   14016           0 :   catch(kdb::tools::BadPluginName &_e) {
   14017           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   14018             :   }
   14019           0 :   catch(kdb::tools::PluginCheckException &_e) {
   14020           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   14021             :   }
   14022           0 :   catch(kdb::tools::ToolException &_e) {
   14023           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   14024             :   }
   14025             :   
   14026           0 :   return self;
   14027             : fail:
   14028             :   return Qnil;
   14029             : }
   14030             : 
   14031             : 
   14032             : SWIGINTERN VALUE
   14033             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   14034           6 : _wrap_PluginSpec_allocate(VALUE self)
   14035             : #else
   14036             : _wrap_PluginSpec_allocate(int argc, VALUE *argv, VALUE self)
   14037             : #endif
   14038             : {
   14039           6 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__PluginSpec);
   14040             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   14041             :   rb_obj_call_init(vresult, argc, argv);
   14042             : #endif
   14043           6 :   return vresult;
   14044             : }
   14045             : 
   14046             : 
   14047             : SWIGINTERN VALUE
   14048           0 : _wrap_new_PluginSpec__SWIG_6(int argc, VALUE *argv, VALUE self) {
   14049           0 :   std::string arg1 ;
   14050             :   size_t arg2 ;
   14051             :   size_t val2 ;
   14052           0 :   int ecode2 = 0 ;
   14053           0 :   kdb::tools::PluginSpec *result = 0 ;
   14054             :   
   14055           0 :   if ((argc < 2) || (argc > 2)) {
   14056           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   14057             :   }
   14058             :   {
   14059           0 :     std::string *ptr = (std::string *)0;
   14060           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   14061           0 :     if (!SWIG_IsOK(res) || !ptr) {
   14062           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","PluginSpec", 1, argv[0] )); 
   14063             :     }
   14064           0 :     arg1 = *ptr;
   14065           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   14066             :   }
   14067           0 :   ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
   14068           0 :   if (!SWIG_IsOK(ecode2)) {
   14069           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","PluginSpec", 2, argv[1] ));
   14070             :   } 
   14071           0 :   arg2 = static_cast< size_t >(val2);
   14072             :   try {
   14073           0 :     result = (kdb::tools::PluginSpec *)new kdb::tools::PluginSpec(arg1,arg2);
   14074           0 :     DATA_PTR(self) = result;
   14075             :   }
   14076           0 :   catch(kdb::tools::BadPluginName &_e) {
   14077           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   14078             :   }
   14079           0 :   catch(kdb::tools::PluginCheckException &_e) {
   14080           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   14081             :   }
   14082           0 :   catch(kdb::tools::ToolException &_e) {
   14083           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   14084             :   }
   14085             :   
   14086           0 :   return self;
   14087             : fail:
   14088             :   return Qnil;
   14089             : }
   14090             : 
   14091             : 
   14092           6 : SWIGINTERN VALUE _wrap_new_PluginSpec(int nargs, VALUE *args, VALUE self) {
   14093             :   int argc;
   14094             :   VALUE argv[3];
   14095             :   int ii;
   14096             :   
   14097           6 :   argc = nargs;
   14098           6 :   if (argc > 3) SWIG_fail;
   14099          18 :   for (ii = 0; (ii < argc); ++ii) {
   14100           6 :     argv[ii] = args[ii];
   14101             :   }
   14102           6 :   if (argc == 0) {
   14103           0 :     return _wrap_new_PluginSpec__SWIG_0(nargs, args, self);
   14104             :   }
   14105           6 :   if (argc == 1) {
   14106           6 :     return _wrap_new_PluginSpec__SWIG_2(nargs, args, self);
   14107             :   }
   14108           0 :   if (argc == 2) {
   14109           0 :     int _v = 0;
   14110             :     {
   14111           0 :       void *vptr = 0;
   14112           0 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_kdb__KeySet, 0);
   14113           0 :       _v = SWIG_CheckState(res);
   14114             :     }
   14115           0 :     if (!_v) goto check_3;
   14116           0 :     return _wrap_new_PluginSpec__SWIG_1(nargs, args, self);
   14117             :   }
   14118             : check_3:
   14119             :   
   14120           0 :   if (argc == 2) {
   14121           0 :     int _v = 0;
   14122             :     {
   14123             :       {
   14124           0 :         int res = SWIG_AsVal_size_t(argv[1], NULL);
   14125           0 :         _v = SWIG_CheckState(res);
   14126             :       }
   14127             :     }
   14128           0 :     if (!_v) goto check_4;
   14129           0 :     return _wrap_new_PluginSpec__SWIG_6(nargs, args, self);
   14130             :   }
   14131             : check_4:
   14132             :   
   14133           0 :   if (argc == 2) {
   14134           0 :     return _wrap_new_PluginSpec__SWIG_4(nargs, args, self);
   14135             :   }
   14136           0 :   if (argc == 3) {
   14137           0 :     int _v = 0;
   14138             :     {
   14139             :       {
   14140           0 :         int res = SWIG_AsVal_size_t(argv[1], NULL);
   14141           0 :         _v = SWIG_CheckState(res);
   14142             :       }
   14143             :     }
   14144           0 :     if (!_v) goto check_6;
   14145           0 :     return _wrap_new_PluginSpec__SWIG_5(nargs, args, self);
   14146             :   }
   14147             : check_6:
   14148             :   
   14149           0 :   if (argc == 3) {
   14150           0 :     return _wrap_new_PluginSpec__SWIG_3(nargs, args, self);
   14151             :   }
   14152             :   
   14153             : fail:
   14154             :   Ruby_Format_OverloadedError( argc, 3, "PluginSpec.new", 
   14155             :     "    PluginSpec.new()\n"
   14156             :     "    PluginSpec.new(std::string pluginName, kdb::KeySet pluginConfig)\n"
   14157             :     "    PluginSpec.new(std::string pluginName)\n"
   14158             :     "    PluginSpec.new(std::string pluginName, std::string refName, kdb::KeySet pluginConfig)\n"
   14159             :     "    PluginSpec.new(std::string pluginName, std::string refName)\n"
   14160             :     "    PluginSpec.new(std::string pluginName, size_t refNumber, kdb::KeySet pluginConfig)\n"
   14161           0 :     "    PluginSpec.new(std::string pluginName, size_t refNumber)\n");
   14162             :   
   14163             :   return Qnil;
   14164             : }
   14165             : 
   14166             : 
   14167             : 
   14168             : /*
   14169             :   Document-method: Kdbtools::PluginSpec.fullname
   14170             : 
   14171             :   call-seq:
   14172             :     fullname -> std::string
   14173             : 
   14174             : An instance method.
   14175             : 
   14176             : */
   14177             : SWIGINTERN VALUE
   14178           9 : _wrap_PluginSpec_fullname(int argc, VALUE *argv, VALUE self) {
   14179           9 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14180           9 :   void *argp1 = 0 ;
   14181           9 :   int res1 = 0 ;
   14182          18 :   std::string result;
   14183           9 :   VALUE vresult = Qnil;
   14184             :   
   14185           9 :   if ((argc < 0) || (argc > 0)) {
   14186           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   14187             :   }
   14188           9 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14189           9 :   if (!SWIG_IsOK(res1)) {
   14190           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const *","getFullName", 1, self )); 
   14191             :   }
   14192           9 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14193          18 :   result = ((kdb::tools::PluginSpec const *)arg1)->getFullName();
   14194          27 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   14195           9 :   return vresult;
   14196             : fail:
   14197             :   return Qnil;
   14198             : }
   14199             : 
   14200             : 
   14201             : 
   14202             : /*
   14203             :   Document-method: Kdbtools::PluginSpec.refname
   14204             : 
   14205             :   call-seq:
   14206             :     refname -> std::string
   14207             : 
   14208             : An instance method.
   14209             : 
   14210             : */
   14211             : SWIGINTERN VALUE
   14212           3 : _wrap_PluginSpec_refname(int argc, VALUE *argv, VALUE self) {
   14213           3 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14214           3 :   void *argp1 = 0 ;
   14215           3 :   int res1 = 0 ;
   14216           6 :   std::string result;
   14217           3 :   VALUE vresult = Qnil;
   14218             :   
   14219           3 :   if ((argc < 0) || (argc > 0)) {
   14220           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   14221             :   }
   14222           3 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14223           3 :   if (!SWIG_IsOK(res1)) {
   14224           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const *","getRefName", 1, self )); 
   14225             :   }
   14226           3 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14227           6 :   result = ((kdb::tools::PluginSpec const *)arg1)->getRefName();
   14228           9 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   14229           3 :   return vresult;
   14230             : fail:
   14231             :   return Qnil;
   14232             : }
   14233             : 
   14234             : 
   14235             : 
   14236             : /*
   14237             :   Document-method: Kdbtools::PluginSpec.is_refnumber?
   14238             : 
   14239             :   call-seq:
   14240             :     is_refnumber? -> bool
   14241             : 
   14242             : An instance method.
   14243             : 
   14244             : */
   14245             : SWIGINTERN VALUE
   14246           2 : _wrap_PluginSpec_is_refnumberq___(int argc, VALUE *argv, VALUE self) {
   14247           2 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14248           2 :   void *argp1 = 0 ;
   14249           2 :   int res1 = 0 ;
   14250             :   bool result;
   14251           2 :   VALUE vresult = Qnil;
   14252             :   
   14253           2 :   if ((argc < 0) || (argc > 0)) {
   14254           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   14255             :   }
   14256           2 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14257           2 :   if (!SWIG_IsOK(res1)) {
   14258           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const *","isRefNumber", 1, self )); 
   14259             :   }
   14260           2 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14261           2 :   result = (bool)((kdb::tools::PluginSpec const *)arg1)->isRefNumber();
   14262           2 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   14263             :   return vresult;
   14264             : fail:
   14265             :   return Qnil;
   14266             : }
   14267             : 
   14268             : 
   14269             : 
   14270             : /*
   14271             :   Document-method: Kdbtools::PluginSpec.name
   14272             : 
   14273             :   call-seq:
   14274             :     name -> std::string
   14275             : 
   14276             : An instance method.
   14277             : 
   14278             : */
   14279             : SWIGINTERN VALUE
   14280           4 : _wrap_PluginSpec_name(int argc, VALUE *argv, VALUE self) {
   14281           4 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14282           4 :   void *argp1 = 0 ;
   14283           4 :   int res1 = 0 ;
   14284           8 :   std::string result;
   14285           4 :   VALUE vresult = Qnil;
   14286             :   
   14287           4 :   if ((argc < 0) || (argc > 0)) {
   14288           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   14289             :   }
   14290           4 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14291           4 :   if (!SWIG_IsOK(res1)) {
   14292           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const *","getName", 1, self )); 
   14293             :   }
   14294           4 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14295           8 :   result = ((kdb::tools::PluginSpec const *)arg1)->getName();
   14296          12 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   14297           4 :   return vresult;
   14298             : fail:
   14299             :   return Qnil;
   14300             : }
   14301             : 
   14302             : 
   14303             : 
   14304             : /*
   14305             :   Document-method: Kdbtools::PluginSpec.config
   14306             : 
   14307             :   call-seq:
   14308             :     config -> KeySet
   14309             : 
   14310             : An instance method.
   14311             : 
   14312             : */
   14313             : SWIGINTERN VALUE
   14314           5 : _wrap_PluginSpec_config(int argc, VALUE *argv, VALUE self) {
   14315           5 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14316           5 :   void *argp1 = 0 ;
   14317           5 :   int res1 = 0 ;
   14318          10 :   kdb::KeySet result;
   14319           5 :   VALUE vresult = Qnil;
   14320             :   
   14321           5 :   if ((argc < 0) || (argc > 0)) {
   14322           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   14323             :   }
   14324           5 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14325           5 :   if (!SWIG_IsOK(res1)) {
   14326           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const *","getConfig", 1, self )); 
   14327             :   }
   14328           5 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14329          15 :   result = ((kdb::tools::PluginSpec const *)arg1)->getConfig();
   14330          10 :   vresult = SWIG_NewPointerObj((new kdb::KeySet(static_cast< const kdb::KeySet& >(result))), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_OWN |  0 );
   14331           5 :   return vresult;
   14332             : fail:
   14333             :   return Qnil;
   14334             : }
   14335             : 
   14336             : 
   14337             : 
   14338             : /*
   14339             :   Document-method: Kdbtools::PluginSpec.fullname=
   14340             : 
   14341             :   call-seq:
   14342             :     fullname=(std::string const & name)
   14343             : 
   14344             : An instance method.
   14345             : 
   14346             : */
   14347             : SWIGINTERN VALUE
   14348           2 : _wrap_PluginSpec_fullnamee___(int argc, VALUE *argv, VALUE self) {
   14349           2 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14350           2 :   std::string *arg2 = 0 ;
   14351           2 :   void *argp1 = 0 ;
   14352           2 :   int res1 = 0 ;
   14353           2 :   int res2 = SWIG_OLDOBJ ;
   14354             :   
   14355           2 :   if ((argc < 1) || (argc > 1)) {
   14356           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   14357             :   }
   14358           2 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14359           2 :   if (!SWIG_IsOK(res1)) {
   14360           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec *","setFullName", 1, self )); 
   14361             :   }
   14362           2 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14363             :   {
   14364           2 :     std::string *ptr = (std::string *)0;
   14365           2 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   14366           2 :     if (!SWIG_IsOK(res2)) {
   14367           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setFullName", 2, argv[0] )); 
   14368             :     }
   14369           2 :     if (!ptr) {
   14370           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setFullName", 2, argv[0])); 
   14371             :     }
   14372           2 :     arg2 = ptr;
   14373             :   }
   14374             :   try {
   14375           2 :     (arg1)->setFullName((std::string const &)*arg2);
   14376             :   }
   14377           1 :   catch(kdb::tools::BadPluginName &_e) {
   14378           1 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   14379             :   }
   14380           0 :   catch(kdb::tools::PluginCheckException &_e) {
   14381           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   14382             :   }
   14383           0 :   catch(kdb::tools::ToolException &_e) {
   14384           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   14385             :   }
   14386             :   
   14387           2 :   if (SWIG_IsNewObj(res2)) delete arg2;
   14388             :   return Qnil;
   14389             : fail:
   14390             :   if (SWIG_IsNewObj(res2)) delete arg2;
   14391             :   return Qnil;
   14392             : }
   14393             : 
   14394             : 
   14395             : 
   14396             : /*
   14397             :   Document-method: Kdbtools::PluginSpec.refname=
   14398             : 
   14399             :   call-seq:
   14400             :     refname=(std::string const & name)
   14401             : 
   14402             : An instance method.
   14403             : 
   14404             : */
   14405             : SWIGINTERN VALUE
   14406           1 : _wrap_PluginSpec_refnamee___(int argc, VALUE *argv, VALUE self) {
   14407           1 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14408           1 :   std::string *arg2 = 0 ;
   14409           1 :   void *argp1 = 0 ;
   14410           1 :   int res1 = 0 ;
   14411           1 :   int res2 = SWIG_OLDOBJ ;
   14412             :   
   14413           1 :   if ((argc < 1) || (argc > 1)) {
   14414           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   14415             :   }
   14416           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14417           1 :   if (!SWIG_IsOK(res1)) {
   14418           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec *","setRefName", 1, self )); 
   14419             :   }
   14420           1 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14421             :   {
   14422           1 :     std::string *ptr = (std::string *)0;
   14423           1 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   14424           1 :     if (!SWIG_IsOK(res2)) {
   14425           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setRefName", 2, argv[0] )); 
   14426             :     }
   14427           1 :     if (!ptr) {
   14428           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setRefName", 2, argv[0])); 
   14429             :     }
   14430           1 :     arg2 = ptr;
   14431             :   }
   14432             :   try {
   14433           1 :     (arg1)->setRefName((std::string const &)*arg2);
   14434             :   }
   14435           0 :   catch(kdb::tools::BadPluginName &_e) {
   14436           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   14437             :   }
   14438           0 :   catch(kdb::tools::PluginCheckException &_e) {
   14439           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   14440             :   }
   14441           0 :   catch(kdb::tools::ToolException &_e) {
   14442           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   14443             :   }
   14444             :   
   14445           2 :   if (SWIG_IsNewObj(res2)) delete arg2;
   14446             :   return Qnil;
   14447             : fail:
   14448             :   if (SWIG_IsNewObj(res2)) delete arg2;
   14449             :   return Qnil;
   14450             : }
   14451             : 
   14452             : 
   14453             : 
   14454             : /*
   14455             :   Document-method: Kdbtools::PluginSpec.refnumber=
   14456             : 
   14457             :   call-seq:
   14458             :     refnumber=(size_t number)
   14459             : 
   14460             : An instance method.
   14461             : 
   14462             : */
   14463             : SWIGINTERN VALUE
   14464           1 : _wrap_PluginSpec_refnumbere___(int argc, VALUE *argv, VALUE self) {
   14465           1 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14466             :   size_t arg2 ;
   14467           1 :   void *argp1 = 0 ;
   14468           1 :   int res1 = 0 ;
   14469             :   size_t val2 ;
   14470           1 :   int ecode2 = 0 ;
   14471             :   
   14472           1 :   if ((argc < 1) || (argc > 1)) {
   14473           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   14474             :   }
   14475           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14476           1 :   if (!SWIG_IsOK(res1)) {
   14477           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec *","setRefNumber", 1, self )); 
   14478             :   }
   14479           1 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14480           2 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
   14481           1 :   if (!SWIG_IsOK(ecode2)) {
   14482           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setRefNumber", 2, argv[0] ));
   14483             :   } 
   14484           1 :   arg2 = static_cast< size_t >(val2);
   14485           1 :   (arg1)->setRefNumber(arg2);
   14486             :   return Qnil;
   14487             : fail:
   14488             :   return Qnil;
   14489             : }
   14490             : 
   14491             : 
   14492             : 
   14493             : /*
   14494             :   Document-method: Kdbtools::PluginSpec.name=
   14495             : 
   14496             :   call-seq:
   14497             :     name=(std::string const & name)
   14498             : 
   14499             : An instance method.
   14500             : 
   14501             : */
   14502             : SWIGINTERN VALUE
   14503           1 : _wrap_PluginSpec_namee___(int argc, VALUE *argv, VALUE self) {
   14504           1 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14505           1 :   std::string *arg2 = 0 ;
   14506           1 :   void *argp1 = 0 ;
   14507           1 :   int res1 = 0 ;
   14508           1 :   int res2 = SWIG_OLDOBJ ;
   14509             :   
   14510           1 :   if ((argc < 1) || (argc > 1)) {
   14511           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   14512             :   }
   14513           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14514           1 :   if (!SWIG_IsOK(res1)) {
   14515           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec *","setName", 1, self )); 
   14516             :   }
   14517           1 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14518             :   {
   14519           1 :     std::string *ptr = (std::string *)0;
   14520           1 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   14521           1 :     if (!SWIG_IsOK(res2)) {
   14522           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","setName", 2, argv[0] )); 
   14523             :     }
   14524           1 :     if (!ptr) {
   14525           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","setName", 2, argv[0])); 
   14526             :     }
   14527           1 :     arg2 = ptr;
   14528             :   }
   14529             :   try {
   14530           1 :     (arg1)->setName((std::string const &)*arg2);
   14531             :   }
   14532           0 :   catch(kdb::tools::BadPluginName &_e) {
   14533           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   14534             :   }
   14535           0 :   catch(kdb::tools::PluginCheckException &_e) {
   14536           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   14537             :   }
   14538           0 :   catch(kdb::tools::ToolException &_e) {
   14539           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   14540             :   }
   14541             :   
   14542           2 :   if (SWIG_IsNewObj(res2)) delete arg2;
   14543             :   return Qnil;
   14544             : fail:
   14545             :   if (SWIG_IsNewObj(res2)) delete arg2;
   14546             :   return Qnil;
   14547             : }
   14548             : 
   14549             : 
   14550             : 
   14551             : /*
   14552             :   Document-method: Kdbtools::PluginSpec.append_config
   14553             : 
   14554             :   call-seq:
   14555             :     append_config(KeySet config)
   14556             : 
   14557             : An instance method.
   14558             : 
   14559             : */
   14560             : SWIGINTERN VALUE
   14561           1 : _wrap_PluginSpec_append_config(int argc, VALUE *argv, VALUE self) {
   14562           1 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14563           2 :   kdb::KeySet arg2 ;
   14564           1 :   void *argp1 = 0 ;
   14565           1 :   int res1 = 0 ;
   14566             :   void *argp2 ;
   14567           1 :   int res2 = 0 ;
   14568             :   
   14569           1 :   if ((argc < 1) || (argc > 1)) {
   14570           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   14571             :   }
   14572           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14573           1 :   if (!SWIG_IsOK(res1)) {
   14574           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec *","appendConfig", 1, self )); 
   14575             :   }
   14576           1 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14577             :   {
   14578           1 :     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   14579           1 :     if (!SWIG_IsOK(res2)) {
   14580           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet","appendConfig", 2, argv[0] )); 
   14581             :     }  
   14582           1 :     if (!argp2) {
   14583           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet","appendConfig", 2, argv[0]));
   14584             :     } else {
   14585           1 :       arg2 = *(reinterpret_cast< kdb::KeySet * >(argp2));
   14586             :     }
   14587             :   }
   14588           2 :   (arg1)->appendConfig(arg2);
   14589           1 :   return Qnil;
   14590             : fail:
   14591             :   return Qnil;
   14592             : }
   14593             : 
   14594             : 
   14595             : 
   14596             : /*
   14597             :   Document-method: Kdbtools::PluginSpec.config=
   14598             : 
   14599             :   call-seq:
   14600             :     config=(KeySet config)
   14601             : 
   14602             : An instance method.
   14603             : 
   14604             : */
   14605             : SWIGINTERN VALUE
   14606           1 : _wrap_PluginSpec_confige___(int argc, VALUE *argv, VALUE self) {
   14607           1 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14608           2 :   kdb::KeySet arg2 ;
   14609           1 :   void *argp1 = 0 ;
   14610           1 :   int res1 = 0 ;
   14611             :   void *argp2 ;
   14612           1 :   int res2 = 0 ;
   14613             :   
   14614           1 :   if ((argc < 1) || (argc > 1)) {
   14615           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   14616             :   }
   14617           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14618           1 :   if (!SWIG_IsOK(res1)) {
   14619           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec *","setConfig", 1, self )); 
   14620             :   }
   14621           1 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14622             :   {
   14623           1 :     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   14624           1 :     if (!SWIG_IsOK(res2)) {
   14625           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet","setConfig", 2, argv[0] )); 
   14626             :     }  
   14627           1 :     if (!argp2) {
   14628           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet","setConfig", 2, argv[0]));
   14629             :     } else {
   14630           1 :       arg2 = *(reinterpret_cast< kdb::KeySet * >(argp2));
   14631             :     }
   14632             :   }
   14633           2 :   (arg1)->setConfig(arg2);
   14634           1 :   return Qnil;
   14635             : fail:
   14636             :   return Qnil;
   14637             : }
   14638             : 
   14639             : 
   14640             : 
   14641             : /*
   14642             :   Document-method: Kdbtools::PluginSpec.validate
   14643             : 
   14644             :   call-seq:
   14645             :     validate(std::string const & str)
   14646             : 
   14647             : An instance method.
   14648             : 
   14649             : */
   14650             : SWIGINTERN VALUE
   14651           0 : _wrap_PluginSpec_validate(int argc, VALUE *argv, VALUE self) {
   14652           0 :   kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *) 0 ;
   14653           0 :   std::string *arg2 = 0 ;
   14654           0 :   void *argp1 = 0 ;
   14655           0 :   int res1 = 0 ;
   14656           0 :   int res2 = SWIG_OLDOBJ ;
   14657             :   
   14658           0 :   if ((argc < 1) || (argc > 1)) {
   14659           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   14660             :   }
   14661           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpec, 0 |  0 );
   14662           0 :   if (!SWIG_IsOK(res1)) {
   14663           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const *","validate", 1, self )); 
   14664             :   }
   14665           0 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   14666             :   {
   14667           0 :     std::string *ptr = (std::string *)0;
   14668           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   14669           0 :     if (!SWIG_IsOK(res2)) {
   14670           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","validate", 2, argv[0] )); 
   14671             :     }
   14672           0 :     if (!ptr) {
   14673           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","validate", 2, argv[0])); 
   14674             :     }
   14675           0 :     arg2 = ptr;
   14676             :   }
   14677             :   try {
   14678           0 :     ((kdb::tools::PluginSpec const *)arg1)->validate((std::string const &)*arg2);
   14679             :   }
   14680           0 :   catch(kdb::tools::BadPluginName &_e) {
   14681           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   14682             :   }
   14683           0 :   catch(kdb::tools::PluginCheckException &_e) {
   14684           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   14685             :   }
   14686           0 :   catch(kdb::tools::ToolException &_e) {
   14687           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   14688             :   }
   14689             :   
   14690           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   14691             :   return Qnil;
   14692             : fail:
   14693             :   if (SWIG_IsNewObj(res2)) delete arg2;
   14694             :   return Qnil;
   14695             : }
   14696             : 
   14697             : 
   14698             : SWIGINTERN void
   14699          16 : free_kdb_tools_PluginSpec(void *self) {
   14700          16 :     kdb::tools::PluginSpec *arg1 = (kdb::tools::PluginSpec *)self;
   14701          16 :     delete arg1;
   14702          16 : }
   14703             : 
   14704             : 
   14705             : /*
   14706             :   Document-class: Kdbtools::PluginSpecName
   14707             : 
   14708             :   Proxy of C++ Kdbtools::PluginSpecName class
   14709             : 
   14710             : 
   14711             : */
   14712             : static swig_class SwigClassPluginSpecName;
   14713             : 
   14714             : 
   14715             : /*
   14716             :   Document-method: Kdbtools::PluginSpecName.call
   14717             : 
   14718             :   call-seq:
   14719             :     call(PluginSpec s1, PluginSpec s2) -> bool
   14720             : 
   14721             : An instance method.
   14722             : 
   14723             : */
   14724             : SWIGINTERN VALUE
   14725           0 : _wrap_PluginSpecName___call__(int argc, VALUE *argv, VALUE self) {
   14726           0 :   kdb::tools::PluginSpecName *arg1 = (kdb::tools::PluginSpecName *) 0 ;
   14727           0 :   kdb::tools::PluginSpec *arg2 = 0 ;
   14728           0 :   kdb::tools::PluginSpec *arg3 = 0 ;
   14729           0 :   void *argp1 = 0 ;
   14730           0 :   int res1 = 0 ;
   14731             :   void *argp2 ;
   14732           0 :   int res2 = 0 ;
   14733             :   void *argp3 ;
   14734           0 :   int res3 = 0 ;
   14735             :   bool result;
   14736           0 :   VALUE vresult = Qnil;
   14737             :   
   14738           0 :   if ((argc < 2) || (argc > 2)) {
   14739           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   14740             :   }
   14741           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpecName, 0 |  0 );
   14742           0 :   if (!SWIG_IsOK(res1)) {
   14743           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpecName const *","operator ()", 1, self )); 
   14744             :   }
   14745           0 :   arg1 = reinterpret_cast< kdb::tools::PluginSpecName * >(argp1);
   14746           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   14747           0 :   if (!SWIG_IsOK(res2)) {
   14748           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","operator ()", 2, argv[0] )); 
   14749             :   }
   14750           0 :   if (!argp2) {
   14751           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","operator ()", 2, argv[0])); 
   14752             :   }
   14753           0 :   arg2 = reinterpret_cast< kdb::tools::PluginSpec * >(argp2);
   14754           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   14755           0 :   if (!SWIG_IsOK(res3)) {
   14756           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","operator ()", 3, argv[1] )); 
   14757             :   }
   14758           0 :   if (!argp3) {
   14759           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","operator ()", 3, argv[1])); 
   14760             :   }
   14761           0 :   arg3 = reinterpret_cast< kdb::tools::PluginSpec * >(argp3);
   14762           0 :   result = (bool)((kdb::tools::PluginSpecName const *)arg1)->operator ()((kdb::tools::PluginSpec const &)*arg2,(kdb::tools::PluginSpec const &)*arg3);
   14763           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   14764             :   return vresult;
   14765             : fail:
   14766             :   return Qnil;
   14767             : }
   14768             : 
   14769             : 
   14770             : SWIGINTERN VALUE
   14771             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   14772           0 : _wrap_PluginSpecName_allocate(VALUE self)
   14773             : #else
   14774             : _wrap_PluginSpecName_allocate(int argc, VALUE *argv, VALUE self)
   14775             : #endif
   14776             : {
   14777           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__PluginSpecName);
   14778             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   14779             :   rb_obj_call_init(vresult, argc, argv);
   14780             : #endif
   14781           0 :   return vresult;
   14782             : }
   14783             : 
   14784             : 
   14785             : 
   14786             : /*
   14787             :   Document-method: Kdbtools::PluginSpecName.new
   14788             : 
   14789             :   call-seq:
   14790             :     PluginSpecName.new
   14791             : 
   14792             : Class constructor.
   14793             : 
   14794             : */
   14795             : SWIGINTERN VALUE
   14796           0 : _wrap_new_PluginSpecName(int argc, VALUE *argv, VALUE self) {
   14797           0 :   kdb::tools::PluginSpecName *result = 0 ;
   14798             :   
   14799           0 :   if ((argc < 0) || (argc > 0)) {
   14800           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   14801             :   }
   14802           0 :   result = (kdb::tools::PluginSpecName *)new kdb::tools::PluginSpecName();
   14803           0 :   DATA_PTR(self) = result;
   14804             :   return self;
   14805             : fail:
   14806             :   return Qnil;
   14807             : }
   14808             : 
   14809             : 
   14810             : SWIGINTERN void
   14811           0 : free_kdb_tools_PluginSpecName(void *self) {
   14812           0 :     kdb::tools::PluginSpecName *arg1 = (kdb::tools::PluginSpecName *)self;
   14813           0 :     delete arg1;
   14814           0 : }
   14815             : 
   14816             : 
   14817             : /*
   14818             :   Document-class: Kdbtools::PluginSpecRefName
   14819             : 
   14820             :   Proxy of C++ Kdbtools::PluginSpecRefName class
   14821             : 
   14822             : 
   14823             : */
   14824             : static swig_class SwigClassPluginSpecRefName;
   14825             : 
   14826             : 
   14827             : /*
   14828             :   Document-method: Kdbtools::PluginSpecRefName.call
   14829             : 
   14830             :   call-seq:
   14831             :     call(PluginSpec s1, PluginSpec s2) -> bool
   14832             : 
   14833             : An instance method.
   14834             : 
   14835             : */
   14836             : SWIGINTERN VALUE
   14837           0 : _wrap_PluginSpecRefName___call__(int argc, VALUE *argv, VALUE self) {
   14838           0 :   kdb::tools::PluginSpecRefName *arg1 = (kdb::tools::PluginSpecRefName *) 0 ;
   14839           0 :   kdb::tools::PluginSpec *arg2 = 0 ;
   14840           0 :   kdb::tools::PluginSpec *arg3 = 0 ;
   14841           0 :   void *argp1 = 0 ;
   14842           0 :   int res1 = 0 ;
   14843             :   void *argp2 ;
   14844           0 :   int res2 = 0 ;
   14845             :   void *argp3 ;
   14846           0 :   int res3 = 0 ;
   14847             :   bool result;
   14848           0 :   VALUE vresult = Qnil;
   14849             :   
   14850           0 :   if ((argc < 2) || (argc > 2)) {
   14851           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   14852             :   }
   14853           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpecRefName, 0 |  0 );
   14854           0 :   if (!SWIG_IsOK(res1)) {
   14855           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpecRefName const *","operator ()", 1, self )); 
   14856             :   }
   14857           0 :   arg1 = reinterpret_cast< kdb::tools::PluginSpecRefName * >(argp1);
   14858           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   14859           0 :   if (!SWIG_IsOK(res2)) {
   14860           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","operator ()", 2, argv[0] )); 
   14861             :   }
   14862           0 :   if (!argp2) {
   14863           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","operator ()", 2, argv[0])); 
   14864             :   }
   14865           0 :   arg2 = reinterpret_cast< kdb::tools::PluginSpec * >(argp2);
   14866           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   14867           0 :   if (!SWIG_IsOK(res3)) {
   14868           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","operator ()", 3, argv[1] )); 
   14869             :   }
   14870           0 :   if (!argp3) {
   14871           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","operator ()", 3, argv[1])); 
   14872             :   }
   14873           0 :   arg3 = reinterpret_cast< kdb::tools::PluginSpec * >(argp3);
   14874           0 :   result = (bool)((kdb::tools::PluginSpecRefName const *)arg1)->operator ()((kdb::tools::PluginSpec const &)*arg2,(kdb::tools::PluginSpec const &)*arg3);
   14875           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   14876             :   return vresult;
   14877             : fail:
   14878             :   return Qnil;
   14879             : }
   14880             : 
   14881             : 
   14882             : SWIGINTERN VALUE
   14883             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   14884           0 : _wrap_PluginSpecRefName_allocate(VALUE self)
   14885             : #else
   14886             : _wrap_PluginSpecRefName_allocate(int argc, VALUE *argv, VALUE self)
   14887             : #endif
   14888             : {
   14889           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__PluginSpecRefName);
   14890             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   14891             :   rb_obj_call_init(vresult, argc, argv);
   14892             : #endif
   14893           0 :   return vresult;
   14894             : }
   14895             : 
   14896             : 
   14897             : 
   14898             : /*
   14899             :   Document-method: Kdbtools::PluginSpecRefName.new
   14900             : 
   14901             :   call-seq:
   14902             :     PluginSpecRefName.new
   14903             : 
   14904             : Class constructor.
   14905             : 
   14906             : */
   14907             : SWIGINTERN VALUE
   14908           0 : _wrap_new_PluginSpecRefName(int argc, VALUE *argv, VALUE self) {
   14909           0 :   kdb::tools::PluginSpecRefName *result = 0 ;
   14910             :   
   14911           0 :   if ((argc < 0) || (argc > 0)) {
   14912           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   14913             :   }
   14914           0 :   result = (kdb::tools::PluginSpecRefName *)new kdb::tools::PluginSpecRefName();
   14915           0 :   DATA_PTR(self) = result;
   14916             :   return self;
   14917             : fail:
   14918             :   return Qnil;
   14919             : }
   14920             : 
   14921             : 
   14922             : SWIGINTERN void
   14923           0 : free_kdb_tools_PluginSpecRefName(void *self) {
   14924           0 :     kdb::tools::PluginSpecRefName *arg1 = (kdb::tools::PluginSpecRefName *)self;
   14925           0 :     delete arg1;
   14926           0 : }
   14927             : 
   14928             : 
   14929             : /*
   14930             :   Document-class: Kdbtools::PluginSpecFullName
   14931             : 
   14932             :   Proxy of C++ Kdbtools::PluginSpecFullName class
   14933             : 
   14934             : 
   14935             : */
   14936             : static swig_class SwigClassPluginSpecFullName;
   14937             : 
   14938             : 
   14939             : /*
   14940             :   Document-method: Kdbtools::PluginSpecFullName.call
   14941             : 
   14942             :   call-seq:
   14943             :     call(PluginSpec s1, PluginSpec s2) -> bool
   14944             : 
   14945             : An instance method.
   14946             : 
   14947             : */
   14948             : SWIGINTERN VALUE
   14949           0 : _wrap_PluginSpecFullName___call__(int argc, VALUE *argv, VALUE self) {
   14950           0 :   kdb::tools::PluginSpecFullName *arg1 = (kdb::tools::PluginSpecFullName *) 0 ;
   14951           0 :   kdb::tools::PluginSpec *arg2 = 0 ;
   14952           0 :   kdb::tools::PluginSpec *arg3 = 0 ;
   14953           0 :   void *argp1 = 0 ;
   14954           0 :   int res1 = 0 ;
   14955             :   void *argp2 ;
   14956           0 :   int res2 = 0 ;
   14957             :   void *argp3 ;
   14958           0 :   int res3 = 0 ;
   14959             :   bool result;
   14960           0 :   VALUE vresult = Qnil;
   14961             :   
   14962           0 :   if ((argc < 2) || (argc > 2)) {
   14963           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   14964             :   }
   14965           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpecFullName, 0 |  0 );
   14966           0 :   if (!SWIG_IsOK(res1)) {
   14967           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpecFullName const *","operator ()", 1, self )); 
   14968             :   }
   14969           0 :   arg1 = reinterpret_cast< kdb::tools::PluginSpecFullName * >(argp1);
   14970           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   14971           0 :   if (!SWIG_IsOK(res2)) {
   14972           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","operator ()", 2, argv[0] )); 
   14973             :   }
   14974           0 :   if (!argp2) {
   14975           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","operator ()", 2, argv[0])); 
   14976             :   }
   14977           0 :   arg2 = reinterpret_cast< kdb::tools::PluginSpec * >(argp2);
   14978           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   14979           0 :   if (!SWIG_IsOK(res3)) {
   14980           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","operator ()", 3, argv[1] )); 
   14981             :   }
   14982           0 :   if (!argp3) {
   14983           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","operator ()", 3, argv[1])); 
   14984             :   }
   14985           0 :   arg3 = reinterpret_cast< kdb::tools::PluginSpec * >(argp3);
   14986           0 :   result = (bool)((kdb::tools::PluginSpecFullName const *)arg1)->operator ()((kdb::tools::PluginSpec const &)*arg2,(kdb::tools::PluginSpec const &)*arg3);
   14987           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   14988             :   return vresult;
   14989             : fail:
   14990             :   return Qnil;
   14991             : }
   14992             : 
   14993             : 
   14994             : SWIGINTERN VALUE
   14995             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   14996           0 : _wrap_PluginSpecFullName_allocate(VALUE self)
   14997             : #else
   14998             : _wrap_PluginSpecFullName_allocate(int argc, VALUE *argv, VALUE self)
   14999             : #endif
   15000             : {
   15001           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__PluginSpecFullName);
   15002             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   15003             :   rb_obj_call_init(vresult, argc, argv);
   15004             : #endif
   15005           0 :   return vresult;
   15006             : }
   15007             : 
   15008             : 
   15009             : 
   15010             : /*
   15011             :   Document-method: Kdbtools::PluginSpecFullName.new
   15012             : 
   15013             :   call-seq:
   15014             :     PluginSpecFullName.new
   15015             : 
   15016             : Class constructor.
   15017             : 
   15018             : */
   15019             : SWIGINTERN VALUE
   15020           0 : _wrap_new_PluginSpecFullName(int argc, VALUE *argv, VALUE self) {
   15021           0 :   kdb::tools::PluginSpecFullName *result = 0 ;
   15022             :   
   15023           0 :   if ((argc < 0) || (argc > 0)) {
   15024           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   15025             :   }
   15026           0 :   result = (kdb::tools::PluginSpecFullName *)new kdb::tools::PluginSpecFullName();
   15027           0 :   DATA_PTR(self) = result;
   15028             :   return self;
   15029             : fail:
   15030             :   return Qnil;
   15031             : }
   15032             : 
   15033             : 
   15034             : SWIGINTERN void
   15035           0 : free_kdb_tools_PluginSpecFullName(void *self) {
   15036           0 :     kdb::tools::PluginSpecFullName *arg1 = (kdb::tools::PluginSpecFullName *)self;
   15037           0 :     delete arg1;
   15038           0 : }
   15039             : 
   15040             : 
   15041             : /*
   15042             :   Document-class: Kdbtools::PluginSpecHash
   15043             : 
   15044             :   Proxy of C++ Kdbtools::PluginSpecHash class
   15045             : 
   15046             : 
   15047             : */
   15048             : static swig_class SwigClassPluginSpecHash;
   15049             : 
   15050             : 
   15051             : /*
   15052             :   Document-method: Kdbtools::PluginSpecHash.call
   15053             : 
   15054             :   call-seq:
   15055             :     call(PluginSpec s) -> size_t
   15056             : 
   15057             : An instance method.
   15058             : 
   15059             : */
   15060             : SWIGINTERN VALUE
   15061           0 : _wrap_PluginSpecHash___call__(int argc, VALUE *argv, VALUE self) {
   15062           0 :   kdb::tools::PluginSpecHash *arg1 = (kdb::tools::PluginSpecHash *) 0 ;
   15063           0 :   kdb::tools::PluginSpec *arg2 = 0 ;
   15064           0 :   void *argp1 = 0 ;
   15065           0 :   int res1 = 0 ;
   15066             :   void *argp2 ;
   15067           0 :   int res2 = 0 ;
   15068             :   size_t result;
   15069           0 :   VALUE vresult = Qnil;
   15070             :   
   15071           0 :   if ((argc < 1) || (argc > 1)) {
   15072           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   15073             :   }
   15074           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__PluginSpecHash, 0 |  0 );
   15075           0 :   if (!SWIG_IsOK(res1)) {
   15076           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpecHash const *","operator ()", 1, self )); 
   15077             :   }
   15078           0 :   arg1 = reinterpret_cast< kdb::tools::PluginSpecHash * >(argp1);
   15079           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   15080           0 :   if (!SWIG_IsOK(res2)) {
   15081           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","operator ()", 2, argv[0] )); 
   15082             :   }
   15083           0 :   if (!argp2) {
   15084           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","operator ()", 2, argv[0])); 
   15085             :   }
   15086           0 :   arg2 = reinterpret_cast< kdb::tools::PluginSpec * >(argp2);
   15087           0 :   result = ((kdb::tools::PluginSpecHash const *)arg1)->operator ()((kdb::tools::PluginSpec const &)*arg2);
   15088           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
   15089             :   return vresult;
   15090             : fail:
   15091             :   return Qnil;
   15092             : }
   15093             : 
   15094             : 
   15095             : SWIGINTERN VALUE
   15096             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   15097           0 : _wrap_PluginSpecHash_allocate(VALUE self)
   15098             : #else
   15099             : _wrap_PluginSpecHash_allocate(int argc, VALUE *argv, VALUE self)
   15100             : #endif
   15101             : {
   15102           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__PluginSpecHash);
   15103             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   15104             :   rb_obj_call_init(vresult, argc, argv);
   15105             : #endif
   15106           0 :   return vresult;
   15107             : }
   15108             : 
   15109             : 
   15110             : 
   15111             : /*
   15112             :   Document-method: Kdbtools::PluginSpecHash.new
   15113             : 
   15114             :   call-seq:
   15115             :     PluginSpecHash.new
   15116             : 
   15117             : Class constructor.
   15118             : 
   15119             : */
   15120             : SWIGINTERN VALUE
   15121           0 : _wrap_new_PluginSpecHash(int argc, VALUE *argv, VALUE self) {
   15122           0 :   kdb::tools::PluginSpecHash *result = 0 ;
   15123             :   
   15124           0 :   if ((argc < 0) || (argc > 0)) {
   15125           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   15126             :   }
   15127           0 :   result = (kdb::tools::PluginSpecHash *)new kdb::tools::PluginSpecHash();
   15128           0 :   DATA_PTR(self) = result;
   15129             :   return self;
   15130             : fail:
   15131             :   return Qnil;
   15132             : }
   15133             : 
   15134             : 
   15135             : SWIGINTERN void
   15136           0 : free_kdb_tools_PluginSpecHash(void *self) {
   15137           0 :     kdb::tools::PluginSpecHash *arg1 = (kdb::tools::PluginSpecHash *)self;
   15138           0 :     delete arg1;
   15139           0 : }
   15140             : 
   15141             : 
   15142             : /*
   15143             :   Document-method: Kdbtools::tools.<<
   15144             : 
   15145             :   call-seq:
   15146             :     <<(os, spec) -> std::ostream &
   15147             : 
   15148             : Left shifting or appending operator.
   15149             : */
   15150             : SWIGINTERN VALUE
   15151           0 : _wrap___lshift__(int argc, VALUE *argv, VALUE self) {
   15152           0 :   std::ostream *arg1 = 0 ;
   15153           0 :   kdb::tools::PluginSpec *arg2 = 0 ;
   15154           0 :   void *argp1 = 0 ;
   15155           0 :   int res1 = 0 ;
   15156             :   void *argp2 ;
   15157           0 :   int res2 = 0 ;
   15158           0 :   std::ostream *result = 0 ;
   15159           0 :   VALUE vresult = Qnil;
   15160             :   
   15161           0 :   if ((argc < 2) || (argc > 2)) {
   15162           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   15163             :   }
   15164           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
   15165           0 :   if (!SWIG_IsOK(res1)) {
   15166           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::ostream &","kdb::tools::operator <<", 1, argv[0] )); 
   15167             :   }
   15168           0 :   if (!argp1) {
   15169           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ostream &","kdb::tools::operator <<", 1, argv[0])); 
   15170             :   }
   15171           0 :   arg1 = reinterpret_cast< std::ostream * >(argp1);
   15172           0 :   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   15173           0 :   if (!SWIG_IsOK(res2)) {
   15174           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","kdb::tools::operator <<", 2, argv[1] )); 
   15175             :   }
   15176           0 :   if (!argp2) {
   15177           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","kdb::tools::operator <<", 2, argv[1])); 
   15178             :   }
   15179           0 :   arg2 = reinterpret_cast< kdb::tools::PluginSpec * >(argp2);
   15180           0 :   result = (std::ostream *) &kdb::tools::operator <<(*arg1,(kdb::tools::PluginSpec const &)*arg2);
   15181           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
   15182             :   return vresult;
   15183             : fail:
   15184             :   return Qnil;
   15185             : }
   15186             : 
   15187             : 
   15188             : 
   15189             : /*
   15190             :   Document-class: Kdbtools::Plugin
   15191             : 
   15192             :   Proxy of C++ Kdbtools::Plugin class
   15193             : 
   15194             : 
   15195             : */
   15196             : static swig_class SwigClassPlugin;
   15197             : 
   15198             : 
   15199             : /*
   15200             :   Document-method: Kdbtools::Plugin.new
   15201             : 
   15202             :   call-seq:
   15203             :     Plugin.new(PluginSpec spec, KeySet modules)
   15204             :     Plugin.new(Plugin other)
   15205             : 
   15206             : Class constructor.
   15207             : 
   15208             : */
   15209             : SWIGINTERN VALUE
   15210           0 : _wrap_new_Plugin__SWIG_0(int argc, VALUE *argv, VALUE self) {
   15211           0 :   kdb::tools::PluginSpec *arg1 = 0 ;
   15212           0 :   kdb::KeySet *arg2 = 0 ;
   15213             :   void *argp1 ;
   15214           0 :   int res1 = 0 ;
   15215           0 :   void *argp2 = 0 ;
   15216           0 :   int res2 = 0 ;
   15217           0 :   kdb::tools::Plugin *result = 0 ;
   15218             :   
   15219           0 :   if ((argc < 2) || (argc > 2)) {
   15220           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   15221             :   }
   15222           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   15223           0 :   if (!SWIG_IsOK(res1)) {
   15224           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","Plugin", 1, argv[0] )); 
   15225             :   }
   15226           0 :   if (!argp1) {
   15227           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","Plugin", 1, argv[0])); 
   15228             :   }
   15229           0 :   arg1 = reinterpret_cast< kdb::tools::PluginSpec * >(argp1);
   15230           0 :   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   15231           0 :   if (!SWIG_IsOK(res2)) {
   15232           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet &","Plugin", 2, argv[1] )); 
   15233             :   }
   15234           0 :   if (!argp2) {
   15235           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","Plugin", 2, argv[1])); 
   15236             :   }
   15237           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   15238             :   try {
   15239           0 :     result = (kdb::tools::Plugin *)new kdb::tools::Plugin((kdb::tools::PluginSpec const &)*arg1,*arg2);
   15240           0 :     DATA_PTR(self) = result;
   15241             :   }
   15242           0 :   catch(kdb::tools::NoPlugin &_e) {
   15243           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__NoPlugin, SWIG_NewPointerObj((new kdb::tools::NoPlugin(static_cast< const kdb::tools::NoPlugin& >(_e))),SWIGTYPE_p_kdb__tools__NoPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   15244             :   }
   15245           0 :   catch(kdb::tools::PluginCheckException &_e) {
   15246           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   15247             :   }
   15248           0 :   catch(kdb::tools::ToolException &_e) {
   15249           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   15250             :   }
   15251             :   
   15252             :   return self;
   15253             : fail:
   15254             :   return Qnil;
   15255             : }
   15256             : 
   15257             : 
   15258             : SWIGINTERN VALUE
   15259             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   15260           0 : _wrap_Plugin_allocate(VALUE self)
   15261             : #else
   15262             : _wrap_Plugin_allocate(int argc, VALUE *argv, VALUE self)
   15263             : #endif
   15264             : {
   15265           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__Plugin);
   15266             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   15267             :   rb_obj_call_init(vresult, argc, argv);
   15268             : #endif
   15269           0 :   return vresult;
   15270             : }
   15271             : 
   15272             : 
   15273             : SWIGINTERN VALUE
   15274           0 : _wrap_new_Plugin__SWIG_1(int argc, VALUE *argv, VALUE self) {
   15275           0 :   kdb::tools::Plugin *arg1 = 0 ;
   15276             :   void *argp1 ;
   15277           0 :   int res1 = 0 ;
   15278           0 :   kdb::tools::Plugin *result = 0 ;
   15279             :   
   15280           0 :   if ((argc < 1) || (argc > 1)) {
   15281           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   15282             :   }
   15283           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   15284           0 :   if (!SWIG_IsOK(res1)) {
   15285           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin const &","Plugin", 1, argv[0] )); 
   15286             :   }
   15287           0 :   if (!argp1) {
   15288           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin const &","Plugin", 1, argv[0])); 
   15289             :   }
   15290           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15291             :   try {
   15292           0 :     result = (kdb::tools::Plugin *)new kdb::tools::Plugin((kdb::tools::Plugin const &)*arg1);
   15293           0 :     DATA_PTR(self) = result;
   15294             :   }
   15295           0 :   catch(kdb::tools::NoPlugin &_e) {
   15296           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__NoPlugin, SWIG_NewPointerObj((new kdb::tools::NoPlugin(static_cast< const kdb::tools::NoPlugin& >(_e))),SWIGTYPE_p_kdb__tools__NoPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   15297             :   }
   15298           0 :   catch(kdb::tools::PluginCheckException &_e) {
   15299           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   15300             :   }
   15301           0 :   catch(kdb::tools::ToolException &_e) {
   15302           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   15303             :   }
   15304             :   
   15305             :   return self;
   15306             : fail:
   15307             :   return Qnil;
   15308             : }
   15309             : 
   15310             : 
   15311           0 : SWIGINTERN VALUE _wrap_new_Plugin(int nargs, VALUE *args, VALUE self) {
   15312             :   int argc;
   15313             :   VALUE argv[2];
   15314             :   int ii;
   15315             :   
   15316           0 :   argc = nargs;
   15317           0 :   if (argc > 2) SWIG_fail;
   15318             :   for (ii = 0; (ii < argc); ++ii) {
   15319             :     argv[ii] = args[ii];
   15320             :   }
   15321           0 :   if (argc == 1) {
   15322           0 :     return _wrap_new_Plugin__SWIG_1(nargs, args, self);
   15323             :   }
   15324           0 :   if (argc == 2) {
   15325           0 :     return _wrap_new_Plugin__SWIG_0(nargs, args, self);
   15326             :   }
   15327             :   
   15328             : fail:
   15329             :   Ruby_Format_OverloadedError( argc, 2, "Plugin.new", 
   15330             :     "    Plugin.new(kdb::tools::PluginSpec const &spec, kdb::KeySet &modules)\n"
   15331           0 :     "    Plugin.new(kdb::tools::Plugin const &other)\n");
   15332             :   
   15333             :   return Qnil;
   15334             : }
   15335             : 
   15336             : 
   15337             : SWIGINTERN void
   15338           3 : free_kdb_tools_Plugin(void *self) {
   15339           3 :     kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *)self;
   15340           3 :     delete arg1;
   15341           3 : }
   15342             : 
   15343             : 
   15344             : /*
   15345             :   Document-method: Kdbtools::Plugin.firstRef
   15346             : 
   15347             :   call-seq:
   15348             :     firstRef -> bool
   15349             : 
   15350             : Get value of attribute.
   15351             : 
   15352             : */
   15353             : 
   15354             : /*
   15355             :   Document-method: Kdbtools::Plugin.firstRef=
   15356             : 
   15357             :   call-seq:
   15358             :     firstRef=(x) -> bool
   15359             : 
   15360             : Set new value for attribute.
   15361             : 
   15362             : */
   15363             : SWIGINTERN VALUE
   15364           0 : _wrap_Plugin_firstRef_set(int argc, VALUE *argv, VALUE self) {
   15365           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15366             :   bool arg2 ;
   15367           0 :   void *argp1 = 0 ;
   15368           0 :   int res1 = 0 ;
   15369             :   bool val2 ;
   15370           0 :   int ecode2 = 0 ;
   15371             :   
   15372           0 :   if ((argc < 1) || (argc > 1)) {
   15373           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   15374             :   }
   15375           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15376           0 :   if (!SWIG_IsOK(res1)) {
   15377           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","firstRef", 1, self )); 
   15378             :   }
   15379           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15380           0 :   ecode2 = SWIG_AsVal_bool(argv[0], &val2);
   15381           0 :   if (!SWIG_IsOK(ecode2)) {
   15382           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","firstRef", 2, argv[0] ));
   15383             :   } 
   15384           0 :   arg2 = static_cast< bool >(val2);
   15385           0 :   if (arg1) (arg1)->firstRef = arg2;
   15386             :   return Qnil;
   15387             : fail:
   15388             :   return Qnil;
   15389             : }
   15390             : 
   15391             : 
   15392             : SWIGINTERN VALUE
   15393           0 : _wrap_Plugin_firstRef_get(int argc, VALUE *argv, VALUE self) {
   15394           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15395           0 :   void *argp1 = 0 ;
   15396           0 :   int res1 = 0 ;
   15397             :   bool result;
   15398           0 :   VALUE vresult = Qnil;
   15399             :   
   15400           0 :   if ((argc < 0) || (argc > 0)) {
   15401           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   15402             :   }
   15403           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15404           0 :   if (!SWIG_IsOK(res1)) {
   15405           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","firstRef", 1, self )); 
   15406             :   }
   15407           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15408           0 :   result = (bool) ((arg1)->firstRef);
   15409           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   15410             :   return vresult;
   15411             : fail:
   15412             :   return Qnil;
   15413             : }
   15414             : 
   15415             : 
   15416             : 
   15417             : /*
   15418             :   Document-method: Kdbtools::Plugin.load_info
   15419             : 
   15420             :   call-seq:
   15421             :     load_info
   15422             : 
   15423             : An instance method.
   15424             : 
   15425             : */
   15426             : SWIGINTERN VALUE
   15427           0 : _wrap_Plugin_load_info(int argc, VALUE *argv, VALUE self) {
   15428           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15429           0 :   void *argp1 = 0 ;
   15430           0 :   int res1 = 0 ;
   15431             :   
   15432           0 :   if ((argc < 0) || (argc > 0)) {
   15433           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   15434             :   }
   15435           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15436           0 :   if (!SWIG_IsOK(res1)) {
   15437           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","loadInfo", 1, self )); 
   15438             :   }
   15439           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15440             :   try {
   15441           0 :     (arg1)->loadInfo();
   15442             :   }
   15443           0 :   catch(kdb::tools::MissingSymbol &_e) {
   15444           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   15445             :   }
   15446           0 :   catch(kdb::tools::PluginCheckException &_e) {
   15447           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   15448             :   }
   15449           0 :   catch(kdb::tools::ToolException &_e) {
   15450           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   15451             :   }
   15452             :   
   15453             :   return Qnil;
   15454             : fail:
   15455             :   return Qnil;
   15456             : }
   15457             : 
   15458             : 
   15459             : 
   15460             : /*
   15461             :   Document-method: Kdbtools::Plugin.parse
   15462             : 
   15463             :   call-seq:
   15464             :     parse
   15465             : 
   15466             : An instance method.
   15467             : 
   15468             : */
   15469             : SWIGINTERN VALUE
   15470           0 : _wrap_Plugin_parse(int argc, VALUE *argv, VALUE self) {
   15471           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15472           0 :   void *argp1 = 0 ;
   15473           0 :   int res1 = 0 ;
   15474             :   
   15475           0 :   if ((argc < 0) || (argc > 0)) {
   15476           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   15477             :   }
   15478           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15479           0 :   if (!SWIG_IsOK(res1)) {
   15480           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","parse", 1, self )); 
   15481             :   }
   15482           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15483             :   try {
   15484           0 :     (arg1)->parse();
   15485             :   }
   15486           0 :   catch(kdb::tools::PluginNoContract &_e) {
   15487           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginNoContract, SWIG_NewPointerObj((new kdb::tools::PluginNoContract(static_cast< const kdb::tools::PluginNoContract& >(_e))),SWIGTYPE_p_kdb__tools__PluginNoContract,SWIG_POINTER_OWN))); SWIG_fail;
   15488             :   }
   15489           0 :   catch(kdb::tools::PluginNoInfo &_e) {
   15490           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginNoInfo, SWIG_NewPointerObj((new kdb::tools::PluginNoInfo(static_cast< const kdb::tools::PluginNoInfo& >(_e))),SWIGTYPE_p_kdb__tools__PluginNoInfo,SWIG_POINTER_OWN))); SWIG_fail;
   15491             :   }
   15492           0 :   catch(kdb::tools::PluginCheckException &_e) {
   15493           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   15494             :   }
   15495           0 :   catch(kdb::tools::ToolException &_e) {
   15496           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   15497             :   }
   15498             :   
   15499             :   return Qnil;
   15500             : fail:
   15501             :   return Qnil;
   15502             : }
   15503             : 
   15504             : 
   15505             : 
   15506             : /*
   15507             :   Document-method: Kdbtools::Plugin.check
   15508             : 
   15509             :   call-seq:
   15510             :     check(VectorStr warnings)
   15511             : 
   15512             : An instance method.
   15513             : 
   15514             : */
   15515             : SWIGINTERN VALUE
   15516           0 : _wrap_Plugin_check(int argc, VALUE *argv, VALUE self) {
   15517           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15518           0 :   std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
   15519           0 :   void *argp1 = 0 ;
   15520           0 :   int res1 = 0 ;
   15521           0 :   void *argp2 = 0 ;
   15522           0 :   int res2 = 0 ;
   15523             :   
   15524           0 :   if ((argc < 1) || (argc > 1)) {
   15525           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   15526             :   }
   15527           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15528           0 :   if (!SWIG_IsOK(res1)) {
   15529           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","check", 1, self )); 
   15530             :   }
   15531           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15532           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
   15533           0 :   if (!SWIG_IsOK(res2)) {
   15534           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::string,std::allocator< std::string > > &","check", 2, argv[0] )); 
   15535             :   }
   15536           0 :   if (!argp2) {
   15537           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::string,std::allocator< std::string > > &","check", 2, argv[0])); 
   15538             :   }
   15539           0 :   arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
   15540             :   try {
   15541           0 :     (arg1)->check(*arg2);
   15542             :   }
   15543           0 :   catch(kdb::tools::VersionInfoMismatch &_e) {
   15544           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__VersionInfoMismatch, SWIG_NewPointerObj((new kdb::tools::VersionInfoMismatch(static_cast< const kdb::tools::VersionInfoMismatch& >(_e))),SWIGTYPE_p_kdb__tools__VersionInfoMismatch,SWIG_POINTER_OWN))); SWIG_fail;
   15545             :   }
   15546           0 :   catch(kdb::tools::WrongStatus &_e) {
   15547           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__WrongStatus, SWIG_NewPointerObj((new kdb::tools::WrongStatus(static_cast< const kdb::tools::WrongStatus& >(_e))),SWIGTYPE_p_kdb__tools__WrongStatus,SWIG_POINTER_OWN))); SWIG_fail;
   15548             :   }
   15549           0 :   catch(kdb::tools::SymbolMismatch &_e) {
   15550           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__SymbolMismatch, SWIG_NewPointerObj((new kdb::tools::SymbolMismatch(static_cast< const kdb::tools::SymbolMismatch& >(_e))),SWIGTYPE_p_kdb__tools__SymbolMismatch,SWIG_POINTER_OWN))); SWIG_fail;
   15551             :   }
   15552           0 :   catch(kdb::tools::SymbolDuplicate &_e) {
   15553           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__SymbolDuplicate, SWIG_NewPointerObj((new kdb::tools::SymbolDuplicate(static_cast< const kdb::tools::SymbolDuplicate& >(_e))),SWIGTYPE_p_kdb__tools__SymbolDuplicate,SWIG_POINTER_OWN))); SWIG_fail;
   15554             :   }
   15555           0 :   catch(kdb::tools::PluginCheckException &_e) {
   15556           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   15557             :   }
   15558           0 :   catch(kdb::tools::ToolException &_e) {
   15559           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   15560             :   }
   15561             :   
   15562             :   return Qnil;
   15563             : fail:
   15564             :   return Qnil;
   15565             : }
   15566             : 
   15567             : 
   15568             : 
   15569             : /*
   15570             :   Document-method: Kdbtools::Plugin.__deref__
   15571             : 
   15572             :   call-seq:
   15573             :     __deref__ -> ckdb::Plugin *
   15574             : 
   15575             : An instance method.
   15576             : 
   15577             : */
   15578             : SWIGINTERN VALUE
   15579           0 : _wrap_Plugin___deref__(int argc, VALUE *argv, VALUE self) {
   15580           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15581           0 :   void *argp1 = 0 ;
   15582           0 :   int res1 = 0 ;
   15583           0 :   ckdb::Plugin *result = 0 ;
   15584           0 :   VALUE vresult = Qnil;
   15585             :   
   15586           0 :   if ((argc < 0) || (argc > 0)) {
   15587           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   15588             :   }
   15589           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15590           0 :   if (!SWIG_IsOK(res1)) {
   15591           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","operator ->", 1, self )); 
   15592             :   }
   15593           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15594           0 :   result = (ckdb::Plugin *)(arg1)->operator ->();
   15595           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__Plugin, 0 |  0 );
   15596             :   return vresult;
   15597             : fail:
   15598             :   return Qnil;
   15599             : }
   15600             : 
   15601             : 
   15602             : 
   15603             : /*
   15604             :   Document-method: Kdbtools::Plugin.lookup_info
   15605             : 
   15606             :   call-seq:
   15607             :     lookup_info(std::string item, std::string section="infos") -> std::string
   15608             :     lookup_info(std::string item) -> std::string
   15609             : 
   15610             : An instance method.
   15611             : 
   15612             : */
   15613             : SWIGINTERN VALUE
   15614           0 : _wrap_Plugin_lookup_info__SWIG_0(int argc, VALUE *argv, VALUE self) {
   15615           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15616           0 :   std::string arg2 ;
   15617           0 :   std::string arg3 ;
   15618           0 :   void *argp1 = 0 ;
   15619           0 :   int res1 = 0 ;
   15620           0 :   std::string result;
   15621           0 :   VALUE vresult = Qnil;
   15622             :   
   15623           0 :   if ((argc < 2) || (argc > 2)) {
   15624           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   15625             :   }
   15626           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15627           0 :   if (!SWIG_IsOK(res1)) {
   15628           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","lookupInfo", 1, self )); 
   15629             :   }
   15630           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15631             :   {
   15632           0 :     std::string *ptr = (std::string *)0;
   15633           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   15634           0 :     if (!SWIG_IsOK(res) || !ptr) {
   15635           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","lookupInfo", 2, argv[0] )); 
   15636             :     }
   15637           0 :     arg2 = *ptr;
   15638           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   15639             :   }
   15640             :   {
   15641           0 :     std::string *ptr = (std::string *)0;
   15642           0 :     int res = SWIG_AsPtr_std_string(argv[1], &ptr);
   15643           0 :     if (!SWIG_IsOK(res) || !ptr) {
   15644           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","lookupInfo", 3, argv[1] )); 
   15645             :     }
   15646           0 :     arg3 = *ptr;
   15647           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   15648             :   }
   15649           0 :   result = (arg1)->lookupInfo(arg2,arg3);
   15650           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   15651           0 :   return vresult;
   15652             : fail:
   15653             :   return Qnil;
   15654             : }
   15655             : 
   15656             : 
   15657             : SWIGINTERN VALUE
   15658           0 : _wrap_Plugin_lookup_info__SWIG_1(int argc, VALUE *argv, VALUE self) {
   15659           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15660           0 :   std::string arg2 ;
   15661           0 :   void *argp1 = 0 ;
   15662           0 :   int res1 = 0 ;
   15663           0 :   std::string result;
   15664           0 :   VALUE vresult = Qnil;
   15665             :   
   15666           0 :   if ((argc < 1) || (argc > 1)) {
   15667           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   15668             :   }
   15669           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15670           0 :   if (!SWIG_IsOK(res1)) {
   15671           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","lookupInfo", 1, self )); 
   15672             :   }
   15673           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15674             :   {
   15675           0 :     std::string *ptr = (std::string *)0;
   15676           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   15677           0 :     if (!SWIG_IsOK(res) || !ptr) {
   15678           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","lookupInfo", 2, argv[0] )); 
   15679             :     }
   15680           0 :     arg2 = *ptr;
   15681           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   15682             :   }
   15683           0 :   result = (arg1)->lookupInfo(arg2);
   15684           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   15685           0 :   return vresult;
   15686             : fail:
   15687             :   return Qnil;
   15688             : }
   15689             : 
   15690             : 
   15691           0 : SWIGINTERN VALUE _wrap_Plugin_lookup_info(int nargs, VALUE *args, VALUE self) {
   15692             :   int argc;
   15693             :   VALUE argv[4];
   15694             :   int ii;
   15695             :   
   15696           0 :   argc = nargs + 1;
   15697             :   argv[0] = self;
   15698           0 :   if (argc > 4) SWIG_fail;
   15699             :   for (ii = 1; (ii < argc); ++ii) {
   15700             :     argv[ii] = args[ii-1];
   15701             :   }
   15702           0 :   if (argc == 2) {
   15703           0 :     return _wrap_Plugin_lookup_info__SWIG_1(nargs, args, self);
   15704             :   }
   15705           0 :   if (argc == 3) {
   15706           0 :     return _wrap_Plugin_lookup_info__SWIG_0(nargs, args, self);
   15707             :   }
   15708             :   
   15709             : fail:
   15710             :   Ruby_Format_OverloadedError( argc, 4, "Plugin.lookup_info", 
   15711             :     "    std::string Plugin.lookup_info(std::string item, std::string section)\n"
   15712           0 :     "    std::string Plugin.lookup_info(std::string item)\n");
   15713             :   
   15714             :   return Qnil;
   15715             : }
   15716             : 
   15717             : 
   15718             : 
   15719             : /*
   15720             :   Document-method: Kdbtools::Plugin.find_info
   15721             : 
   15722             :   call-seq:
   15723             :     find_info(std::string check, std::string item, std::string section="infos") -> bool
   15724             :     find_info(std::string check, std::string item) -> bool
   15725             : 
   15726             : An instance method.
   15727             : 
   15728             : */
   15729             : SWIGINTERN VALUE
   15730           0 : _wrap_Plugin_find_info__SWIG_0(int argc, VALUE *argv, VALUE self) {
   15731           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15732           0 :   std::string arg2 ;
   15733           0 :   std::string arg3 ;
   15734           0 :   std::string arg4 ;
   15735           0 :   void *argp1 = 0 ;
   15736           0 :   int res1 = 0 ;
   15737             :   bool result;
   15738           0 :   VALUE vresult = Qnil;
   15739             :   
   15740           0 :   if ((argc < 3) || (argc > 3)) {
   15741           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   15742             :   }
   15743           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15744           0 :   if (!SWIG_IsOK(res1)) {
   15745           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","findInfo", 1, self )); 
   15746             :   }
   15747           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15748             :   {
   15749           0 :     std::string *ptr = (std::string *)0;
   15750           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   15751           0 :     if (!SWIG_IsOK(res) || !ptr) {
   15752           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","findInfo", 2, argv[0] )); 
   15753             :     }
   15754           0 :     arg2 = *ptr;
   15755           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   15756             :   }
   15757             :   {
   15758           0 :     std::string *ptr = (std::string *)0;
   15759           0 :     int res = SWIG_AsPtr_std_string(argv[1], &ptr);
   15760           0 :     if (!SWIG_IsOK(res) || !ptr) {
   15761           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","findInfo", 3, argv[1] )); 
   15762             :     }
   15763           0 :     arg3 = *ptr;
   15764           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   15765             :   }
   15766             :   {
   15767           0 :     std::string *ptr = (std::string *)0;
   15768           0 :     int res = SWIG_AsPtr_std_string(argv[2], &ptr);
   15769           0 :     if (!SWIG_IsOK(res) || !ptr) {
   15770           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","findInfo", 4, argv[2] )); 
   15771             :     }
   15772           0 :     arg4 = *ptr;
   15773           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   15774             :   }
   15775           0 :   result = (bool)(arg1)->findInfo(arg2,arg3,arg4);
   15776           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   15777           0 :   return vresult;
   15778             : fail:
   15779             :   return Qnil;
   15780             : }
   15781             : 
   15782             : 
   15783             : SWIGINTERN VALUE
   15784           0 : _wrap_Plugin_find_info__SWIG_1(int argc, VALUE *argv, VALUE self) {
   15785           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15786           0 :   std::string arg2 ;
   15787           0 :   std::string arg3 ;
   15788           0 :   void *argp1 = 0 ;
   15789           0 :   int res1 = 0 ;
   15790             :   bool result;
   15791           0 :   VALUE vresult = Qnil;
   15792             :   
   15793           0 :   if ((argc < 2) || (argc > 2)) {
   15794           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   15795             :   }
   15796           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15797           0 :   if (!SWIG_IsOK(res1)) {
   15798           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","findInfo", 1, self )); 
   15799             :   }
   15800           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15801             :   {
   15802           0 :     std::string *ptr = (std::string *)0;
   15803           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   15804           0 :     if (!SWIG_IsOK(res) || !ptr) {
   15805           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","findInfo", 2, argv[0] )); 
   15806             :     }
   15807           0 :     arg2 = *ptr;
   15808           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   15809             :   }
   15810             :   {
   15811           0 :     std::string *ptr = (std::string *)0;
   15812           0 :     int res = SWIG_AsPtr_std_string(argv[1], &ptr);
   15813           0 :     if (!SWIG_IsOK(res) || !ptr) {
   15814           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","findInfo", 3, argv[1] )); 
   15815             :     }
   15816           0 :     arg3 = *ptr;
   15817           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   15818             :   }
   15819           0 :   result = (bool)(arg1)->findInfo(arg2,arg3);
   15820           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   15821           0 :   return vresult;
   15822             : fail:
   15823             :   return Qnil;
   15824             : }
   15825             : 
   15826             : 
   15827           0 : SWIGINTERN VALUE _wrap_Plugin_find_info(int nargs, VALUE *args, VALUE self) {
   15828             :   int argc;
   15829             :   VALUE argv[5];
   15830             :   int ii;
   15831             :   
   15832           0 :   argc = nargs + 1;
   15833             :   argv[0] = self;
   15834           0 :   if (argc > 5) SWIG_fail;
   15835             :   for (ii = 1; (ii < argc); ++ii) {
   15836             :     argv[ii] = args[ii-1];
   15837             :   }
   15838           0 :   if (argc == 3) {
   15839           0 :     return _wrap_Plugin_find_info__SWIG_1(nargs, args, self);
   15840             :   }
   15841           0 :   if (argc == 4) {
   15842           0 :     return _wrap_Plugin_find_info__SWIG_0(nargs, args, self);
   15843             :   }
   15844             :   
   15845             : fail:
   15846             :   Ruby_Format_OverloadedError( argc, 5, "Plugin.find_info", 
   15847             :     "    bool Plugin.find_info(std::string check, std::string item, std::string section)\n"
   15848           0 :     "    bool Plugin.find_info(std::string check, std::string item)\n");
   15849             :   
   15850             :   return Qnil;
   15851             : }
   15852             : 
   15853             : 
   15854             : 
   15855             : /*
   15856             :   Document-method: Kdbtools::Plugin.get_info
   15857             : 
   15858             :   call-seq:
   15859             :     get_info -> KeySet
   15860             : 
   15861             : An instance method.
   15862             : 
   15863             : */
   15864             : SWIGINTERN VALUE
   15865           0 : _wrap_Plugin_get_info(int argc, VALUE *argv, VALUE self) {
   15866           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15867           0 :   void *argp1 = 0 ;
   15868           0 :   int res1 = 0 ;
   15869           0 :   kdb::KeySet result;
   15870           0 :   VALUE vresult = Qnil;
   15871             :   
   15872           0 :   if ((argc < 0) || (argc > 0)) {
   15873           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   15874             :   }
   15875           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15876           0 :   if (!SWIG_IsOK(res1)) {
   15877           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","getInfo", 1, self )); 
   15878             :   }
   15879           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15880           0 :   result = (arg1)->getInfo();
   15881           0 :   vresult = SWIG_NewPointerObj((new kdb::KeySet(static_cast< const kdb::KeySet& >(result))), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_OWN |  0 );
   15882           0 :   return vresult;
   15883             : fail:
   15884             :   return Qnil;
   15885             : }
   15886             : 
   15887             : 
   15888             : 
   15889             : /*
   15890             :   Document-method: Kdbtools::Plugin.get_needed_config
   15891             : 
   15892             :   call-seq:
   15893             :     get_needed_config -> KeySet
   15894             : 
   15895             : An instance method.
   15896             : 
   15897             : */
   15898             : SWIGINTERN VALUE
   15899           0 : _wrap_Plugin_get_needed_config(int argc, VALUE *argv, VALUE self) {
   15900           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15901           0 :   void *argp1 = 0 ;
   15902           0 :   int res1 = 0 ;
   15903           0 :   kdb::KeySet result;
   15904           0 :   VALUE vresult = Qnil;
   15905             :   
   15906           0 :   if ((argc < 0) || (argc > 0)) {
   15907           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   15908             :   }
   15909           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15910           0 :   if (!SWIG_IsOK(res1)) {
   15911           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","getNeededConfig", 1, self )); 
   15912             :   }
   15913           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15914           0 :   result = (arg1)->getNeededConfig();
   15915           0 :   vresult = SWIG_NewPointerObj((new kdb::KeySet(static_cast< const kdb::KeySet& >(result))), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_OWN |  0 );
   15916           0 :   return vresult;
   15917             : fail:
   15918             :   return Qnil;
   15919             : }
   15920             : 
   15921             : 
   15922             : 
   15923             : /*
   15924             :   Document-method: Kdbtools::Plugin.get_config
   15925             : 
   15926             :   call-seq:
   15927             :     get_config -> KeySet
   15928             : 
   15929             : An instance method.
   15930             : 
   15931             : */
   15932             : SWIGINTERN VALUE
   15933           2 : _wrap_Plugin_get_config(int argc, VALUE *argv, VALUE self) {
   15934           2 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15935           2 :   void *argp1 = 0 ;
   15936           2 :   int res1 = 0 ;
   15937           4 :   kdb::KeySet result;
   15938           2 :   VALUE vresult = Qnil;
   15939             :   
   15940           2 :   if ((argc < 0) || (argc > 0)) {
   15941           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   15942             :   }
   15943           2 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15944           2 :   if (!SWIG_IsOK(res1)) {
   15945           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","getConfig", 1, self )); 
   15946             :   }
   15947           2 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15948           6 :   result = (arg1)->getConfig();
   15949           4 :   vresult = SWIG_NewPointerObj((new kdb::KeySet(static_cast< const kdb::KeySet& >(result))), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_OWN |  0 );
   15950           2 :   return vresult;
   15951             : fail:
   15952             :   return Qnil;
   15953             : }
   15954             : 
   15955             : 
   15956             : 
   15957             : /*
   15958             :   Document-method: Kdbtools::Plugin.open
   15959             : 
   15960             :   call-seq:
   15961             :     open(Key errorKey) -> int
   15962             : 
   15963             : An instance method.
   15964             : 
   15965             : */
   15966             : SWIGINTERN VALUE
   15967           0 : _wrap_Plugin_open(int argc, VALUE *argv, VALUE self) {
   15968           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   15969           0 :   kdb::Key *arg2 = 0 ;
   15970           0 :   void *argp1 = 0 ;
   15971           0 :   int res1 = 0 ;
   15972           0 :   void *argp2 = 0 ;
   15973           0 :   int res2 = 0 ;
   15974             :   int result;
   15975           0 :   VALUE vresult = Qnil;
   15976             :   
   15977           0 :   if ((argc < 1) || (argc > 1)) {
   15978           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   15979             :   }
   15980           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   15981           0 :   if (!SWIG_IsOK(res1)) {
   15982           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","open", 1, self )); 
   15983             :   }
   15984           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   15985           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   15986           0 :   if (!SWIG_IsOK(res2)) {
   15987           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::Key &","open", 2, argv[0] )); 
   15988             :   }
   15989           0 :   if (!argp2) {
   15990           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key &","open", 2, argv[0])); 
   15991             :   }
   15992           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
   15993             :   try {
   15994           0 :     result = (int)(arg1)->open(*arg2);
   15995             :   }
   15996           0 :   catch(kdb::tools::MissingSymbol &_e) {
   15997           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   15998             :   }
   15999           0 :   catch(kdb::tools::PluginCheckException &_e) {
   16000           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   16001             :   }
   16002           0 :   catch(kdb::tools::ToolException &_e) {
   16003           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   16004             :   }
   16005             :   
   16006           0 :   vresult = SWIG_From_int(static_cast< int >(result));
   16007             :   return vresult;
   16008             : fail:
   16009             :   return Qnil;
   16010             : }
   16011             : 
   16012             : 
   16013             : 
   16014             : /*
   16015             :   Document-method: Kdbtools::Plugin.close
   16016             : 
   16017             :   call-seq:
   16018             :     close(Key errorKey) -> int
   16019             : 
   16020             : An instance method.
   16021             : 
   16022             : */
   16023             : SWIGINTERN VALUE
   16024           0 : _wrap_Plugin_close(int argc, VALUE *argv, VALUE self) {
   16025           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   16026           0 :   kdb::Key *arg2 = 0 ;
   16027           0 :   void *argp1 = 0 ;
   16028           0 :   int res1 = 0 ;
   16029           0 :   void *argp2 = 0 ;
   16030           0 :   int res2 = 0 ;
   16031             :   int result;
   16032           0 :   VALUE vresult = Qnil;
   16033             :   
   16034           0 :   if ((argc < 1) || (argc > 1)) {
   16035           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   16036             :   }
   16037           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   16038           0 :   if (!SWIG_IsOK(res1)) {
   16039           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","close", 1, self )); 
   16040             :   }
   16041           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   16042           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   16043           0 :   if (!SWIG_IsOK(res2)) {
   16044           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::Key &","close", 2, argv[0] )); 
   16045             :   }
   16046           0 :   if (!argp2) {
   16047           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key &","close", 2, argv[0])); 
   16048             :   }
   16049           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
   16050             :   try {
   16051           0 :     result = (int)(arg1)->close(*arg2);
   16052             :   }
   16053           0 :   catch(kdb::tools::MissingSymbol &_e) {
   16054           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   16055             :   }
   16056           0 :   catch(kdb::tools::PluginCheckException &_e) {
   16057           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   16058             :   }
   16059           0 :   catch(kdb::tools::ToolException &_e) {
   16060           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   16061             :   }
   16062             :   
   16063           0 :   vresult = SWIG_From_int(static_cast< int >(result));
   16064             :   return vresult;
   16065             : fail:
   16066             :   return Qnil;
   16067             : }
   16068             : 
   16069             : 
   16070             : 
   16071             : /*
   16072             :   Document-method: Kdbtools::Plugin.get
   16073             : 
   16074             :   call-seq:
   16075             :     get(KeySet ks, Key parentKey) -> int
   16076             : 
   16077             : An instance method.
   16078             : 
   16079             : */
   16080             : SWIGINTERN VALUE
   16081           0 : _wrap_Plugin_get(int argc, VALUE *argv, VALUE self) {
   16082           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   16083           0 :   kdb::KeySet *arg2 = 0 ;
   16084           0 :   kdb::Key *arg3 = 0 ;
   16085           0 :   void *argp1 = 0 ;
   16086           0 :   int res1 = 0 ;
   16087           0 :   void *argp2 = 0 ;
   16088           0 :   int res2 = 0 ;
   16089           0 :   void *argp3 = 0 ;
   16090           0 :   int res3 = 0 ;
   16091             :   int result;
   16092           0 :   VALUE vresult = Qnil;
   16093             :   
   16094           0 :   if ((argc < 2) || (argc > 2)) {
   16095           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   16096             :   }
   16097           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   16098           0 :   if (!SWIG_IsOK(res1)) {
   16099           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","get", 1, self )); 
   16100             :   }
   16101           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   16102           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   16103           0 :   if (!SWIG_IsOK(res2)) {
   16104           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet &","get", 2, argv[0] )); 
   16105             :   }
   16106           0 :   if (!argp2) {
   16107           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","get", 2, argv[0])); 
   16108             :   }
   16109           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   16110           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__Key,  0 );
   16111           0 :   if (!SWIG_IsOK(res3)) {
   16112           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::Key &","get", 3, argv[1] )); 
   16113             :   }
   16114           0 :   if (!argp3) {
   16115           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key &","get", 3, argv[1])); 
   16116             :   }
   16117           0 :   arg3 = reinterpret_cast< kdb::Key * >(argp3);
   16118             :   try {
   16119           0 :     result = (int)(arg1)->get(*arg2,*arg3);
   16120             :   }
   16121           0 :   catch(kdb::tools::MissingSymbol &_e) {
   16122           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   16123             :   }
   16124           0 :   catch(kdb::tools::PluginCheckException &_e) {
   16125           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   16126             :   }
   16127           0 :   catch(kdb::tools::ToolException &_e) {
   16128           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   16129             :   }
   16130             :   
   16131           0 :   vresult = SWIG_From_int(static_cast< int >(result));
   16132             :   return vresult;
   16133             : fail:
   16134             :   return Qnil;
   16135             : }
   16136             : 
   16137             : 
   16138             : 
   16139             : /*
   16140             :   Document-method: Kdbtools::Plugin.set
   16141             : 
   16142             :   call-seq:
   16143             :     set(KeySet ks, Key parentKey) -> int
   16144             : 
   16145             : An instance method.
   16146             : 
   16147             : */
   16148             : SWIGINTERN VALUE
   16149           0 : _wrap_Plugin_set(int argc, VALUE *argv, VALUE self) {
   16150           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   16151           0 :   kdb::KeySet *arg2 = 0 ;
   16152           0 :   kdb::Key *arg3 = 0 ;
   16153           0 :   void *argp1 = 0 ;
   16154           0 :   int res1 = 0 ;
   16155           0 :   void *argp2 = 0 ;
   16156           0 :   int res2 = 0 ;
   16157           0 :   void *argp3 = 0 ;
   16158           0 :   int res3 = 0 ;
   16159             :   int result;
   16160           0 :   VALUE vresult = Qnil;
   16161             :   
   16162           0 :   if ((argc < 2) || (argc > 2)) {
   16163           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   16164             :   }
   16165           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   16166           0 :   if (!SWIG_IsOK(res1)) {
   16167           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","set", 1, self )); 
   16168             :   }
   16169           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   16170           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   16171           0 :   if (!SWIG_IsOK(res2)) {
   16172           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet &","set", 2, argv[0] )); 
   16173             :   }
   16174           0 :   if (!argp2) {
   16175           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","set", 2, argv[0])); 
   16176             :   }
   16177           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   16178           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__Key,  0 );
   16179           0 :   if (!SWIG_IsOK(res3)) {
   16180           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::Key &","set", 3, argv[1] )); 
   16181             :   }
   16182           0 :   if (!argp3) {
   16183           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key &","set", 3, argv[1])); 
   16184             :   }
   16185           0 :   arg3 = reinterpret_cast< kdb::Key * >(argp3);
   16186             :   try {
   16187           0 :     result = (int)(arg1)->set(*arg2,*arg3);
   16188             :   }
   16189           0 :   catch(kdb::tools::MissingSymbol &_e) {
   16190           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   16191             :   }
   16192           0 :   catch(kdb::tools::PluginCheckException &_e) {
   16193           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   16194             :   }
   16195           0 :   catch(kdb::tools::ToolException &_e) {
   16196           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   16197             :   }
   16198             :   
   16199           0 :   vresult = SWIG_From_int(static_cast< int >(result));
   16200             :   return vresult;
   16201             : fail:
   16202             :   return Qnil;
   16203             : }
   16204             : 
   16205             : 
   16206             : 
   16207             : /*
   16208             :   Document-method: Kdbtools::Plugin.commit
   16209             : 
   16210             :   call-seq:
   16211             :     commit(KeySet ks, Key parentKey) -> int
   16212             : 
   16213             : An instance method.
   16214             : 
   16215             : */
   16216             : SWIGINTERN VALUE
   16217           0 : _wrap_Plugin_commit(int argc, VALUE *argv, VALUE self) {
   16218           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   16219           0 :   kdb::KeySet *arg2 = 0 ;
   16220           0 :   kdb::Key *arg3 = 0 ;
   16221           0 :   void *argp1 = 0 ;
   16222           0 :   int res1 = 0 ;
   16223           0 :   void *argp2 = 0 ;
   16224           0 :   int res2 = 0 ;
   16225           0 :   void *argp3 = 0 ;
   16226           0 :   int res3 = 0 ;
   16227             :   int result;
   16228           0 :   VALUE vresult = Qnil;
   16229             :   
   16230           0 :   if ((argc < 2) || (argc > 2)) {
   16231           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   16232             :   }
   16233           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   16234           0 :   if (!SWIG_IsOK(res1)) {
   16235           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","commit", 1, self )); 
   16236             :   }
   16237           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   16238           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   16239           0 :   if (!SWIG_IsOK(res2)) {
   16240           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet &","commit", 2, argv[0] )); 
   16241             :   }
   16242           0 :   if (!argp2) {
   16243           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","commit", 2, argv[0])); 
   16244             :   }
   16245           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   16246           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__Key,  0 );
   16247           0 :   if (!SWIG_IsOK(res3)) {
   16248           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::Key &","commit", 3, argv[1] )); 
   16249             :   }
   16250           0 :   if (!argp3) {
   16251           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key &","commit", 3, argv[1])); 
   16252             :   }
   16253           0 :   arg3 = reinterpret_cast< kdb::Key * >(argp3);
   16254           0 :   result = (int)(arg1)->commit(*arg2,*arg3);
   16255           0 :   vresult = SWIG_From_int(static_cast< int >(result));
   16256             :   return vresult;
   16257             : fail:
   16258             :   return Qnil;
   16259             : }
   16260             : 
   16261             : 
   16262             : 
   16263             : /*
   16264             :   Document-method: Kdbtools::Plugin.error
   16265             : 
   16266             :   call-seq:
   16267             :     error(KeySet ks, Key parentKey) -> int
   16268             : 
   16269             : An instance method.
   16270             : 
   16271             : */
   16272             : SWIGINTERN VALUE
   16273           0 : _wrap_Plugin_error(int argc, VALUE *argv, VALUE self) {
   16274           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   16275           0 :   kdb::KeySet *arg2 = 0 ;
   16276           0 :   kdb::Key *arg3 = 0 ;
   16277           0 :   void *argp1 = 0 ;
   16278           0 :   int res1 = 0 ;
   16279           0 :   void *argp2 = 0 ;
   16280           0 :   int res2 = 0 ;
   16281           0 :   void *argp3 = 0 ;
   16282           0 :   int res3 = 0 ;
   16283             :   int result;
   16284           0 :   VALUE vresult = Qnil;
   16285             :   
   16286           0 :   if ((argc < 2) || (argc > 2)) {
   16287           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   16288             :   }
   16289           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   16290           0 :   if (!SWIG_IsOK(res1)) {
   16291           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","error", 1, self )); 
   16292             :   }
   16293           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   16294           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   16295           0 :   if (!SWIG_IsOK(res2)) {
   16296           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet &","error", 2, argv[0] )); 
   16297             :   }
   16298           0 :   if (!argp2) {
   16299           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","error", 2, argv[0])); 
   16300             :   }
   16301           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   16302           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__Key,  0 );
   16303           0 :   if (!SWIG_IsOK(res3)) {
   16304           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::Key &","error", 3, argv[1] )); 
   16305             :   }
   16306           0 :   if (!argp3) {
   16307           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key &","error", 3, argv[1])); 
   16308             :   }
   16309           0 :   arg3 = reinterpret_cast< kdb::Key * >(argp3);
   16310             :   try {
   16311           0 :     result = (int)(arg1)->error(*arg2,*arg3);
   16312             :   }
   16313           0 :   catch(kdb::tools::MissingSymbol &_e) {
   16314           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   16315             :   }
   16316           0 :   catch(kdb::tools::PluginCheckException &_e) {
   16317           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   16318             :   }
   16319           0 :   catch(kdb::tools::ToolException &_e) {
   16320           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   16321             :   }
   16322             :   
   16323           0 :   vresult = SWIG_From_int(static_cast< int >(result));
   16324             :   return vresult;
   16325             : fail:
   16326             :   return Qnil;
   16327             : }
   16328             : 
   16329             : 
   16330             : 
   16331             : /*
   16332             :   Document-method: Kdbtools::Plugin.name
   16333             : 
   16334             :   call-seq:
   16335             :     name -> std::string
   16336             : 
   16337             : An instance method.
   16338             : 
   16339             : */
   16340             : SWIGINTERN VALUE
   16341           3 : _wrap_Plugin_name(int argc, VALUE *argv, VALUE self) {
   16342           3 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   16343           3 :   void *argp1 = 0 ;
   16344           3 :   int res1 = 0 ;
   16345           6 :   std::string result;
   16346           3 :   VALUE vresult = Qnil;
   16347             :   
   16348           3 :   if ((argc < 0) || (argc > 0)) {
   16349           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   16350             :   }
   16351           3 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   16352           3 :   if (!SWIG_IsOK(res1)) {
   16353           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","name", 1, self )); 
   16354             :   }
   16355           3 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   16356           6 :   result = (arg1)->name();
   16357           9 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   16358           3 :   return vresult;
   16359             : fail:
   16360             :   return Qnil;
   16361             : }
   16362             : 
   16363             : 
   16364             : 
   16365             : /*
   16366             :   Document-method: Kdbtools::Plugin.get_full_name
   16367             : 
   16368             :   call-seq:
   16369             :     get_full_name -> std::string
   16370             : 
   16371             : An instance method.
   16372             : 
   16373             : */
   16374             : SWIGINTERN VALUE
   16375           0 : _wrap_Plugin_get_full_name(int argc, VALUE *argv, VALUE self) {
   16376           0 :   kdb::tools::Plugin *arg1 = (kdb::tools::Plugin *) 0 ;
   16377           0 :   void *argp1 = 0 ;
   16378           0 :   int res1 = 0 ;
   16379           0 :   std::string result;
   16380           0 :   VALUE vresult = Qnil;
   16381             :   
   16382           0 :   if ((argc < 0) || (argc > 0)) {
   16383           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   16384             :   }
   16385           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugin, 0 |  0 );
   16386           0 :   if (!SWIG_IsOK(res1)) {
   16387           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugin *","getFullName", 1, self )); 
   16388             :   }
   16389           0 :   arg1 = reinterpret_cast< kdb::tools::Plugin * >(argp1);
   16390           0 :   result = (arg1)->getFullName();
   16391           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   16392           0 :   return vresult;
   16393             : fail:
   16394             :   return Qnil;
   16395             : }
   16396             : 
   16397             : 
   16398             : 
   16399             : /*
   16400             :   Document-class: Kdbtools::Place
   16401             : 
   16402             :   Proxy of C++ Kdbtools::Place class
   16403             : 
   16404             : 
   16405             : */
   16406             : static swig_class SwigClassPlace;
   16407             : 
   16408             : 
   16409             : /*
   16410             :   Document-method: Kdbtools::Place.current
   16411             : 
   16412             :   call-seq:
   16413             :     current -> int
   16414             : 
   16415             : Get value of attribute.
   16416             : 
   16417             : */
   16418             : 
   16419             : /*
   16420             :   Document-method: Kdbtools::Place.current=
   16421             : 
   16422             :   call-seq:
   16423             :     current=(x) -> int
   16424             : 
   16425             : Set new value for attribute.
   16426             : 
   16427             : */
   16428             : SWIGINTERN VALUE
   16429           0 : _wrap_Place_current_set(int argc, VALUE *argv, VALUE self) {
   16430           0 :   kdb::tools::Place *arg1 = (kdb::tools::Place *) 0 ;
   16431             :   int arg2 ;
   16432           0 :   void *argp1 = 0 ;
   16433           0 :   int res1 = 0 ;
   16434             :   int val2 ;
   16435           0 :   int ecode2 = 0 ;
   16436             :   
   16437           0 :   if ((argc < 1) || (argc > 1)) {
   16438           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   16439             :   }
   16440           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Place, 0 |  0 );
   16441           0 :   if (!SWIG_IsOK(res1)) {
   16442           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Place *","current", 1, self )); 
   16443             :   }
   16444           0 :   arg1 = reinterpret_cast< kdb::tools::Place * >(argp1);
   16445           0 :   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   16446           0 :   if (!SWIG_IsOK(ecode2)) {
   16447           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","current", 2, argv[0] ));
   16448             :   } 
   16449           0 :   arg2 = static_cast< int >(val2);
   16450           0 :   if (arg1) (arg1)->current = arg2;
   16451             :   return Qnil;
   16452             : fail:
   16453             :   return Qnil;
   16454             : }
   16455             : 
   16456             : 
   16457             : SWIGINTERN VALUE
   16458           0 : _wrap_Place_current_get(int argc, VALUE *argv, VALUE self) {
   16459           0 :   kdb::tools::Place *arg1 = (kdb::tools::Place *) 0 ;
   16460           0 :   void *argp1 = 0 ;
   16461           0 :   int res1 = 0 ;
   16462             :   int result;
   16463           0 :   VALUE vresult = Qnil;
   16464             :   
   16465           0 :   if ((argc < 0) || (argc > 0)) {
   16466           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   16467             :   }
   16468           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Place, 0 |  0 );
   16469           0 :   if (!SWIG_IsOK(res1)) {
   16470           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Place *","current", 1, self )); 
   16471             :   }
   16472           0 :   arg1 = reinterpret_cast< kdb::tools::Place * >(argp1);
   16473           0 :   result = (int) ((arg1)->current);
   16474           0 :   vresult = SWIG_From_int(static_cast< int >(result));
   16475             :   return vresult;
   16476             : fail:
   16477             :   return Qnil;
   16478             : }
   16479             : 
   16480             : 
   16481             : 
   16482             : /*
   16483             :   Document-method: Kdbtools::Place.max
   16484             : 
   16485             :   call-seq:
   16486             :     max -> int
   16487             : 
   16488             : Get value of attribute.
   16489             : 
   16490             : */
   16491             : 
   16492             : /*
   16493             :   Document-method: Kdbtools::Place.max=
   16494             : 
   16495             :   call-seq:
   16496             :     max=(x) -> int
   16497             : 
   16498             : Set new value for attribute.
   16499             : 
   16500             : */
   16501             : SWIGINTERN VALUE
   16502           0 : _wrap_Place_max_set(int argc, VALUE *argv, VALUE self) {
   16503           0 :   kdb::tools::Place *arg1 = (kdb::tools::Place *) 0 ;
   16504             :   int arg2 ;
   16505           0 :   void *argp1 = 0 ;
   16506           0 :   int res1 = 0 ;
   16507             :   int val2 ;
   16508           0 :   int ecode2 = 0 ;
   16509             :   
   16510           0 :   if ((argc < 1) || (argc > 1)) {
   16511           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   16512             :   }
   16513           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Place, 0 |  0 );
   16514           0 :   if (!SWIG_IsOK(res1)) {
   16515           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Place *","max", 1, self )); 
   16516             :   }
   16517           0 :   arg1 = reinterpret_cast< kdb::tools::Place * >(argp1);
   16518           0 :   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   16519           0 :   if (!SWIG_IsOK(ecode2)) {
   16520           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","max", 2, argv[0] ));
   16521             :   } 
   16522           0 :   arg2 = static_cast< int >(val2);
   16523           0 :   if (arg1) (arg1)->max = arg2;
   16524             :   return Qnil;
   16525             : fail:
   16526             :   return Qnil;
   16527             : }
   16528             : 
   16529             : 
   16530             : SWIGINTERN VALUE
   16531           0 : _wrap_Place_max_get(int argc, VALUE *argv, VALUE self) {
   16532           0 :   kdb::tools::Place *arg1 = (kdb::tools::Place *) 0 ;
   16533           0 :   void *argp1 = 0 ;
   16534           0 :   int res1 = 0 ;
   16535             :   int result;
   16536           0 :   VALUE vresult = Qnil;
   16537             :   
   16538           0 :   if ((argc < 0) || (argc > 0)) {
   16539           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   16540             :   }
   16541           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Place, 0 |  0 );
   16542           0 :   if (!SWIG_IsOK(res1)) {
   16543           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Place *","max", 1, self )); 
   16544             :   }
   16545           0 :   arg1 = reinterpret_cast< kdb::tools::Place * >(argp1);
   16546           0 :   result = (int) ((arg1)->max);
   16547           0 :   vresult = SWIG_From_int(static_cast< int >(result));
   16548             :   return vresult;
   16549             : fail:
   16550             :   return Qnil;
   16551             : }
   16552             : 
   16553             : 
   16554             : 
   16555             : /*
   16556             :   Document-method: Kdbtools::Place.new
   16557             : 
   16558             :   call-seq:
   16559             :     Place.new
   16560             :     Place.new(int current_, int max_)
   16561             : 
   16562             : Class constructor.
   16563             : 
   16564             : */
   16565             : SWIGINTERN VALUE
   16566           0 : _wrap_new_Place__SWIG_0(int argc, VALUE *argv, VALUE self) {
   16567           0 :   kdb::tools::Place *result = 0 ;
   16568             :   
   16569           0 :   if ((argc < 0) || (argc > 0)) {
   16570           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   16571             :   }
   16572           0 :   result = (kdb::tools::Place *)new kdb::tools::Place();
   16573           0 :   DATA_PTR(self) = result;
   16574             :   return self;
   16575             : fail:
   16576             :   return Qnil;
   16577             : }
   16578             : 
   16579             : 
   16580             : SWIGINTERN VALUE
   16581             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   16582           0 : _wrap_Place_allocate(VALUE self)
   16583             : #else
   16584             : _wrap_Place_allocate(int argc, VALUE *argv, VALUE self)
   16585             : #endif
   16586             : {
   16587           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__Place);
   16588             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   16589             :   rb_obj_call_init(vresult, argc, argv);
   16590             : #endif
   16591           0 :   return vresult;
   16592             : }
   16593             : 
   16594             : 
   16595             : SWIGINTERN VALUE
   16596           0 : _wrap_new_Place__SWIG_1(int argc, VALUE *argv, VALUE self) {
   16597             :   int arg1 ;
   16598             :   int arg2 ;
   16599             :   int val1 ;
   16600           0 :   int ecode1 = 0 ;
   16601             :   int val2 ;
   16602           0 :   int ecode2 = 0 ;
   16603           0 :   kdb::tools::Place *result = 0 ;
   16604             :   
   16605           0 :   if ((argc < 2) || (argc > 2)) {
   16606           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   16607             :   }
   16608           0 :   ecode1 = SWIG_AsVal_int(argv[0], &val1);
   16609           0 :   if (!SWIG_IsOK(ecode1)) {
   16610           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Place", 1, argv[0] ));
   16611             :   } 
   16612           0 :   arg1 = static_cast< int >(val1);
   16613           0 :   ecode2 = SWIG_AsVal_int(argv[1], &val2);
   16614           0 :   if (!SWIG_IsOK(ecode2)) {
   16615           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Place", 2, argv[1] ));
   16616             :   } 
   16617           0 :   arg2 = static_cast< int >(val2);
   16618           0 :   result = (kdb::tools::Place *)new kdb::tools::Place(arg1,arg2);
   16619           0 :   DATA_PTR(self) = result;
   16620             :   return self;
   16621             : fail:
   16622             :   return Qnil;
   16623             : }
   16624             : 
   16625             : 
   16626           0 : SWIGINTERN VALUE _wrap_new_Place(int nargs, VALUE *args, VALUE self) {
   16627             :   int argc;
   16628             :   VALUE argv[2];
   16629             :   int ii;
   16630             :   
   16631           0 :   argc = nargs;
   16632           0 :   if (argc > 2) SWIG_fail;
   16633             :   for (ii = 0; (ii < argc); ++ii) {
   16634             :     argv[ii] = args[ii];
   16635             :   }
   16636           0 :   if (argc == 0) {
   16637           0 :     return _wrap_new_Place__SWIG_0(nargs, args, self);
   16638             :   }
   16639           0 :   if (argc == 2) {
   16640           0 :     return _wrap_new_Place__SWIG_1(nargs, args, self);
   16641             :   }
   16642             :   
   16643             : fail:
   16644             :   Ruby_Format_OverloadedError( argc, 2, "Place.new", 
   16645             :     "    Place.new()\n"
   16646           0 :     "    Place.new(int current_, int max_)\n");
   16647             :   
   16648             :   return Qnil;
   16649             : }
   16650             : 
   16651             : 
   16652             : SWIGINTERN void
   16653           0 : free_kdb_tools_Place(void *self) {
   16654           0 :     kdb::tools::Place *arg1 = (kdb::tools::Place *)self;
   16655           0 :     delete arg1;
   16656           0 : }
   16657             : 
   16658             : 
   16659             : /*
   16660             :   Document-class: Kdbtools::Plugins
   16661             : 
   16662             :   Proxy of C++ Kdbtools::Plugins class
   16663             : 
   16664             : 
   16665             : */
   16666             : static swig_class SwigClassPlugins;
   16667             : 
   16668             : SWIGINTERN VALUE
   16669             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   16670           0 : _wrap_Plugins_allocate(VALUE self)
   16671             : #else
   16672             : _wrap_Plugins_allocate(int argc, VALUE *argv, VALUE self)
   16673             : #endif
   16674             : {
   16675           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__Plugins);
   16676             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   16677             :   rb_obj_call_init(vresult, argc, argv);
   16678             : #endif
   16679           0 :   return vresult;
   16680             : }
   16681             : 
   16682             : 
   16683             : 
   16684             : /*
   16685             :   Document-method: Kdbtools::Plugins.new
   16686             : 
   16687             :   call-seq:
   16688             :     Plugins.new
   16689             : 
   16690             : Class constructor.
   16691             : 
   16692             : */
   16693             : SWIGINTERN VALUE
   16694           0 : _wrap_new_Plugins(int argc, VALUE *argv, VALUE self) {
   16695           0 :   kdb::tools::Plugins *result = 0 ;
   16696             :   
   16697           0 :   if ((argc < 0) || (argc > 0)) {
   16698           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   16699             :   }
   16700           0 :   result = (kdb::tools::Plugins *)new kdb::tools::Plugins();
   16701           0 :   DATA_PTR(self) = result;
   16702             :   return self;
   16703             : fail:
   16704             :   return Qnil;
   16705             : }
   16706             : 
   16707             : 
   16708             : 
   16709             : /*
   16710             :   Document-method: Kdbtools::Plugins.add_info
   16711             : 
   16712             :   call-seq:
   16713             :     add_info(Plugin plugin)
   16714             : 
   16715             : An instance method.
   16716             : 
   16717             : */
   16718             : SWIGINTERN VALUE
   16719           0 : _wrap_Plugins_add_info(int argc, VALUE *argv, VALUE self) {
   16720           0 :   kdb::tools::Plugins *arg1 = (kdb::tools::Plugins *) 0 ;
   16721           0 :   kdb::tools::Plugin *arg2 = 0 ;
   16722           0 :   void *argp1 = 0 ;
   16723           0 :   int res1 = 0 ;
   16724           0 :   void *argp2 = 0 ;
   16725           0 :   int res2 = 0 ;
   16726             :   
   16727           0 :   if ((argc < 1) || (argc > 1)) {
   16728           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   16729             :   }
   16730           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugins, 0 |  0 );
   16731           0 :   if (!SWIG_IsOK(res1)) {
   16732           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugins *","addInfo", 1, self )); 
   16733             :   }
   16734           0 :   arg1 = reinterpret_cast< kdb::tools::Plugins * >(argp1);
   16735           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   16736           0 :   if (!SWIG_IsOK(res2)) {
   16737           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","addInfo", 2, argv[0] )); 
   16738             :   }
   16739           0 :   if (!argp2) {
   16740           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","addInfo", 2, argv[0])); 
   16741             :   }
   16742           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   16743           0 :   (arg1)->addInfo(*arg2);
   16744             :   return Qnil;
   16745             : fail:
   16746             :   return Qnil;
   16747             : }
   16748             : 
   16749             : 
   16750             : 
   16751             : /*
   16752             :   Document-method: Kdbtools::Plugins.add_plugin
   16753             : 
   16754             :   call-seq:
   16755             :     add_plugin(Plugin plugin, std::string which)
   16756             : 
   16757             : An instance method.
   16758             : 
   16759             : */
   16760             : SWIGINTERN VALUE
   16761           0 : _wrap_Plugins_add_plugin(int argc, VALUE *argv, VALUE self) {
   16762           0 :   kdb::tools::Plugins *arg1 = (kdb::tools::Plugins *) 0 ;
   16763           0 :   kdb::tools::Plugin *arg2 = 0 ;
   16764           0 :   std::string arg3 ;
   16765           0 :   void *argp1 = 0 ;
   16766           0 :   int res1 = 0 ;
   16767           0 :   void *argp2 = 0 ;
   16768           0 :   int res2 = 0 ;
   16769             :   
   16770           0 :   if ((argc < 2) || (argc > 2)) {
   16771           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   16772             :   }
   16773           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugins, 0 |  0 );
   16774           0 :   if (!SWIG_IsOK(res1)) {
   16775           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugins *","addPlugin", 1, self )); 
   16776             :   }
   16777           0 :   arg1 = reinterpret_cast< kdb::tools::Plugins * >(argp1);
   16778           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   16779           0 :   if (!SWIG_IsOK(res2)) {
   16780           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","addPlugin", 2, argv[0] )); 
   16781             :   }
   16782           0 :   if (!argp2) {
   16783           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","addPlugin", 2, argv[0])); 
   16784             :   }
   16785           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   16786             :   {
   16787           0 :     std::string *ptr = (std::string *)0;
   16788           0 :     int res = SWIG_AsPtr_std_string(argv[1], &ptr);
   16789           0 :     if (!SWIG_IsOK(res) || !ptr) {
   16790           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","addPlugin", 3, argv[1] )); 
   16791             :     }
   16792           0 :     arg3 = *ptr;
   16793           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   16794             :   }
   16795           0 :   (arg1)->addPlugin(*arg2,arg3);
   16796           0 :   return Qnil;
   16797             : fail:
   16798             :   return Qnil;
   16799             : }
   16800             : 
   16801             : 
   16802             : 
   16803             : /*
   16804             :   Document-method: Kdbtools::Plugins.validate_provided
   16805             : 
   16806             :   call-seq:
   16807             :     validate_provided -> bool
   16808             : 
   16809             : An instance method.
   16810             : 
   16811             : */
   16812             : SWIGINTERN VALUE
   16813           0 : _wrap_Plugins_validate_provided(int argc, VALUE *argv, VALUE self) {
   16814           0 :   kdb::tools::Plugins *arg1 = (kdb::tools::Plugins *) 0 ;
   16815           0 :   void *argp1 = 0 ;
   16816           0 :   int res1 = 0 ;
   16817             :   bool result;
   16818           0 :   VALUE vresult = Qnil;
   16819             :   
   16820           0 :   if ((argc < 0) || (argc > 0)) {
   16821           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   16822             :   }
   16823           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugins, 0 |  0 );
   16824           0 :   if (!SWIG_IsOK(res1)) {
   16825           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugins const *","validateProvided", 1, self )); 
   16826             :   }
   16827           0 :   arg1 = reinterpret_cast< kdb::tools::Plugins * >(argp1);
   16828           0 :   result = (bool)((kdb::tools::Plugins const *)arg1)->validateProvided();
   16829           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   16830             :   return vresult;
   16831             : fail:
   16832             :   return Qnil;
   16833             : }
   16834             : 
   16835             : 
   16836             : 
   16837             : /*
   16838             :   Document-method: Kdbtools::Plugins.get_needed_missing
   16839             : 
   16840             :   call-seq:
   16841             :     get_needed_missing -> VectorStr
   16842             : 
   16843             : An instance method.
   16844             : 
   16845             : */
   16846             : SWIGINTERN VALUE
   16847           0 : _wrap_Plugins_get_needed_missing(int argc, VALUE *argv, VALUE self) {
   16848           0 :   kdb::tools::Plugins *arg1 = (kdb::tools::Plugins *) 0 ;
   16849           0 :   void *argp1 = 0 ;
   16850           0 :   int res1 = 0 ;
   16851           0 :   std::vector< std::string,std::allocator< std::string > > result;
   16852           0 :   VALUE vresult = Qnil;
   16853             :   
   16854           0 :   if ((argc < 0) || (argc > 0)) {
   16855           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   16856             :   }
   16857           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugins, 0 |  0 );
   16858           0 :   if (!SWIG_IsOK(res1)) {
   16859           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugins const *","getNeededMissing", 1, self )); 
   16860             :   }
   16861           0 :   arg1 = reinterpret_cast< kdb::tools::Plugins * >(argp1);
   16862           0 :   result = ((kdb::tools::Plugins const *)arg1)->getNeededMissing();
   16863           0 :   vresult = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
   16864             :   return vresult;
   16865             : fail:
   16866             :   return Qnil;
   16867             : }
   16868             : 
   16869             : 
   16870             : 
   16871             : /*
   16872             :   Document-method: Kdbtools::Plugins.get_recommended_missing
   16873             : 
   16874             :   call-seq:
   16875             :     get_recommended_missing -> VectorStr
   16876             : 
   16877             : An instance method.
   16878             : 
   16879             : */
   16880             : SWIGINTERN VALUE
   16881           0 : _wrap_Plugins_get_recommended_missing(int argc, VALUE *argv, VALUE self) {
   16882           0 :   kdb::tools::Plugins *arg1 = (kdb::tools::Plugins *) 0 ;
   16883           0 :   void *argp1 = 0 ;
   16884           0 :   int res1 = 0 ;
   16885           0 :   std::vector< std::string,std::allocator< std::string > > result;
   16886           0 :   VALUE vresult = Qnil;
   16887             :   
   16888           0 :   if ((argc < 0) || (argc > 0)) {
   16889           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   16890             :   }
   16891           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugins, 0 |  0 );
   16892           0 :   if (!SWIG_IsOK(res1)) {
   16893           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugins const *","getRecommendedMissing", 1, self )); 
   16894             :   }
   16895           0 :   arg1 = reinterpret_cast< kdb::tools::Plugins * >(argp1);
   16896           0 :   result = ((kdb::tools::Plugins const *)arg1)->getRecommendedMissing();
   16897           0 :   vresult = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
   16898             :   return vresult;
   16899             : fail:
   16900             :   return Qnil;
   16901             : }
   16902             : 
   16903             : 
   16904             : 
   16905             : /*
   16906             :   Document-method: Kdbtools::Plugins.check_placement
   16907             : 
   16908             :   call-seq:
   16909             :     check_placement(Plugin plugin, std::string which) -> bool
   16910             : 
   16911             : An instance method.
   16912             : 
   16913             : */
   16914             : SWIGINTERN VALUE
   16915           0 : _wrap_Plugins_check_placement(int argc, VALUE *argv, VALUE self) {
   16916           0 :   kdb::tools::Plugins *arg1 = (kdb::tools::Plugins *) 0 ;
   16917           0 :   kdb::tools::Plugin *arg2 = 0 ;
   16918           0 :   std::string arg3 ;
   16919           0 :   void *argp1 = 0 ;
   16920           0 :   int res1 = 0 ;
   16921           0 :   void *argp2 = 0 ;
   16922           0 :   int res2 = 0 ;
   16923             :   bool result;
   16924           0 :   VALUE vresult = Qnil;
   16925             :   
   16926           0 :   if ((argc < 2) || (argc > 2)) {
   16927           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   16928             :   }
   16929           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugins, 0 |  0 );
   16930           0 :   if (!SWIG_IsOK(res1)) {
   16931           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugins *","checkPlacement", 1, self )); 
   16932             :   }
   16933           0 :   arg1 = reinterpret_cast< kdb::tools::Plugins * >(argp1);
   16934           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   16935           0 :   if (!SWIG_IsOK(res2)) {
   16936           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","checkPlacement", 2, argv[0] )); 
   16937             :   }
   16938           0 :   if (!argp2) {
   16939           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","checkPlacement", 2, argv[0])); 
   16940             :   }
   16941           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   16942             :   {
   16943           0 :     std::string *ptr = (std::string *)0;
   16944           0 :     int res = SWIG_AsPtr_std_string(argv[1], &ptr);
   16945           0 :     if (!SWIG_IsOK(res) || !ptr) {
   16946           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","checkPlacement", 3, argv[1] )); 
   16947             :     }
   16948           0 :     arg3 = *ptr;
   16949           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   16950             :   }
   16951             :   try {
   16952           0 :     result = (bool)(arg1)->checkPlacement(*arg2,arg3);
   16953             :   }
   16954           0 :   catch(kdb::tools::TooManyPlugins &_e) {
   16955           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__TooManyPlugins, SWIG_NewPointerObj((new kdb::tools::TooManyPlugins(static_cast< const kdb::tools::TooManyPlugins& >(_e))),SWIGTYPE_p_kdb__tools__TooManyPlugins,SWIG_POINTER_OWN))); SWIG_fail;
   16956             :   }
   16957           0 :   catch(kdb::tools::PluginCheckException &_e) {
   16958           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   16959             :   }
   16960           0 :   catch(kdb::tools::ToolException &_e) {
   16961           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   16962             :   }
   16963             :   
   16964           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   16965           0 :   return vresult;
   16966             : fail:
   16967             :   return Qnil;
   16968             : }
   16969             : 
   16970             : 
   16971             : 
   16972             : /*
   16973             :   Document-method: Kdbtools::Plugins.check_storage
   16974             : 
   16975             :   call-seq:
   16976             :     check_storage(Plugin plugin)
   16977             : 
   16978             : An instance method.
   16979             : 
   16980             : */
   16981             : SWIGINTERN VALUE
   16982           0 : _wrap_Plugins_check_storage(int argc, VALUE *argv, VALUE self) {
   16983           0 :   kdb::tools::Plugins *arg1 = (kdb::tools::Plugins *) 0 ;
   16984           0 :   kdb::tools::Plugin *arg2 = 0 ;
   16985           0 :   void *argp1 = 0 ;
   16986           0 :   int res1 = 0 ;
   16987           0 :   void *argp2 = 0 ;
   16988           0 :   int res2 = 0 ;
   16989             :   
   16990           0 :   if ((argc < 1) || (argc > 1)) {
   16991           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   16992             :   }
   16993           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugins, 0 |  0 );
   16994           0 :   if (!SWIG_IsOK(res1)) {
   16995           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugins *","checkStorage", 1, self )); 
   16996             :   }
   16997           0 :   arg1 = reinterpret_cast< kdb::tools::Plugins * >(argp1);
   16998           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   16999           0 :   if (!SWIG_IsOK(res2)) {
   17000           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","checkStorage", 2, argv[0] )); 
   17001             :   }
   17002           0 :   if (!argp2) {
   17003           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","checkStorage", 2, argv[0])); 
   17004             :   }
   17005           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   17006             :   try {
   17007           0 :     (arg1)->checkStorage(*arg2);
   17008             :   }
   17009           0 :   catch(kdb::tools::StoragePlugin &_e) {
   17010           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__StoragePlugin, SWIG_NewPointerObj((new kdb::tools::StoragePlugin(static_cast< const kdb::tools::StoragePlugin& >(_e))),SWIGTYPE_p_kdb__tools__StoragePlugin,SWIG_POINTER_OWN))); SWIG_fail;
   17011             :   }
   17012           0 :   catch(kdb::tools::PluginCheckException &_e) {
   17013           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   17014             :   }
   17015           0 :   catch(kdb::tools::ToolException &_e) {
   17016           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   17017             :   }
   17018             :   
   17019             :   return Qnil;
   17020             : fail:
   17021             :   return Qnil;
   17022             : }
   17023             : 
   17024             : 
   17025             : 
   17026             : /*
   17027             :   Document-method: Kdbtools::Plugins.check_resolver
   17028             : 
   17029             :   call-seq:
   17030             :     check_resolver(Plugin plugin)
   17031             : 
   17032             : An instance method.
   17033             : 
   17034             : */
   17035             : SWIGINTERN VALUE
   17036           0 : _wrap_Plugins_check_resolver(int argc, VALUE *argv, VALUE self) {
   17037           0 :   kdb::tools::Plugins *arg1 = (kdb::tools::Plugins *) 0 ;
   17038           0 :   kdb::tools::Plugin *arg2 = 0 ;
   17039           0 :   void *argp1 = 0 ;
   17040           0 :   int res1 = 0 ;
   17041           0 :   void *argp2 = 0 ;
   17042           0 :   int res2 = 0 ;
   17043             :   
   17044           0 :   if ((argc < 1) || (argc > 1)) {
   17045           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   17046             :   }
   17047           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugins, 0 |  0 );
   17048           0 :   if (!SWIG_IsOK(res1)) {
   17049           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugins *","checkResolver", 1, self )); 
   17050             :   }
   17051           0 :   arg1 = reinterpret_cast< kdb::tools::Plugins * >(argp1);
   17052           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   17053           0 :   if (!SWIG_IsOK(res2)) {
   17054           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","checkResolver", 2, argv[0] )); 
   17055             :   }
   17056           0 :   if (!argp2) {
   17057           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","checkResolver", 2, argv[0])); 
   17058             :   }
   17059           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   17060             :   try {
   17061           0 :     (arg1)->checkResolver(*arg2);
   17062             :   }
   17063           0 :   catch(kdb::tools::ResolverPlugin &_e) {
   17064           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ResolverPlugin, SWIG_NewPointerObj((new kdb::tools::ResolverPlugin(static_cast< const kdb::tools::ResolverPlugin& >(_e))),SWIGTYPE_p_kdb__tools__ResolverPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   17065             :   }
   17066           0 :   catch(kdb::tools::PluginCheckException &_e) {
   17067           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   17068             :   }
   17069           0 :   catch(kdb::tools::ToolException &_e) {
   17070           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   17071             :   }
   17072             :   
   17073             :   return Qnil;
   17074             : fail:
   17075             :   return Qnil;
   17076             : }
   17077             : 
   17078             : 
   17079             : 
   17080             : /*
   17081             :   Document-method: Kdbtools::Plugins.check_ordering
   17082             : 
   17083             :   call-seq:
   17084             :     check_ordering(Plugin plugin)
   17085             : 
   17086             : An instance method.
   17087             : 
   17088             : */
   17089             : SWIGINTERN VALUE
   17090           0 : _wrap_Plugins_check_ordering(int argc, VALUE *argv, VALUE self) {
   17091           0 :   kdb::tools::Plugins *arg1 = (kdb::tools::Plugins *) 0 ;
   17092           0 :   kdb::tools::Plugin *arg2 = 0 ;
   17093           0 :   void *argp1 = 0 ;
   17094           0 :   int res1 = 0 ;
   17095           0 :   void *argp2 = 0 ;
   17096           0 :   int res2 = 0 ;
   17097             :   
   17098           0 :   if ((argc < 1) || (argc > 1)) {
   17099           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   17100             :   }
   17101           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugins, 0 |  0 );
   17102           0 :   if (!SWIG_IsOK(res1)) {
   17103           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugins *","checkOrdering", 1, self )); 
   17104             :   }
   17105           0 :   arg1 = reinterpret_cast< kdb::tools::Plugins * >(argp1);
   17106           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   17107           0 :   if (!SWIG_IsOK(res2)) {
   17108           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","checkOrdering", 2, argv[0] )); 
   17109             :   }
   17110           0 :   if (!argp2) {
   17111           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","checkOrdering", 2, argv[0])); 
   17112             :   }
   17113           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   17114             :   try {
   17115           0 :     (arg1)->checkOrdering(*arg2);
   17116             :   }
   17117           0 :   catch(kdb::tools::OrderingViolation &_e) {
   17118           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__OrderingViolation, SWIG_NewPointerObj((new kdb::tools::OrderingViolation(static_cast< const kdb::tools::OrderingViolation& >(_e))),SWIGTYPE_p_kdb__tools__OrderingViolation,SWIG_POINTER_OWN))); SWIG_fail;
   17119             :   }
   17120           0 :   catch(kdb::tools::PluginCheckException &_e) {
   17121           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   17122             :   }
   17123           0 :   catch(kdb::tools::ToolException &_e) {
   17124           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   17125             :   }
   17126             :   
   17127             :   return Qnil;
   17128             : fail:
   17129             :   return Qnil;
   17130             : }
   17131             : 
   17132             : 
   17133             : 
   17134             : /*
   17135             :   Document-method: Kdbtools::Plugins.check_conflicts
   17136             : 
   17137             :   call-seq:
   17138             :     check_conflicts(Plugin plugin)
   17139             : 
   17140             : An instance method.
   17141             : 
   17142             : */
   17143             : SWIGINTERN VALUE
   17144           0 : _wrap_Plugins_check_conflicts(int argc, VALUE *argv, VALUE self) {
   17145           0 :   kdb::tools::Plugins *arg1 = (kdb::tools::Plugins *) 0 ;
   17146           0 :   kdb::tools::Plugin *arg2 = 0 ;
   17147           0 :   void *argp1 = 0 ;
   17148           0 :   int res1 = 0 ;
   17149           0 :   void *argp2 = 0 ;
   17150           0 :   int res2 = 0 ;
   17151             :   
   17152           0 :   if ((argc < 1) || (argc > 1)) {
   17153           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   17154             :   }
   17155           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Plugins, 0 |  0 );
   17156           0 :   if (!SWIG_IsOK(res1)) {
   17157           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Plugins *","checkConflicts", 1, self )); 
   17158             :   }
   17159           0 :   arg1 = reinterpret_cast< kdb::tools::Plugins * >(argp1);
   17160           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   17161           0 :   if (!SWIG_IsOK(res2)) {
   17162           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","checkConflicts", 2, argv[0] )); 
   17163             :   }
   17164           0 :   if (!argp2) {
   17165           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","checkConflicts", 2, argv[0])); 
   17166             :   }
   17167           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   17168             :   try {
   17169           0 :     (arg1)->checkConflicts(*arg2);
   17170             :   }
   17171           0 :   catch(kdb::tools::ConflictViolation &_e) {
   17172           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ConflictViolation, SWIG_NewPointerObj((new kdb::tools::ConflictViolation(static_cast< const kdb::tools::ConflictViolation& >(_e))),SWIGTYPE_p_kdb__tools__ConflictViolation,SWIG_POINTER_OWN))); SWIG_fail;
   17173             :   }
   17174           0 :   catch(kdb::tools::PluginCheckException &_e) {
   17175           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   17176             :   }
   17177           0 :   catch(kdb::tools::ToolException &_e) {
   17178           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   17179             :   }
   17180             :   
   17181             :   return Qnil;
   17182             : fail:
   17183             :   return Qnil;
   17184             : }
   17185             : 
   17186             : 
   17187             : SWIGINTERN void
   17188           0 : free_kdb_tools_Plugins(void *self) {
   17189           0 :     kdb::tools::Plugins *arg1 = (kdb::tools::Plugins *)self;
   17190           0 :     delete arg1;
   17191           0 : }
   17192             : 
   17193             : 
   17194             : /*
   17195             :   Document-class: Kdbtools::GetPlugins
   17196             : 
   17197             :   Proxy of C++ Kdbtools::GetPlugins class
   17198             : 
   17199             : 
   17200             : */
   17201             : static swig_class SwigClassGetPlugins;
   17202             : 
   17203             : 
   17204             : /*
   17205             :   Document-method: Kdbtools::GetPlugins.try_plugin
   17206             : 
   17207             :   call-seq:
   17208             :     try_plugin(Plugin plugin)
   17209             : 
   17210             : An instance method.
   17211             : 
   17212             : */
   17213             : SWIGINTERN VALUE
   17214           0 : _wrap_GetPlugins_try_plugin(int argc, VALUE *argv, VALUE self) {
   17215           0 :   kdb::tools::GetPlugins *arg1 = (kdb::tools::GetPlugins *) 0 ;
   17216           0 :   kdb::tools::Plugin *arg2 = 0 ;
   17217           0 :   void *argp1 = 0 ;
   17218           0 :   int res1 = 0 ;
   17219           0 :   void *argp2 = 0 ;
   17220           0 :   int res2 = 0 ;
   17221             :   
   17222           0 :   if ((argc < 1) || (argc > 1)) {
   17223           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   17224             :   }
   17225           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__GetPlugins, 0 |  0 );
   17226           0 :   if (!SWIG_IsOK(res1)) {
   17227           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::GetPlugins *","tryPlugin", 1, self )); 
   17228             :   }
   17229           0 :   arg1 = reinterpret_cast< kdb::tools::GetPlugins * >(argp1);
   17230           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   17231           0 :   if (!SWIG_IsOK(res2)) {
   17232           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","tryPlugin", 2, argv[0] )); 
   17233             :   }
   17234           0 :   if (!argp2) {
   17235           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","tryPlugin", 2, argv[0])); 
   17236             :   }
   17237           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   17238             :   try {
   17239           0 :     (arg1)->tryPlugin(*arg2);
   17240             :   }
   17241           0 :   catch(kdb::tools::MissingSymbol &_e) {
   17242           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   17243             :   }
   17244           0 :   catch(kdb::tools::TooManyPlugins &_e) {
   17245           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__TooManyPlugins, SWIG_NewPointerObj((new kdb::tools::TooManyPlugins(static_cast< const kdb::tools::TooManyPlugins& >(_e))),SWIGTYPE_p_kdb__tools__TooManyPlugins,SWIG_POINTER_OWN))); SWIG_fail;
   17246             :   }
   17247           0 :   catch(kdb::tools::StoragePlugin &_e) {
   17248           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__StoragePlugin, SWIG_NewPointerObj((new kdb::tools::StoragePlugin(static_cast< const kdb::tools::StoragePlugin& >(_e))),SWIGTYPE_p_kdb__tools__StoragePlugin,SWIG_POINTER_OWN))); SWIG_fail;
   17249             :   }
   17250           0 :   catch(kdb::tools::ResolverPlugin &_e) {
   17251           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ResolverPlugin, SWIG_NewPointerObj((new kdb::tools::ResolverPlugin(static_cast< const kdb::tools::ResolverPlugin& >(_e))),SWIGTYPE_p_kdb__tools__ResolverPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   17252             :   }
   17253           0 :   catch(kdb::tools::OrderingViolation &_e) {
   17254           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__OrderingViolation, SWIG_NewPointerObj((new kdb::tools::OrderingViolation(static_cast< const kdb::tools::OrderingViolation& >(_e))),SWIGTYPE_p_kdb__tools__OrderingViolation,SWIG_POINTER_OWN))); SWIG_fail;
   17255             :   }
   17256           0 :   catch(kdb::tools::ConflictViolation &_e) {
   17257           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ConflictViolation, SWIG_NewPointerObj((new kdb::tools::ConflictViolation(static_cast< const kdb::tools::ConflictViolation& >(_e))),SWIGTYPE_p_kdb__tools__ConflictViolation,SWIG_POINTER_OWN))); SWIG_fail;
   17258             :   }
   17259           0 :   catch(kdb::tools::PluginCheckException &_e) {
   17260           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   17261             :   }
   17262           0 :   catch(kdb::tools::ToolException &_e) {
   17263           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   17264             :   }
   17265             :   
   17266             :   return Qnil;
   17267             : fail:
   17268             :   return Qnil;
   17269             : }
   17270             : 
   17271             : 
   17272             : 
   17273             : /*
   17274             :   Document-method: Kdbtools::GetPlugins.add_plugin
   17275             : 
   17276             :   call-seq:
   17277             :     add_plugin(Plugin plugin)
   17278             : 
   17279             : An instance method.
   17280             : 
   17281             : */
   17282             : SWIGINTERN VALUE
   17283           0 : _wrap_GetPlugins_add_plugin(int argc, VALUE *argv, VALUE self) {
   17284           0 :   kdb::tools::GetPlugins *arg1 = (kdb::tools::GetPlugins *) 0 ;
   17285           0 :   kdb::tools::Plugin *arg2 = 0 ;
   17286           0 :   void *argp1 = 0 ;
   17287           0 :   int res1 = 0 ;
   17288           0 :   void *argp2 = 0 ;
   17289           0 :   int res2 = 0 ;
   17290             :   
   17291           0 :   if ((argc < 1) || (argc > 1)) {
   17292           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   17293             :   }
   17294           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__GetPlugins, 0 |  0 );
   17295           0 :   if (!SWIG_IsOK(res1)) {
   17296           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::GetPlugins *","addPlugin", 1, self )); 
   17297             :   }
   17298           0 :   arg1 = reinterpret_cast< kdb::tools::GetPlugins * >(argp1);
   17299           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   17300           0 :   if (!SWIG_IsOK(res2)) {
   17301           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","addPlugin", 2, argv[0] )); 
   17302             :   }
   17303           0 :   if (!argp2) {
   17304           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","addPlugin", 2, argv[0])); 
   17305             :   }
   17306           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   17307           0 :   (arg1)->addPlugin(*arg2);
   17308             :   return Qnil;
   17309             : fail:
   17310             :   return Qnil;
   17311             : }
   17312             : 
   17313             : 
   17314             : 
   17315             : /*
   17316             :   Document-method: Kdbtools::GetPlugins.validated
   17317             : 
   17318             :   call-seq:
   17319             :     validated -> bool
   17320             : 
   17321             : An instance method.
   17322             : 
   17323             : */
   17324             : SWIGINTERN VALUE
   17325           0 : _wrap_GetPlugins_validated(int argc, VALUE *argv, VALUE self) {
   17326           0 :   kdb::tools::GetPlugins *arg1 = (kdb::tools::GetPlugins *) 0 ;
   17327           0 :   void *argp1 = 0 ;
   17328           0 :   int res1 = 0 ;
   17329             :   bool result;
   17330           0 :   VALUE vresult = Qnil;
   17331             :   
   17332           0 :   if ((argc < 0) || (argc > 0)) {
   17333           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   17334             :   }
   17335           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__GetPlugins, 0 |  0 );
   17336           0 :   if (!SWIG_IsOK(res1)) {
   17337           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::GetPlugins const *","validated", 1, self )); 
   17338             :   }
   17339           0 :   arg1 = reinterpret_cast< kdb::tools::GetPlugins * >(argp1);
   17340           0 :   result = (bool)((kdb::tools::GetPlugins const *)arg1)->validated();
   17341           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   17342             :   return vresult;
   17343             : fail:
   17344             :   return Qnil;
   17345             : }
   17346             : 
   17347             : 
   17348             : 
   17349             : /*
   17350             :   Document-method: Kdbtools::GetPlugins.serialise
   17351             : 
   17352             :   call-seq:
   17353             :     serialise(Key baseKey, KeySet ret)
   17354             : 
   17355             : An instance method.
   17356             : 
   17357             : */
   17358             : SWIGINTERN VALUE
   17359           0 : _wrap_GetPlugins_serialise(int argc, VALUE *argv, VALUE self) {
   17360           0 :   kdb::tools::GetPlugins *arg1 = (kdb::tools::GetPlugins *) 0 ;
   17361           0 :   kdb::Key *arg2 = 0 ;
   17362           0 :   kdb::KeySet *arg3 = 0 ;
   17363           0 :   void *argp1 = 0 ;
   17364           0 :   int res1 = 0 ;
   17365           0 :   void *argp2 = 0 ;
   17366           0 :   int res2 = 0 ;
   17367           0 :   void *argp3 = 0 ;
   17368           0 :   int res3 = 0 ;
   17369             :   
   17370           0 :   if ((argc < 2) || (argc > 2)) {
   17371           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   17372             :   }
   17373           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__GetPlugins, 0 |  0 );
   17374           0 :   if (!SWIG_IsOK(res1)) {
   17375           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::GetPlugins *","serialise", 1, self )); 
   17376             :   }
   17377           0 :   arg1 = reinterpret_cast< kdb::tools::GetPlugins * >(argp1);
   17378           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   17379           0 :   if (!SWIG_IsOK(res2)) {
   17380           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::Key &","serialise", 2, argv[0] )); 
   17381             :   }
   17382           0 :   if (!argp2) {
   17383           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key &","serialise", 2, argv[0])); 
   17384             :   }
   17385           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
   17386           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__KeySet,  0 );
   17387           0 :   if (!SWIG_IsOK(res3)) {
   17388           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::KeySet &","serialise", 3, argv[1] )); 
   17389             :   }
   17390           0 :   if (!argp3) {
   17391           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","serialise", 3, argv[1])); 
   17392             :   }
   17393           0 :   arg3 = reinterpret_cast< kdb::KeySet * >(argp3);
   17394           0 :   (arg1)->serialise(*arg2,*arg3);
   17395             :   return Qnil;
   17396             : fail:
   17397             :   return Qnil;
   17398             : }
   17399             : 
   17400             : 
   17401             : SWIGINTERN VALUE
   17402             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   17403           0 : _wrap_GetPlugins_allocate(VALUE self)
   17404             : #else
   17405             : _wrap_GetPlugins_allocate(int argc, VALUE *argv, VALUE self)
   17406             : #endif
   17407             : {
   17408           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__GetPlugins);
   17409             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   17410             :   rb_obj_call_init(vresult, argc, argv);
   17411             : #endif
   17412           0 :   return vresult;
   17413             : }
   17414             : 
   17415             : 
   17416             : 
   17417             : /*
   17418             :   Document-method: Kdbtools::GetPlugins.new
   17419             : 
   17420             :   call-seq:
   17421             :     GetPlugins.new
   17422             : 
   17423             : Class constructor.
   17424             : 
   17425             : */
   17426             : SWIGINTERN VALUE
   17427           0 : _wrap_new_GetPlugins(int argc, VALUE *argv, VALUE self) {
   17428           0 :   kdb::tools::GetPlugins *result = 0 ;
   17429             :   
   17430           0 :   if ((argc < 0) || (argc > 0)) {
   17431           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   17432             :   }
   17433           0 :   result = (kdb::tools::GetPlugins *)new kdb::tools::GetPlugins();
   17434           0 :   DATA_PTR(self) = result;
   17435             :   return self;
   17436             : fail:
   17437             :   return Qnil;
   17438             : }
   17439             : 
   17440             : 
   17441             : SWIGINTERN void
   17442           0 : free_kdb_tools_GetPlugins(void *self) {
   17443           0 :     kdb::tools::GetPlugins *arg1 = (kdb::tools::GetPlugins *)self;
   17444           0 :     delete arg1;
   17445           0 : }
   17446             : 
   17447             : 
   17448             : /*
   17449             :   Document-class: Kdbtools::SetPlugins
   17450             : 
   17451             :   Proxy of C++ Kdbtools::SetPlugins class
   17452             : 
   17453             : 
   17454             : */
   17455             : static swig_class SwigClassSetPlugins;
   17456             : 
   17457             : 
   17458             : /*
   17459             :   Document-method: Kdbtools::SetPlugins.try_plugin
   17460             : 
   17461             :   call-seq:
   17462             :     try_plugin(Plugin plugin)
   17463             : 
   17464             : An instance method.
   17465             : 
   17466             : */
   17467             : SWIGINTERN VALUE
   17468           0 : _wrap_SetPlugins_try_plugin(int argc, VALUE *argv, VALUE self) {
   17469           0 :   kdb::tools::SetPlugins *arg1 = (kdb::tools::SetPlugins *) 0 ;
   17470           0 :   kdb::tools::Plugin *arg2 = 0 ;
   17471           0 :   void *argp1 = 0 ;
   17472           0 :   int res1 = 0 ;
   17473           0 :   void *argp2 = 0 ;
   17474           0 :   int res2 = 0 ;
   17475             :   
   17476           0 :   if ((argc < 1) || (argc > 1)) {
   17477           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   17478             :   }
   17479           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SetPlugins, 0 |  0 );
   17480           0 :   if (!SWIG_IsOK(res1)) {
   17481           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SetPlugins *","tryPlugin", 1, self )); 
   17482             :   }
   17483           0 :   arg1 = reinterpret_cast< kdb::tools::SetPlugins * >(argp1);
   17484           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   17485           0 :   if (!SWIG_IsOK(res2)) {
   17486           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","tryPlugin", 2, argv[0] )); 
   17487             :   }
   17488           0 :   if (!argp2) {
   17489           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","tryPlugin", 2, argv[0])); 
   17490             :   }
   17491           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   17492             :   try {
   17493           0 :     (arg1)->tryPlugin(*arg2);
   17494             :   }
   17495           0 :   catch(kdb::tools::MissingSymbol &_e) {
   17496           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   17497             :   }
   17498           0 :   catch(kdb::tools::TooManyPlugins &_e) {
   17499           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__TooManyPlugins, SWIG_NewPointerObj((new kdb::tools::TooManyPlugins(static_cast< const kdb::tools::TooManyPlugins& >(_e))),SWIGTYPE_p_kdb__tools__TooManyPlugins,SWIG_POINTER_OWN))); SWIG_fail;
   17500             :   }
   17501           0 :   catch(kdb::tools::StoragePlugin &_e) {
   17502           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__StoragePlugin, SWIG_NewPointerObj((new kdb::tools::StoragePlugin(static_cast< const kdb::tools::StoragePlugin& >(_e))),SWIGTYPE_p_kdb__tools__StoragePlugin,SWIG_POINTER_OWN))); SWIG_fail;
   17503             :   }
   17504           0 :   catch(kdb::tools::ResolverPlugin &_e) {
   17505           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ResolverPlugin, SWIG_NewPointerObj((new kdb::tools::ResolverPlugin(static_cast< const kdb::tools::ResolverPlugin& >(_e))),SWIGTYPE_p_kdb__tools__ResolverPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   17506             :   }
   17507           0 :   catch(kdb::tools::OrderingViolation &_e) {
   17508           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__OrderingViolation, SWIG_NewPointerObj((new kdb::tools::OrderingViolation(static_cast< const kdb::tools::OrderingViolation& >(_e))),SWIGTYPE_p_kdb__tools__OrderingViolation,SWIG_POINTER_OWN))); SWIG_fail;
   17509             :   }
   17510           0 :   catch(kdb::tools::ConflictViolation &_e) {
   17511           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ConflictViolation, SWIG_NewPointerObj((new kdb::tools::ConflictViolation(static_cast< const kdb::tools::ConflictViolation& >(_e))),SWIGTYPE_p_kdb__tools__ConflictViolation,SWIG_POINTER_OWN))); SWIG_fail;
   17512             :   }
   17513           0 :   catch(kdb::tools::PluginCheckException &_e) {
   17514           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   17515             :   }
   17516           0 :   catch(kdb::tools::ToolException &_e) {
   17517           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   17518             :   }
   17519             :   
   17520             :   return Qnil;
   17521             : fail:
   17522             :   return Qnil;
   17523             : }
   17524             : 
   17525             : 
   17526             : 
   17527             : /*
   17528             :   Document-method: Kdbtools::SetPlugins.add_plugin
   17529             : 
   17530             :   call-seq:
   17531             :     add_plugin(Plugin plugin)
   17532             : 
   17533             : An instance method.
   17534             : 
   17535             : */
   17536             : SWIGINTERN VALUE
   17537           0 : _wrap_SetPlugins_add_plugin(int argc, VALUE *argv, VALUE self) {
   17538           0 :   kdb::tools::SetPlugins *arg1 = (kdb::tools::SetPlugins *) 0 ;
   17539           0 :   kdb::tools::Plugin *arg2 = 0 ;
   17540           0 :   void *argp1 = 0 ;
   17541           0 :   int res1 = 0 ;
   17542           0 :   void *argp2 = 0 ;
   17543           0 :   int res2 = 0 ;
   17544             :   
   17545           0 :   if ((argc < 1) || (argc > 1)) {
   17546           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   17547             :   }
   17548           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SetPlugins, 0 |  0 );
   17549           0 :   if (!SWIG_IsOK(res1)) {
   17550           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SetPlugins *","addPlugin", 1, self )); 
   17551             :   }
   17552           0 :   arg1 = reinterpret_cast< kdb::tools::SetPlugins * >(argp1);
   17553           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   17554           0 :   if (!SWIG_IsOK(res2)) {
   17555           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","addPlugin", 2, argv[0] )); 
   17556             :   }
   17557           0 :   if (!argp2) {
   17558           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","addPlugin", 2, argv[0])); 
   17559             :   }
   17560           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   17561           0 :   (arg1)->addPlugin(*arg2);
   17562             :   return Qnil;
   17563             : fail:
   17564             :   return Qnil;
   17565             : }
   17566             : 
   17567             : 
   17568             : 
   17569             : /*
   17570             :   Document-method: Kdbtools::SetPlugins.validated
   17571             : 
   17572             :   call-seq:
   17573             :     validated -> bool
   17574             : 
   17575             : An instance method.
   17576             : 
   17577             : */
   17578             : SWIGINTERN VALUE
   17579           0 : _wrap_SetPlugins_validated(int argc, VALUE *argv, VALUE self) {
   17580           0 :   kdb::tools::SetPlugins *arg1 = (kdb::tools::SetPlugins *) 0 ;
   17581           0 :   void *argp1 = 0 ;
   17582           0 :   int res1 = 0 ;
   17583             :   bool result;
   17584           0 :   VALUE vresult = Qnil;
   17585             :   
   17586           0 :   if ((argc < 0) || (argc > 0)) {
   17587           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   17588             :   }
   17589           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SetPlugins, 0 |  0 );
   17590           0 :   if (!SWIG_IsOK(res1)) {
   17591           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SetPlugins const *","validated", 1, self )); 
   17592             :   }
   17593           0 :   arg1 = reinterpret_cast< kdb::tools::SetPlugins * >(argp1);
   17594           0 :   result = (bool)((kdb::tools::SetPlugins const *)arg1)->validated();
   17595           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   17596             :   return vresult;
   17597             : fail:
   17598             :   return Qnil;
   17599             : }
   17600             : 
   17601             : 
   17602             : 
   17603             : /*
   17604             :   Document-method: Kdbtools::SetPlugins.serialise
   17605             : 
   17606             :   call-seq:
   17607             :     serialise(Key baseKey, KeySet ret)
   17608             : 
   17609             : An instance method.
   17610             : 
   17611             : */
   17612             : SWIGINTERN VALUE
   17613           0 : _wrap_SetPlugins_serialise(int argc, VALUE *argv, VALUE self) {
   17614           0 :   kdb::tools::SetPlugins *arg1 = (kdb::tools::SetPlugins *) 0 ;
   17615           0 :   kdb::Key *arg2 = 0 ;
   17616           0 :   kdb::KeySet *arg3 = 0 ;
   17617           0 :   void *argp1 = 0 ;
   17618           0 :   int res1 = 0 ;
   17619           0 :   void *argp2 = 0 ;
   17620           0 :   int res2 = 0 ;
   17621           0 :   void *argp3 = 0 ;
   17622           0 :   int res3 = 0 ;
   17623             :   
   17624           0 :   if ((argc < 2) || (argc > 2)) {
   17625           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   17626             :   }
   17627           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SetPlugins, 0 |  0 );
   17628           0 :   if (!SWIG_IsOK(res1)) {
   17629           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SetPlugins *","serialise", 1, self )); 
   17630             :   }
   17631           0 :   arg1 = reinterpret_cast< kdb::tools::SetPlugins * >(argp1);
   17632           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   17633           0 :   if (!SWIG_IsOK(res2)) {
   17634           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::Key &","serialise", 2, argv[0] )); 
   17635             :   }
   17636           0 :   if (!argp2) {
   17637           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key &","serialise", 2, argv[0])); 
   17638             :   }
   17639           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
   17640           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__KeySet,  0 );
   17641           0 :   if (!SWIG_IsOK(res3)) {
   17642           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::KeySet &","serialise", 3, argv[1] )); 
   17643             :   }
   17644           0 :   if (!argp3) {
   17645           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","serialise", 3, argv[1])); 
   17646             :   }
   17647           0 :   arg3 = reinterpret_cast< kdb::KeySet * >(argp3);
   17648           0 :   (arg1)->serialise(*arg2,*arg3);
   17649             :   return Qnil;
   17650             : fail:
   17651             :   return Qnil;
   17652             : }
   17653             : 
   17654             : 
   17655             : SWIGINTERN VALUE
   17656             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   17657           0 : _wrap_SetPlugins_allocate(VALUE self)
   17658             : #else
   17659             : _wrap_SetPlugins_allocate(int argc, VALUE *argv, VALUE self)
   17660             : #endif
   17661             : {
   17662           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__SetPlugins);
   17663             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   17664             :   rb_obj_call_init(vresult, argc, argv);
   17665             : #endif
   17666           0 :   return vresult;
   17667             : }
   17668             : 
   17669             : 
   17670             : 
   17671             : /*
   17672             :   Document-method: Kdbtools::SetPlugins.new
   17673             : 
   17674             :   call-seq:
   17675             :     SetPlugins.new
   17676             : 
   17677             : Class constructor.
   17678             : 
   17679             : */
   17680             : SWIGINTERN VALUE
   17681           0 : _wrap_new_SetPlugins(int argc, VALUE *argv, VALUE self) {
   17682           0 :   kdb::tools::SetPlugins *result = 0 ;
   17683             :   
   17684           0 :   if ((argc < 0) || (argc > 0)) {
   17685           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   17686             :   }
   17687           0 :   result = (kdb::tools::SetPlugins *)new kdb::tools::SetPlugins();
   17688           0 :   DATA_PTR(self) = result;
   17689             :   return self;
   17690             : fail:
   17691             :   return Qnil;
   17692             : }
   17693             : 
   17694             : 
   17695             : SWIGINTERN void
   17696           0 : free_kdb_tools_SetPlugins(void *self) {
   17697           0 :     kdb::tools::SetPlugins *arg1 = (kdb::tools::SetPlugins *)self;
   17698           0 :     delete arg1;
   17699           0 : }
   17700             : 
   17701             : 
   17702             : /*
   17703             :   Document-class: Kdbtools::ErrorPlugins
   17704             : 
   17705             :   Proxy of C++ Kdbtools::ErrorPlugins class
   17706             : 
   17707             : 
   17708             : */
   17709             : static swig_class SwigClassErrorPlugins;
   17710             : 
   17711             : 
   17712             : /*
   17713             :   Document-method: Kdbtools::ErrorPlugins.status
   17714             : 
   17715             :   call-seq:
   17716             :     status(std::ostream & os)
   17717             : 
   17718             : An instance method.
   17719             : 
   17720             : */
   17721             : SWIGINTERN VALUE
   17722           0 : _wrap_ErrorPlugins_status(int argc, VALUE *argv, VALUE self) {
   17723           0 :   kdb::tools::ErrorPlugins *arg1 = (kdb::tools::ErrorPlugins *) 0 ;
   17724           0 :   std::ostream *arg2 = 0 ;
   17725           0 :   void *argp1 = 0 ;
   17726           0 :   int res1 = 0 ;
   17727           0 :   void *argp2 = 0 ;
   17728           0 :   int res2 = 0 ;
   17729             :   
   17730           0 :   if ((argc < 1) || (argc > 1)) {
   17731           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   17732             :   }
   17733           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ErrorPlugins, 0 |  0 );
   17734           0 :   if (!SWIG_IsOK(res1)) {
   17735           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ErrorPlugins const *","status", 1, self )); 
   17736             :   }
   17737           0 :   arg1 = reinterpret_cast< kdb::tools::ErrorPlugins * >(argp1);
   17738           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__ostream,  0 );
   17739           0 :   if (!SWIG_IsOK(res2)) {
   17740           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::ostream &","status", 2, argv[0] )); 
   17741             :   }
   17742           0 :   if (!argp2) {
   17743           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ostream &","status", 2, argv[0])); 
   17744             :   }
   17745           0 :   arg2 = reinterpret_cast< std::ostream * >(argp2);
   17746           0 :   ((kdb::tools::ErrorPlugins const *)arg1)->status(*arg2);
   17747             :   return Qnil;
   17748             : fail:
   17749             :   return Qnil;
   17750             : }
   17751             : 
   17752             : 
   17753             : 
   17754             : /*
   17755             :   Document-method: Kdbtools::ErrorPlugins.try_plugin
   17756             : 
   17757             :   call-seq:
   17758             :     try_plugin(Plugin plugin)
   17759             : 
   17760             : An instance method.
   17761             : 
   17762             : */
   17763             : SWIGINTERN VALUE
   17764           0 : _wrap_ErrorPlugins_try_plugin(int argc, VALUE *argv, VALUE self) {
   17765           0 :   kdb::tools::ErrorPlugins *arg1 = (kdb::tools::ErrorPlugins *) 0 ;
   17766           0 :   kdb::tools::Plugin *arg2 = 0 ;
   17767           0 :   void *argp1 = 0 ;
   17768           0 :   int res1 = 0 ;
   17769           0 :   void *argp2 = 0 ;
   17770           0 :   int res2 = 0 ;
   17771             :   
   17772           0 :   if ((argc < 1) || (argc > 1)) {
   17773           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   17774             :   }
   17775           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ErrorPlugins, 0 |  0 );
   17776           0 :   if (!SWIG_IsOK(res1)) {
   17777           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ErrorPlugins *","tryPlugin", 1, self )); 
   17778             :   }
   17779           0 :   arg1 = reinterpret_cast< kdb::tools::ErrorPlugins * >(argp1);
   17780           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   17781           0 :   if (!SWIG_IsOK(res2)) {
   17782           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","tryPlugin", 2, argv[0] )); 
   17783             :   }
   17784           0 :   if (!argp2) {
   17785           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","tryPlugin", 2, argv[0])); 
   17786             :   }
   17787           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   17788             :   try {
   17789           0 :     (arg1)->tryPlugin(*arg2);
   17790             :   }
   17791           0 :   catch(kdb::tools::MissingSymbol &_e) {
   17792           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   17793             :   }
   17794           0 :   catch(kdb::tools::TooManyPlugins &_e) {
   17795           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__TooManyPlugins, SWIG_NewPointerObj((new kdb::tools::TooManyPlugins(static_cast< const kdb::tools::TooManyPlugins& >(_e))),SWIGTYPE_p_kdb__tools__TooManyPlugins,SWIG_POINTER_OWN))); SWIG_fail;
   17796             :   }
   17797           0 :   catch(kdb::tools::StoragePlugin &_e) {
   17798           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__StoragePlugin, SWIG_NewPointerObj((new kdb::tools::StoragePlugin(static_cast< const kdb::tools::StoragePlugin& >(_e))),SWIGTYPE_p_kdb__tools__StoragePlugin,SWIG_POINTER_OWN))); SWIG_fail;
   17799             :   }
   17800           0 :   catch(kdb::tools::ResolverPlugin &_e) {
   17801           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ResolverPlugin, SWIG_NewPointerObj((new kdb::tools::ResolverPlugin(static_cast< const kdb::tools::ResolverPlugin& >(_e))),SWIGTYPE_p_kdb__tools__ResolverPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   17802             :   }
   17803           0 :   catch(kdb::tools::OrderingViolation &_e) {
   17804           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__OrderingViolation, SWIG_NewPointerObj((new kdb::tools::OrderingViolation(static_cast< const kdb::tools::OrderingViolation& >(_e))),SWIGTYPE_p_kdb__tools__OrderingViolation,SWIG_POINTER_OWN))); SWIG_fail;
   17805             :   }
   17806           0 :   catch(kdb::tools::ConflictViolation &_e) {
   17807           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ConflictViolation, SWIG_NewPointerObj((new kdb::tools::ConflictViolation(static_cast< const kdb::tools::ConflictViolation& >(_e))),SWIGTYPE_p_kdb__tools__ConflictViolation,SWIG_POINTER_OWN))); SWIG_fail;
   17808             :   }
   17809           0 :   catch(kdb::tools::PluginCheckException &_e) {
   17810           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   17811             :   }
   17812           0 :   catch(kdb::tools::ToolException &_e) {
   17813           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   17814             :   }
   17815             :   
   17816             :   return Qnil;
   17817             : fail:
   17818             :   return Qnil;
   17819             : }
   17820             : 
   17821             : 
   17822             : 
   17823             : /*
   17824             :   Document-method: Kdbtools::ErrorPlugins.add_plugin
   17825             : 
   17826             :   call-seq:
   17827             :     add_plugin(Plugin plugin)
   17828             : 
   17829             : An instance method.
   17830             : 
   17831             : */
   17832             : SWIGINTERN VALUE
   17833           0 : _wrap_ErrorPlugins_add_plugin(int argc, VALUE *argv, VALUE self) {
   17834           0 :   kdb::tools::ErrorPlugins *arg1 = (kdb::tools::ErrorPlugins *) 0 ;
   17835           0 :   kdb::tools::Plugin *arg2 = 0 ;
   17836           0 :   void *argp1 = 0 ;
   17837           0 :   int res1 = 0 ;
   17838           0 :   void *argp2 = 0 ;
   17839           0 :   int res2 = 0 ;
   17840             :   
   17841           0 :   if ((argc < 1) || (argc > 1)) {
   17842           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   17843             :   }
   17844           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ErrorPlugins, 0 |  0 );
   17845           0 :   if (!SWIG_IsOK(res1)) {
   17846           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ErrorPlugins *","addPlugin", 1, self )); 
   17847             :   }
   17848           0 :   arg1 = reinterpret_cast< kdb::tools::ErrorPlugins * >(argp1);
   17849           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__Plugin,  0 );
   17850           0 :   if (!SWIG_IsOK(res2)) {
   17851           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::Plugin &","addPlugin", 2, argv[0] )); 
   17852             :   }
   17853           0 :   if (!argp2) {
   17854           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Plugin &","addPlugin", 2, argv[0])); 
   17855             :   }
   17856           0 :   arg2 = reinterpret_cast< kdb::tools::Plugin * >(argp2);
   17857           0 :   (arg1)->addPlugin(*arg2);
   17858             :   return Qnil;
   17859             : fail:
   17860             :   return Qnil;
   17861             : }
   17862             : 
   17863             : 
   17864             : 
   17865             : /*
   17866             :   Document-method: Kdbtools::ErrorPlugins.validated
   17867             : 
   17868             :   call-seq:
   17869             :     validated -> bool
   17870             : 
   17871             : An instance method.
   17872             : 
   17873             : */
   17874             : SWIGINTERN VALUE
   17875           0 : _wrap_ErrorPlugins_validated(int argc, VALUE *argv, VALUE self) {
   17876           0 :   kdb::tools::ErrorPlugins *arg1 = (kdb::tools::ErrorPlugins *) 0 ;
   17877           0 :   void *argp1 = 0 ;
   17878           0 :   int res1 = 0 ;
   17879             :   bool result;
   17880           0 :   VALUE vresult = Qnil;
   17881             :   
   17882           0 :   if ((argc < 0) || (argc > 0)) {
   17883           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   17884             :   }
   17885           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ErrorPlugins, 0 |  0 );
   17886           0 :   if (!SWIG_IsOK(res1)) {
   17887           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ErrorPlugins const *","validated", 1, self )); 
   17888             :   }
   17889           0 :   arg1 = reinterpret_cast< kdb::tools::ErrorPlugins * >(argp1);
   17890           0 :   result = (bool)((kdb::tools::ErrorPlugins const *)arg1)->validated();
   17891           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   17892             :   return vresult;
   17893             : fail:
   17894             :   return Qnil;
   17895             : }
   17896             : 
   17897             : 
   17898             : 
   17899             : /*
   17900             :   Document-method: Kdbtools::ErrorPlugins.serialise
   17901             : 
   17902             :   call-seq:
   17903             :     serialise(Key baseKey, KeySet ret)
   17904             : 
   17905             : An instance method.
   17906             : 
   17907             : */
   17908             : SWIGINTERN VALUE
   17909           0 : _wrap_ErrorPlugins_serialise(int argc, VALUE *argv, VALUE self) {
   17910           0 :   kdb::tools::ErrorPlugins *arg1 = (kdb::tools::ErrorPlugins *) 0 ;
   17911           0 :   kdb::Key *arg2 = 0 ;
   17912           0 :   kdb::KeySet *arg3 = 0 ;
   17913           0 :   void *argp1 = 0 ;
   17914           0 :   int res1 = 0 ;
   17915           0 :   void *argp2 = 0 ;
   17916           0 :   int res2 = 0 ;
   17917           0 :   void *argp3 = 0 ;
   17918           0 :   int res3 = 0 ;
   17919             :   
   17920           0 :   if ((argc < 2) || (argc > 2)) {
   17921           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   17922             :   }
   17923           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ErrorPlugins, 0 |  0 );
   17924           0 :   if (!SWIG_IsOK(res1)) {
   17925           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ErrorPlugins *","serialise", 1, self )); 
   17926             :   }
   17927           0 :   arg1 = reinterpret_cast< kdb::tools::ErrorPlugins * >(argp1);
   17928           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   17929           0 :   if (!SWIG_IsOK(res2)) {
   17930           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::Key &","serialise", 2, argv[0] )); 
   17931             :   }
   17932           0 :   if (!argp2) {
   17933           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key &","serialise", 2, argv[0])); 
   17934             :   }
   17935           0 :   arg2 = reinterpret_cast< kdb::Key * >(argp2);
   17936           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__KeySet,  0 );
   17937           0 :   if (!SWIG_IsOK(res3)) {
   17938           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::KeySet &","serialise", 3, argv[1] )); 
   17939             :   }
   17940           0 :   if (!argp3) {
   17941           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","serialise", 3, argv[1])); 
   17942             :   }
   17943           0 :   arg3 = reinterpret_cast< kdb::KeySet * >(argp3);
   17944           0 :   (arg1)->serialise(*arg2,*arg3);
   17945             :   return Qnil;
   17946             : fail:
   17947             :   return Qnil;
   17948             : }
   17949             : 
   17950             : 
   17951             : SWIGINTERN VALUE
   17952             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   17953           0 : _wrap_ErrorPlugins_allocate(VALUE self)
   17954             : #else
   17955             : _wrap_ErrorPlugins_allocate(int argc, VALUE *argv, VALUE self)
   17956             : #endif
   17957             : {
   17958           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__ErrorPlugins);
   17959             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   17960             :   rb_obj_call_init(vresult, argc, argv);
   17961             : #endif
   17962           0 :   return vresult;
   17963             : }
   17964             : 
   17965             : 
   17966             : 
   17967             : /*
   17968             :   Document-method: Kdbtools::ErrorPlugins.new
   17969             : 
   17970             :   call-seq:
   17971             :     ErrorPlugins.new
   17972             : 
   17973             : Class constructor.
   17974             : 
   17975             : */
   17976             : SWIGINTERN VALUE
   17977           0 : _wrap_new_ErrorPlugins(int argc, VALUE *argv, VALUE self) {
   17978           0 :   kdb::tools::ErrorPlugins *result = 0 ;
   17979             :   
   17980           0 :   if ((argc < 0) || (argc > 0)) {
   17981           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   17982             :   }
   17983           0 :   result = (kdb::tools::ErrorPlugins *)new kdb::tools::ErrorPlugins();
   17984           0 :   DATA_PTR(self) = result;
   17985             :   return self;
   17986             : fail:
   17987             :   return Qnil;
   17988             : }
   17989             : 
   17990             : 
   17991             : SWIGINTERN void
   17992           0 : free_kdb_tools_ErrorPlugins(void *self) {
   17993           0 :     kdb::tools::ErrorPlugins *arg1 = (kdb::tools::ErrorPlugins *)self;
   17994           0 :     delete arg1;
   17995           0 : }
   17996             : 
   17997             : 
   17998             : /*
   17999             :   Document-class: Kdbtools::IntPluginSpecMap
   18000             : 
   18001             :   Proxy of C++ Kdbtools::IntPluginSpecMap class
   18002             : 
   18003             : 
   18004             : */
   18005             : static swig_class SwigClassIntPluginSpecMap;
   18006             : 
   18007             : 
   18008             : /*
   18009             :   Document-method: Kdbtools::IntPluginSpecMap.new
   18010             : 
   18011             :   call-seq:
   18012             :     IntPluginSpecMap.new(std::less< int > const & arg2)
   18013             :     IntPluginSpecMap.new
   18014             :     IntPluginSpecMap.new(IntPluginSpecMap arg2)
   18015             : 
   18016             : Class constructor.
   18017             : 
   18018             : */
   18019             : SWIGINTERN VALUE
   18020           0 : _wrap_new_IntPluginSpecMap__SWIG_0(int argc, VALUE *argv, VALUE self) {
   18021           0 :   std::less< int > *arg1 = 0 ;
   18022             :   void *argp1 ;
   18023           0 :   int res1 = 0 ;
   18024           0 :   std::map< int,kdb::tools::PluginSpec > *result = 0 ;
   18025             :   
   18026           0 :   if ((argc < 1) || (argc > 1)) {
   18027           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   18028             :   }
   18029           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__lessT_int_t,  0 );
   18030           0 :   if (!SWIG_IsOK(res1)) {
   18031           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::less< int > const &","map<(int,kdb::tools::PluginSpec)>", 1, argv[0] )); 
   18032             :   }
   18033           0 :   if (!argp1) {
   18034           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::less< int > const &","map<(int,kdb::tools::PluginSpec)>", 1, argv[0])); 
   18035             :   }
   18036           0 :   arg1 = reinterpret_cast< std::less< int > * >(argp1);
   18037           0 :   result = (std::map< int,kdb::tools::PluginSpec > *)new std::map< int,kdb::tools::PluginSpec >((std::less< int > const &)*arg1);
   18038           0 :   DATA_PTR(self) = result;
   18039             :   return self;
   18040             : fail:
   18041             :   return Qnil;
   18042             : }
   18043             : 
   18044             : 
   18045             : 
   18046             : /*
   18047             :   Document-method: Kdbtools::IntPluginSpecMap.dup
   18048             : 
   18049             :   call-seq:
   18050             :     dup -> IntPluginSpecMap
   18051             : 
   18052             : Create a duplicate of the class and unfreeze it if needed.
   18053             : */
   18054             : SWIGINTERN VALUE
   18055           0 : _wrap_IntPluginSpecMap_dup(int argc, VALUE *argv, VALUE self) {
   18056           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18057           0 :   void *argp1 = 0 ;
   18058           0 :   int res1 = 0 ;
   18059           0 :   std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *result = 0 ;
   18060           0 :   VALUE vresult = Qnil;
   18061             :   
   18062           0 :   if ((argc < 0) || (argc > 0)) {
   18063           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18064             :   }
   18065           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18066           0 :   if (!SWIG_IsOK(res1)) {
   18067           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","dup", 1, self )); 
   18068             :   }
   18069           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18070           0 :   result = (std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__dup(arg1);
   18071           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, SWIG_POINTER_OWN |  0 );
   18072             :   return vresult;
   18073             : fail:
   18074             :   return Qnil;
   18075             : }
   18076             : 
   18077             : 
   18078             : 
   18079             : /*
   18080             :   Document-method: Kdbtools::IntPluginSpecMap.__delete__
   18081             : 
   18082             :   call-seq:
   18083             :     __delete__(key) -> VALUE
   18084             : 
   18085             : Delete a matching element.
   18086             : */
   18087             : SWIGINTERN VALUE
   18088           0 : _wrap_IntPluginSpecMap___delete__(int argc, VALUE *argv, VALUE self) {
   18089           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18090           0 :   std::map< int,kdb::tools::PluginSpec >::key_type *arg2 = 0 ;
   18091           0 :   void *argp1 = 0 ;
   18092           0 :   int res1 = 0 ;
   18093             :   std::map< int,kdb::tools::PluginSpec >::key_type temp2 ;
   18094             :   int val2 ;
   18095           0 :   int ecode2 = 0 ;
   18096             :   VALUE result;
   18097           0 :   VALUE vresult = Qnil;
   18098             :   
   18099           0 :   if ((argc < 1) || (argc > 1)) {
   18100           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   18101             :   }
   18102           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18103           0 :   if (!SWIG_IsOK(res1)) {
   18104           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","__delete__", 1, self )); 
   18105             :   }
   18106           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18107           0 :   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   18108           0 :   if (!SWIG_IsOK(ecode2)) {
   18109           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec >::key_type","__delete__", 2, argv[0] ));
   18110             :   } 
   18111           0 :   temp2 = static_cast< std::map< int,kdb::tools::PluginSpec >::key_type >(val2);
   18112           0 :   arg2 = &temp2;
   18113           0 :   result = (VALUE)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg____delete__(arg1,(int const &)*arg2);
   18114           0 :   vresult = result;
   18115             :   return vresult;
   18116             : fail:
   18117             :   return Qnil;
   18118             : }
   18119             : 
   18120             : 
   18121             : 
   18122             : /*
   18123             :   Document-method: Kdbtools::IntPluginSpecMap.has_key
   18124             : 
   18125             :   call-seq:
   18126             :     has_key(std::map< int,kdb::tools::PluginSpec >::key_type const & key) -> bool
   18127             : 
   18128             : An instance method.
   18129             : 
   18130             : */
   18131             : SWIGINTERN VALUE
   18132           0 : _wrap_IntPluginSpecMap_has_key(int argc, VALUE *argv, VALUE self) {
   18133           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18134           0 :   std::map< int,kdb::tools::PluginSpec >::key_type *arg2 = 0 ;
   18135           0 :   void *argp1 = 0 ;
   18136           0 :   int res1 = 0 ;
   18137             :   std::map< int,kdb::tools::PluginSpec >::key_type temp2 ;
   18138             :   int val2 ;
   18139           0 :   int ecode2 = 0 ;
   18140             :   bool result;
   18141           0 :   VALUE vresult = Qnil;
   18142             :   
   18143           0 :   if ((argc < 1) || (argc > 1)) {
   18144           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   18145             :   }
   18146           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18147           0 :   if (!SWIG_IsOK(res1)) {
   18148           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > const *","has_key", 1, self )); 
   18149             :   }
   18150           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18151           0 :   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   18152           0 :   if (!SWIG_IsOK(ecode2)) {
   18153           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec >::key_type","has_key", 2, argv[0] ));
   18154             :   } 
   18155           0 :   temp2 = static_cast< std::map< int,kdb::tools::PluginSpec >::key_type >(val2);
   18156           0 :   arg2 = &temp2;
   18157           0 :   result = (bool)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__has_key((std::map< int,kdb::tools::PluginSpec > const *)arg1,(int const &)*arg2);
   18158           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   18159             :   return vresult;
   18160             : fail:
   18161             :   return Qnil;
   18162             : }
   18163             : 
   18164             : 
   18165             : 
   18166             : /*
   18167             :   Document-method: Kdbtools::IntPluginSpecMap.keys
   18168             : 
   18169             :   call-seq:
   18170             :     keys -> VALUE
   18171             : 
   18172             : Return an Array of key elements.
   18173             : */
   18174             : SWIGINTERN VALUE
   18175           0 : _wrap_IntPluginSpecMap_keys(int argc, VALUE *argv, VALUE self) {
   18176           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18177           0 :   void *argp1 = 0 ;
   18178           0 :   int res1 = 0 ;
   18179             :   VALUE result;
   18180           0 :   VALUE vresult = Qnil;
   18181             :   
   18182           0 :   if ((argc < 0) || (argc > 0)) {
   18183           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18184             :   }
   18185           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18186           0 :   if (!SWIG_IsOK(res1)) {
   18187           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","keys", 1, self )); 
   18188             :   }
   18189           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18190           0 :   result = (VALUE)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__keys(arg1);
   18191           0 :   vresult = result;
   18192             :   return vresult;
   18193             : fail:
   18194             :   return Qnil;
   18195             : }
   18196             : 
   18197             : 
   18198             : 
   18199             : /*
   18200             :   Document-method: Kdbtools::IntPluginSpecMap.each
   18201             : 
   18202             :   call-seq:
   18203             :     each -> IntPluginSpecMap
   18204             : 
   18205             : Iterate thru each element in the IntPluginSpecMap.  A block must be provided.
   18206             : */
   18207             : SWIGINTERN VALUE
   18208           1 : _wrap_IntPluginSpecMap_each(int argc, VALUE *argv, VALUE self) {
   18209           1 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18210           1 :   void *argp1 = 0 ;
   18211           1 :   int res1 = 0 ;
   18212           1 :   std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *result = 0 ;
   18213           1 :   VALUE vresult = Qnil;
   18214             :   
   18215           1 :   if ((argc < 0) || (argc > 0)) {
   18216           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18217             :   }
   18218           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18219           1 :   if (!SWIG_IsOK(res1)) {
   18220           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","each", 1, self )); 
   18221             :   }
   18222           1 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18223           1 :   result = (std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__each(arg1);
   18224           1 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18225             :   return vresult;
   18226             : fail:
   18227             :   return Qnil;
   18228             : }
   18229             : 
   18230             : 
   18231             : 
   18232             : /*
   18233             :   Document-method: Kdbtools::IntPluginSpecMap.select
   18234             : 
   18235             :   call-seq:
   18236             :     select -> IntPluginSpecMap
   18237             : 
   18238             : Iterate thru each element in the IntPluginSpecMap and select those that match a condition.  A block must be provided.
   18239             : */
   18240             : SWIGINTERN VALUE
   18241           0 : _wrap_IntPluginSpecMap_select(int argc, VALUE *argv, VALUE self) {
   18242           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18243           0 :   void *argp1 = 0 ;
   18244           0 :   int res1 = 0 ;
   18245           0 :   std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *result = 0 ;
   18246           0 :   VALUE vresult = Qnil;
   18247             :   
   18248           0 :   if ((argc < 0) || (argc > 0)) {
   18249           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18250             :   }
   18251           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18252           0 :   if (!SWIG_IsOK(res1)) {
   18253           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","select", 1, self )); 
   18254             :   }
   18255           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18256           0 :   result = (std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__select(arg1);
   18257           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, SWIG_POINTER_OWN |  0 );
   18258             :   return vresult;
   18259             : fail:
   18260             :   return Qnil;
   18261             : }
   18262             : 
   18263             : 
   18264             : 
   18265             : /*
   18266             :   Document-method: Kdbtools::IntPluginSpecMap.values_at
   18267             : 
   18268             :   call-seq:
   18269             :     values_at(argc) -> VALUE
   18270             : 
   18271             : Return an Array of value elements matching the conditions.
   18272             : */
   18273             : SWIGINTERN VALUE
   18274           0 : _wrap_IntPluginSpecMap_values_at(int argc, VALUE *argv, VALUE self) {
   18275           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18276             :   int arg2 ;
   18277           0 :   VALUE *arg3 = (VALUE *) 0 ;
   18278           0 :   void *arg4 = 0 ;
   18279           0 :   void *argp1 = 0 ;
   18280           0 :   int res1 = 0 ;
   18281             :   VALUE result;
   18282           0 :   VALUE vresult = Qnil;
   18283             :   
   18284           0 :   if (argc < 1) {
   18285           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   18286             :   }
   18287           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18288           0 :   if (!SWIG_IsOK(res1)) {
   18289           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","values_at", 1, self )); 
   18290             :   }
   18291           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18292             :   {
   18293           0 :     arg2 = argc;
   18294           0 :     arg3 = argv;
   18295             :   }
   18296           0 :   result = (VALUE)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__values_at(arg1,arg2,arg3,arg4);
   18297           0 :   vresult = result;
   18298             :   return vresult;
   18299             : fail:
   18300             :   return Qnil;
   18301             : }
   18302             : 
   18303             : 
   18304             : 
   18305             : /*
   18306             :   Document-method: Kdbtools::IntPluginSpecMap.each_key
   18307             : 
   18308             :   call-seq:
   18309             :     each_key -> IntPluginSpecMap
   18310             : 
   18311             : Iterate thru each key element in the IntPluginSpecMap.  A block must be provided.
   18312             : */
   18313             : SWIGINTERN VALUE
   18314           0 : _wrap_IntPluginSpecMap_each_key(int argc, VALUE *argv, VALUE self) {
   18315           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18316           0 :   void *argp1 = 0 ;
   18317           0 :   int res1 = 0 ;
   18318           0 :   std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *result = 0 ;
   18319           0 :   VALUE vresult = Qnil;
   18320             :   
   18321           0 :   if ((argc < 0) || (argc > 0)) {
   18322           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18323             :   }
   18324           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18325           0 :   if (!SWIG_IsOK(res1)) {
   18326           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","each_key", 1, self )); 
   18327             :   }
   18328           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18329           0 :   result = (std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__each_key(arg1);
   18330           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18331             :   return vresult;
   18332             : fail:
   18333             :   return Qnil;
   18334             : }
   18335             : 
   18336             : 
   18337             : 
   18338             : /*
   18339             :   Document-method: Kdbtools::IntPluginSpecMap.values
   18340             : 
   18341             :   call-seq:
   18342             :     values -> VALUE
   18343             : 
   18344             : Return an Array of value elements.
   18345             : */
   18346             : SWIGINTERN VALUE
   18347           0 : _wrap_IntPluginSpecMap_values(int argc, VALUE *argv, VALUE self) {
   18348           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18349           0 :   void *argp1 = 0 ;
   18350           0 :   int res1 = 0 ;
   18351             :   VALUE result;
   18352           0 :   VALUE vresult = Qnil;
   18353             :   
   18354           0 :   if ((argc < 0) || (argc > 0)) {
   18355           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18356             :   }
   18357           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18358           0 :   if (!SWIG_IsOK(res1)) {
   18359           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","values", 1, self )); 
   18360             :   }
   18361           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18362           0 :   result = (VALUE)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__values(arg1);
   18363           0 :   vresult = result;
   18364             :   return vresult;
   18365             : fail:
   18366             :   return Qnil;
   18367             : }
   18368             : 
   18369             : 
   18370             : 
   18371             : /*
   18372             :   Document-method: Kdbtools::IntPluginSpecMap.each_value
   18373             : 
   18374             :   call-seq:
   18375             :     each_value -> IntPluginSpecMap
   18376             : 
   18377             : Iterate thru each key element in the IntPluginSpecMap.  A block must be provided.
   18378             : */
   18379             : SWIGINTERN VALUE
   18380           0 : _wrap_IntPluginSpecMap_each_value(int argc, VALUE *argv, VALUE self) {
   18381           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18382           0 :   void *argp1 = 0 ;
   18383           0 :   int res1 = 0 ;
   18384           0 :   std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *result = 0 ;
   18385           0 :   VALUE vresult = Qnil;
   18386             :   
   18387           0 :   if ((argc < 0) || (argc > 0)) {
   18388           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18389             :   }
   18390           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18391           0 :   if (!SWIG_IsOK(res1)) {
   18392           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","each_value", 1, self )); 
   18393             :   }
   18394           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18395           0 :   result = (std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__each_value(arg1);
   18396           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18397             :   return vresult;
   18398             : fail:
   18399             :   return Qnil;
   18400             : }
   18401             : 
   18402             : 
   18403             : 
   18404             : /*
   18405             :   Document-method: Kdbtools::IntPluginSpecMap.entries
   18406             : 
   18407             :   call-seq:
   18408             :     entries -> VALUE
   18409             : 
   18410             : An instance method.
   18411             : 
   18412             : */
   18413             : SWIGINTERN VALUE
   18414           0 : _wrap_IntPluginSpecMap_entries(int argc, VALUE *argv, VALUE self) {
   18415           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18416           0 :   void *argp1 = 0 ;
   18417           0 :   int res1 = 0 ;
   18418             :   VALUE result;
   18419           0 :   VALUE vresult = Qnil;
   18420             :   
   18421           0 :   if ((argc < 0) || (argc > 0)) {
   18422           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18423             :   }
   18424           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18425           0 :   if (!SWIG_IsOK(res1)) {
   18426           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","entries", 1, self )); 
   18427             :   }
   18428           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18429           0 :   result = (VALUE)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__entries(arg1);
   18430           0 :   vresult = result;
   18431             :   return vresult;
   18432             : fail:
   18433             :   return Qnil;
   18434             : }
   18435             : 
   18436             : 
   18437             : 
   18438             : /*
   18439             :   Document-method: Kdbtools::IntPluginSpecMap.__contains__
   18440             : 
   18441             :   call-seq:
   18442             :     __contains__(std::map< int,kdb::tools::PluginSpec >::key_type const & key) -> bool
   18443             : 
   18444             : An instance method.
   18445             : 
   18446             : */
   18447             : SWIGINTERN VALUE
   18448           0 : _wrap_IntPluginSpecMap___contains__(int argc, VALUE *argv, VALUE self) {
   18449           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18450           0 :   std::map< int,kdb::tools::PluginSpec >::key_type *arg2 = 0 ;
   18451           0 :   void *argp1 = 0 ;
   18452           0 :   int res1 = 0 ;
   18453             :   std::map< int,kdb::tools::PluginSpec >::key_type temp2 ;
   18454             :   int val2 ;
   18455           0 :   int ecode2 = 0 ;
   18456             :   bool result;
   18457           0 :   VALUE vresult = Qnil;
   18458             :   
   18459           0 :   if ((argc < 1) || (argc > 1)) {
   18460           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   18461             :   }
   18462           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18463           0 :   if (!SWIG_IsOK(res1)) {
   18464           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","__contains__", 1, self )); 
   18465             :   }
   18466           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18467           0 :   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   18468           0 :   if (!SWIG_IsOK(ecode2)) {
   18469           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec >::key_type","__contains__", 2, argv[0] ));
   18470             :   } 
   18471           0 :   temp2 = static_cast< std::map< int,kdb::tools::PluginSpec >::key_type >(val2);
   18472           0 :   arg2 = &temp2;
   18473           0 :   result = (bool)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg____contains__(arg1,(int const &)*arg2);
   18474           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   18475             :   return vresult;
   18476             : fail:
   18477             :   return Qnil;
   18478             : }
   18479             : 
   18480             : 
   18481             : 
   18482             : /*
   18483             :   Document-method: Kdbtools::IntPluginSpecMap.key_iterator
   18484             : 
   18485             :   call-seq:
   18486             :     key_iterator -> ConstIterator
   18487             : 
   18488             : An instance method.
   18489             : 
   18490             : */
   18491             : SWIGINTERN VALUE
   18492           0 : _wrap_IntPluginSpecMap_key_iterator(int argc, VALUE *argv, VALUE self) {
   18493           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18494           0 :   VALUE *arg2 = (VALUE *) 0 ;
   18495           0 :   void *argp1 = 0 ;
   18496           0 :   int res1 = 0 ;
   18497           0 :   swig::ConstIterator *result = 0 ;
   18498           0 :   VALUE vresult = Qnil;
   18499             :   
   18500           0 :   arg2 = &self;
   18501           0 :   if ((argc < 0) || (argc > 0)) {
   18502           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18503             :   }
   18504           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18505           0 :   if (!SWIG_IsOK(res1)) {
   18506           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","key_iterator", 1, self )); 
   18507             :   }
   18508           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18509           0 :   result = (swig::ConstIterator *)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__key_iterator(arg1,arg2);
   18510           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
   18511             :   return vresult;
   18512             : fail:
   18513             :   return Qnil;
   18514             : }
   18515             : 
   18516             : 
   18517             : 
   18518             : /*
   18519             :   Document-method: Kdbtools::IntPluginSpecMap.value_iterator
   18520             : 
   18521             :   call-seq:
   18522             :     value_iterator -> ConstIterator
   18523             : 
   18524             : An instance method.
   18525             : 
   18526             : */
   18527             : SWIGINTERN VALUE
   18528           0 : _wrap_IntPluginSpecMap_value_iterator(int argc, VALUE *argv, VALUE self) {
   18529           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18530           0 :   VALUE *arg2 = (VALUE *) 0 ;
   18531           0 :   void *argp1 = 0 ;
   18532           0 :   int res1 = 0 ;
   18533           0 :   swig::ConstIterator *result = 0 ;
   18534           0 :   VALUE vresult = Qnil;
   18535             :   
   18536           0 :   arg2 = &self;
   18537           0 :   if ((argc < 0) || (argc > 0)) {
   18538           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18539             :   }
   18540           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18541           0 :   if (!SWIG_IsOK(res1)) {
   18542           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","value_iterator", 1, self )); 
   18543             :   }
   18544           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18545           0 :   result = (swig::ConstIterator *)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__value_iterator(arg1,arg2);
   18546           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
   18547             :   return vresult;
   18548             : fail:
   18549             :   return Qnil;
   18550             : }
   18551             : 
   18552             : 
   18553             : 
   18554             : /*
   18555             :   Document-method: Kdbtools::IntPluginSpecMap.[]
   18556             : 
   18557             :   call-seq:
   18558             :     [](key) -> VALUE
   18559             : 
   18560             : Element accessor/slicing.
   18561             : */
   18562             : SWIGINTERN VALUE
   18563           0 : _wrap_IntPluginSpecMap___getitem__(int argc, VALUE *argv, VALUE self) {
   18564           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18565           0 :   std::map< int,kdb::tools::PluginSpec >::key_type *arg2 = 0 ;
   18566           0 :   void *argp1 = 0 ;
   18567           0 :   int res1 = 0 ;
   18568             :   std::map< int,kdb::tools::PluginSpec >::key_type temp2 ;
   18569             :   int val2 ;
   18570           0 :   int ecode2 = 0 ;
   18571             :   VALUE result;
   18572           0 :   VALUE vresult = Qnil;
   18573             :   
   18574           0 :   if ((argc < 1) || (argc > 1)) {
   18575           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   18576             :   }
   18577           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18578           0 :   if (!SWIG_IsOK(res1)) {
   18579           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > const *","__getitem__", 1, self )); 
   18580             :   }
   18581           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18582           0 :   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   18583           0 :   if (!SWIG_IsOK(ecode2)) {
   18584           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec >::key_type","__getitem__", 2, argv[0] ));
   18585             :   } 
   18586           0 :   temp2 = static_cast< std::map< int,kdb::tools::PluginSpec >::key_type >(val2);
   18587           0 :   arg2 = &temp2;
   18588           0 :   result = (VALUE)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg____getitem__((std::map< int,kdb::tools::PluginSpec > const *)arg1,(int const &)*arg2);
   18589           0 :   vresult = result;
   18590             :   return vresult;
   18591             : fail:
   18592             :   return Qnil;
   18593             : }
   18594             : 
   18595             : 
   18596             : 
   18597             : /*
   18598             :   Document-method: Kdbtools::IntPluginSpecMap.[]=
   18599             : 
   18600             :   call-seq:
   18601             :     []=(key, x)
   18602             : 
   18603             : Element setter/slicing.
   18604             : */
   18605             : SWIGINTERN VALUE
   18606           0 : _wrap_IntPluginSpecMap___setitem__(int argc, VALUE *argv, VALUE self) {
   18607           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18608           0 :   std::map< int,kdb::tools::PluginSpec >::key_type *arg2 = 0 ;
   18609           0 :   std::map< int,kdb::tools::PluginSpec >::mapped_type *arg3 = 0 ;
   18610           0 :   void *argp1 = 0 ;
   18611           0 :   int res1 = 0 ;
   18612             :   std::map< int,kdb::tools::PluginSpec >::key_type temp2 ;
   18613             :   int val2 ;
   18614           0 :   int ecode2 = 0 ;
   18615             :   void *argp3 ;
   18616           0 :   int res3 = 0 ;
   18617             :   
   18618           0 :   if ((argc < 2) || (argc > 2)) {
   18619           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   18620             :   }
   18621           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18622           0 :   if (!SWIG_IsOK(res1)) {
   18623           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","__setitem__", 1, self )); 
   18624             :   }
   18625           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18626           0 :   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   18627           0 :   if (!SWIG_IsOK(ecode2)) {
   18628           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec >::key_type","__setitem__", 2, argv[0] ));
   18629             :   } 
   18630           0 :   temp2 = static_cast< std::map< int,kdb::tools::PluginSpec >::key_type >(val2);
   18631           0 :   arg2 = &temp2;
   18632           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   18633           0 :   if (!SWIG_IsOK(res3)) {
   18634           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec >::mapped_type const &","__setitem__", 3, argv[1] )); 
   18635             :   }
   18636           0 :   if (!argp3) {
   18637           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< int,kdb::tools::PluginSpec >::mapped_type const &","__setitem__", 3, argv[1])); 
   18638             :   }
   18639           0 :   arg3 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec >::mapped_type * >(argp3);
   18640             :   try {
   18641           0 :     std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg____setitem__(arg1,(int const &)*arg2,(kdb::tools::PluginSpec const &)*arg3);
   18642             :   }
   18643           0 :   catch(std::out_of_range &_e) {
   18644           0 :     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   18645             :   }
   18646             :   
   18647             :   return Qnil;
   18648             : fail:
   18649             :   return Qnil;
   18650             : }
   18651             : 
   18652             : 
   18653             : 
   18654             : /*
   18655             :   Document-method: Kdbtools::IntPluginSpecMap.inspect
   18656             : 
   18657             :   call-seq:
   18658             :     inspect -> VALUE
   18659             : 
   18660             : Inspect class and its contents.
   18661             : */
   18662             : SWIGINTERN VALUE
   18663           0 : _wrap_IntPluginSpecMap_inspect(int argc, VALUE *argv, VALUE self) {
   18664           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18665           0 :   void *argp1 = 0 ;
   18666           0 :   int res1 = 0 ;
   18667             :   VALUE result;
   18668           0 :   VALUE vresult = Qnil;
   18669             :   
   18670           0 :   if ((argc < 0) || (argc > 0)) {
   18671           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18672             :   }
   18673           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18674           0 :   if (!SWIG_IsOK(res1)) {
   18675           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","inspect", 1, self )); 
   18676             :   }
   18677           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18678           0 :   result = (VALUE)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__inspect(arg1);
   18679           0 :   vresult = result;
   18680             :   return vresult;
   18681             : fail:
   18682             :   return Qnil;
   18683             : }
   18684             : 
   18685             : 
   18686             : 
   18687             : /*
   18688             :   Document-method: Kdbtools::IntPluginSpecMap.to_a
   18689             : 
   18690             :   call-seq:
   18691             :     to_a -> VALUE
   18692             : 
   18693             : Convert IntPluginSpecMap to an Array.
   18694             : */
   18695             : SWIGINTERN VALUE
   18696           0 : _wrap_IntPluginSpecMap_to_a(int argc, VALUE *argv, VALUE self) {
   18697           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18698           0 :   void *argp1 = 0 ;
   18699           0 :   int res1 = 0 ;
   18700             :   VALUE result;
   18701           0 :   VALUE vresult = Qnil;
   18702             :   
   18703           0 :   if ((argc < 0) || (argc > 0)) {
   18704           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18705             :   }
   18706           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18707           0 :   if (!SWIG_IsOK(res1)) {
   18708           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","to_a", 1, self )); 
   18709             :   }
   18710           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18711           0 :   result = (VALUE)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__to_a(arg1);
   18712           0 :   vresult = result;
   18713             :   return vresult;
   18714             : fail:
   18715             :   return Qnil;
   18716             : }
   18717             : 
   18718             : 
   18719             : 
   18720             : /*
   18721             :   Document-method: Kdbtools::IntPluginSpecMap.to_s
   18722             : 
   18723             :   call-seq:
   18724             :     to_s -> VALUE
   18725             : 
   18726             : Convert class to a String representation.
   18727             : */
   18728             : SWIGINTERN VALUE
   18729           0 : _wrap_IntPluginSpecMap_to_s(int argc, VALUE *argv, VALUE self) {
   18730           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18731           0 :   void *argp1 = 0 ;
   18732           0 :   int res1 = 0 ;
   18733             :   VALUE result;
   18734           0 :   VALUE vresult = Qnil;
   18735             :   
   18736           0 :   if ((argc < 0) || (argc > 0)) {
   18737           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18738             :   }
   18739           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18740           0 :   if (!SWIG_IsOK(res1)) {
   18741           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","to_s", 1, self )); 
   18742             :   }
   18743           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18744           0 :   result = (VALUE)std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg__to_s(arg1);
   18745           0 :   vresult = result;
   18746             :   return vresult;
   18747             : fail:
   18748             :   return Qnil;
   18749             : }
   18750             : 
   18751             : 
   18752             : 
   18753             : /*
   18754             :   Document-method: Kdbtools::IntPluginSpecMap.new
   18755             : 
   18756             :   call-seq:
   18757             :     IntPluginSpecMap.new(std::less< int > const & arg2)
   18758             :     IntPluginSpecMap.new
   18759             :     IntPluginSpecMap.new(IntPluginSpecMap arg2)
   18760             : 
   18761             : Class constructor.
   18762             : 
   18763             : */
   18764             : SWIGINTERN VALUE
   18765           0 : _wrap_new_IntPluginSpecMap__SWIG_1(int argc, VALUE *argv, VALUE self) {
   18766           0 :   std::map< int,kdb::tools::PluginSpec > *result = 0 ;
   18767             :   
   18768           0 :   if ((argc < 0) || (argc > 0)) {
   18769           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18770             :   }
   18771           0 :   result = (std::map< int,kdb::tools::PluginSpec > *)new std::map< int,kdb::tools::PluginSpec >();
   18772           0 :   DATA_PTR(self) = result;
   18773             :   return self;
   18774             : fail:
   18775             :   return Qnil;
   18776             : }
   18777             : 
   18778             : 
   18779             : SWIGINTERN VALUE
   18780             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   18781           0 : _wrap_IntPluginSpecMap_allocate(VALUE self)
   18782             : #else
   18783             : _wrap_IntPluginSpecMap_allocate(int argc, VALUE *argv, VALUE self)
   18784             : #endif
   18785             : {
   18786           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t);
   18787             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   18788             :   rb_obj_call_init(vresult, argc, argv);
   18789             : #endif
   18790           0 :   return vresult;
   18791             : }
   18792             : 
   18793             : 
   18794             : SWIGINTERN VALUE
   18795           0 : _wrap_new_IntPluginSpecMap__SWIG_2(int argc, VALUE *argv, VALUE self) {
   18796           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = 0 ;
   18797           0 :   int res1 = SWIG_OLDOBJ ;
   18798           0 :   std::map< int,kdb::tools::PluginSpec > *result = 0 ;
   18799             :   
   18800           0 :   if ((argc < 1) || (argc > 1)) {
   18801           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   18802             :   }
   18803             :   {
   18804           0 :     std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *ptr = (std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *)0;
   18805           0 :     res1 = swig::asptr(argv[0], &ptr);
   18806           0 :     if (!SWIG_IsOK(res1)) {
   18807           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > const &","map<(int,kdb::tools::PluginSpec)>", 1, argv[0] )); 
   18808             :     }
   18809           0 :     if (!ptr) {
   18810           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< int,kdb::tools::PluginSpec > const &","map<(int,kdb::tools::PluginSpec)>", 1, argv[0])); 
   18811             :     }
   18812           0 :     arg1 = ptr;
   18813             :   }
   18814           0 :   result = (std::map< int,kdb::tools::PluginSpec > *)new std::map< int,kdb::tools::PluginSpec >((std::map< int,kdb::tools::PluginSpec > const &)*arg1);
   18815           0 :   DATA_PTR(self) = result;
   18816           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
   18817             :   return self;
   18818             : fail:
   18819             :   if (SWIG_IsNewObj(res1)) delete arg1;
   18820             :   return Qnil;
   18821             : }
   18822             : 
   18823             : 
   18824           0 : SWIGINTERN VALUE _wrap_new_IntPluginSpecMap(int nargs, VALUE *args, VALUE self) {
   18825             :   int argc;
   18826             :   VALUE argv[1];
   18827             :   int ii;
   18828             :   
   18829           0 :   argc = nargs;
   18830           0 :   if (argc > 1) SWIG_fail;
   18831           0 :   for (ii = 0; (ii < argc); ++ii) {
   18832           0 :     argv[ii] = args[ii];
   18833             :   }
   18834           0 :   if (argc == 0) {
   18835           0 :     return _wrap_new_IntPluginSpecMap__SWIG_1(nargs, args, self);
   18836             :   }
   18837           0 :   if (argc == 1) {
   18838           0 :     int _v = 0;
   18839             :     {
   18840           0 :       void *vptr = 0;
   18841           0 :       int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__lessT_int_t, 0);
   18842           0 :       _v = SWIG_CheckState(res);
   18843             :     }
   18844           0 :     if (!_v) goto check_2;
   18845           0 :     return _wrap_new_IntPluginSpecMap__SWIG_0(nargs, args, self);
   18846             :   }
   18847             : check_2:
   18848             :   
   18849           0 :   if (argc == 1) {
   18850           0 :     return _wrap_new_IntPluginSpecMap__SWIG_2(nargs, args, self);
   18851             :   }
   18852             :   
   18853             : fail:
   18854             :   Ruby_Format_OverloadedError( argc, 1, "IntPluginSpecMap.new", 
   18855             :     "    IntPluginSpecMap.new(std::less< int > const &)\n"
   18856             :     "    IntPluginSpecMap.new()\n"
   18857           0 :     "    IntPluginSpecMap.new(std::map< int,kdb::tools::PluginSpec > const &)\n");
   18858             :   
   18859             :   return Qnil;
   18860             : }
   18861             : 
   18862             : 
   18863             : 
   18864             : /*
   18865             :   Document-method: Kdbtools::IntPluginSpecMap.empty
   18866             : 
   18867             :   call-seq:
   18868             :     empty -> bool
   18869             : 
   18870             : Check if the IntPluginSpecMap is empty or not.
   18871             : */
   18872             : SWIGINTERN VALUE
   18873           0 : _wrap_IntPluginSpecMap_empty(int argc, VALUE *argv, VALUE self) {
   18874           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18875           0 :   void *argp1 = 0 ;
   18876           0 :   int res1 = 0 ;
   18877             :   bool result;
   18878           0 :   VALUE vresult = Qnil;
   18879             :   
   18880           0 :   if ((argc < 0) || (argc > 0)) {
   18881           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18882             :   }
   18883           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18884           0 :   if (!SWIG_IsOK(res1)) {
   18885           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > const *","empty", 1, self )); 
   18886             :   }
   18887           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18888           0 :   result = (bool)((std::map< int,kdb::tools::PluginSpec > const *)arg1)->empty();
   18889           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   18890             :   return vresult;
   18891             : fail:
   18892             :   return Qnil;
   18893             : }
   18894             : 
   18895             : 
   18896             : 
   18897             : /*
   18898             :   Document-method: Kdbtools::IntPluginSpecMap.size
   18899             : 
   18900             :   call-seq:
   18901             :     size -> std::map< int,kdb::tools::PluginSpec >::size_type
   18902             : 
   18903             : Size or Length of the IntPluginSpecMap.
   18904             : */
   18905             : SWIGINTERN VALUE
   18906           0 : _wrap_IntPluginSpecMap_size(int argc, VALUE *argv, VALUE self) {
   18907           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18908           0 :   void *argp1 = 0 ;
   18909           0 :   int res1 = 0 ;
   18910             :   std::map< int,kdb::tools::PluginSpec >::size_type result;
   18911           0 :   VALUE vresult = Qnil;
   18912             :   
   18913           0 :   if ((argc < 0) || (argc > 0)) {
   18914           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18915             :   }
   18916           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18917           0 :   if (!SWIG_IsOK(res1)) {
   18918           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > const *","size", 1, self )); 
   18919             :   }
   18920           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18921           0 :   result = ((std::map< int,kdb::tools::PluginSpec > const *)arg1)->size();
   18922           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
   18923             :   return vresult;
   18924             : fail:
   18925             :   return Qnil;
   18926             : }
   18927             : 
   18928             : 
   18929             : 
   18930             : /*
   18931             :   Document-method: Kdbtools::IntPluginSpecMap.swap
   18932             : 
   18933             :   call-seq:
   18934             :     swap(IntPluginSpecMap v)
   18935             : 
   18936             : An instance method.
   18937             : 
   18938             : */
   18939             : SWIGINTERN VALUE
   18940           0 : _wrap_IntPluginSpecMap_swap(int argc, VALUE *argv, VALUE self) {
   18941           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18942           0 :   std::map< int,kdb::tools::PluginSpec > *arg2 = 0 ;
   18943           0 :   void *argp1 = 0 ;
   18944           0 :   int res1 = 0 ;
   18945           0 :   void *argp2 = 0 ;
   18946           0 :   int res2 = 0 ;
   18947             :   
   18948           0 :   if ((argc < 1) || (argc > 1)) {
   18949           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   18950             :   }
   18951           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18952           0 :   if (!SWIG_IsOK(res1)) {
   18953           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","swap", 1, self )); 
   18954             :   }
   18955           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18956           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t,  0 );
   18957           0 :   if (!SWIG_IsOK(res2)) {
   18958           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > &","swap", 2, argv[0] )); 
   18959             :   }
   18960           0 :   if (!argp2) {
   18961           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< int,kdb::tools::PluginSpec > &","swap", 2, argv[0])); 
   18962             :   }
   18963           0 :   arg2 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp2);
   18964           0 :   (arg1)->swap(*arg2);
   18965             :   return Qnil;
   18966             : fail:
   18967             :   return Qnil;
   18968             : }
   18969             : 
   18970             : 
   18971             : 
   18972             : /*
   18973             :   Document-method: Kdbtools::IntPluginSpecMap.clear
   18974             : 
   18975             :   call-seq:
   18976             :     clear
   18977             : 
   18978             : Clear IntPluginSpecMap contents.
   18979             : */
   18980             : SWIGINTERN VALUE
   18981           0 : _wrap_IntPluginSpecMap_clear(int argc, VALUE *argv, VALUE self) {
   18982           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   18983           0 :   void *argp1 = 0 ;
   18984           0 :   int res1 = 0 ;
   18985             :   
   18986           0 :   if ((argc < 0) || (argc > 0)) {
   18987           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   18988             :   }
   18989           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   18990           0 :   if (!SWIG_IsOK(res1)) {
   18991           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","clear", 1, self )); 
   18992             :   }
   18993           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   18994           0 :   (arg1)->clear();
   18995             :   return Qnil;
   18996             : fail:
   18997             :   return Qnil;
   18998             : }
   18999             : 
   19000             : 
   19001             : 
   19002             : /*
   19003             :   Document-method: Kdbtools::IntPluginSpecMap.get_allocator
   19004             : 
   19005             :   call-seq:
   19006             :     get_allocator -> std::map< int,kdb::tools::PluginSpec >::allocator_type
   19007             : 
   19008             : An instance method.
   19009             : 
   19010             : */
   19011             : SWIGINTERN VALUE
   19012           0 : _wrap_IntPluginSpecMap_get_allocator(int argc, VALUE *argv, VALUE self) {
   19013           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   19014           0 :   void *argp1 = 0 ;
   19015           0 :   int res1 = 0 ;
   19016           0 :   SwigValueWrapper< std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > result;
   19017           0 :   VALUE vresult = Qnil;
   19018             :   
   19019           0 :   if ((argc < 0) || (argc > 0)) {
   19020           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   19021             :   }
   19022           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   19023           0 :   if (!SWIG_IsOK(res1)) {
   19024           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > const *","get_allocator", 1, self )); 
   19025             :   }
   19026           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   19027           0 :   result = ((std::map< int,kdb::tools::PluginSpec > const *)arg1)->get_allocator();
   19028           0 :   vresult = SWIG_NewPointerObj((new std::map< int,kdb::tools::PluginSpec >::allocator_type(static_cast< const std::map< int,kdb::tools::PluginSpec >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t, SWIG_POINTER_OWN |  0 );
   19029           0 :   return vresult;
   19030             : fail:
   19031             :   return Qnil;
   19032             : }
   19033             : 
   19034             : 
   19035             : 
   19036             : /*
   19037             :   Document-method: Kdbtools::IntPluginSpecMap.erase
   19038             : 
   19039             :   call-seq:
   19040             :     erase(x) -> std::map< int,kdb::tools::PluginSpec >::size_type
   19041             : 
   19042             : Delete a portion of the IntPluginSpecMap.
   19043             : */
   19044             : SWIGINTERN VALUE
   19045           0 : _wrap_IntPluginSpecMap_erase(int argc, VALUE *argv, VALUE self) {
   19046           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   19047           0 :   std::map< int,kdb::tools::PluginSpec >::key_type *arg2 = 0 ;
   19048           0 :   void *argp1 = 0 ;
   19049           0 :   int res1 = 0 ;
   19050             :   std::map< int,kdb::tools::PluginSpec >::key_type temp2 ;
   19051             :   int val2 ;
   19052           0 :   int ecode2 = 0 ;
   19053             :   std::map< int,kdb::tools::PluginSpec >::size_type result;
   19054           0 :   VALUE vresult = Qnil;
   19055             :   
   19056           0 :   if ((argc < 1) || (argc > 1)) {
   19057           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   19058             :   }
   19059           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   19060           0 :   if (!SWIG_IsOK(res1)) {
   19061           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > *","erase", 1, self )); 
   19062             :   }
   19063           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   19064           0 :   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   19065           0 :   if (!SWIG_IsOK(ecode2)) {
   19066           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec >::key_type","erase", 2, argv[0] ));
   19067             :   } 
   19068           0 :   temp2 = static_cast< std::map< int,kdb::tools::PluginSpec >::key_type >(val2);
   19069           0 :   arg2 = &temp2;
   19070           0 :   result = (arg1)->erase((std::map< int,kdb::tools::PluginSpec >::key_type const &)*arg2);
   19071           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
   19072             :   return vresult;
   19073             : fail:
   19074             :   return Qnil;
   19075             : }
   19076             : 
   19077             : 
   19078             : 
   19079             : /*
   19080             :   Document-method: Kdbtools::IntPluginSpecMap.count
   19081             : 
   19082             :   call-seq:
   19083             :     count(std::map< int,kdb::tools::PluginSpec >::key_type const & x) -> std::map< int,kdb::tools::PluginSpec >::size_type
   19084             : 
   19085             : An instance method.
   19086             : 
   19087             : */
   19088             : SWIGINTERN VALUE
   19089           0 : _wrap_IntPluginSpecMap_count(int argc, VALUE *argv, VALUE self) {
   19090           0 :   std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *) 0 ;
   19091           0 :   std::map< int,kdb::tools::PluginSpec >::key_type *arg2 = 0 ;
   19092           0 :   void *argp1 = 0 ;
   19093           0 :   int res1 = 0 ;
   19094             :   std::map< int,kdb::tools::PluginSpec >::key_type temp2 ;
   19095             :   int val2 ;
   19096           0 :   int ecode2 = 0 ;
   19097             :   std::map< int,kdb::tools::PluginSpec >::size_type result;
   19098           0 :   VALUE vresult = Qnil;
   19099             :   
   19100           0 :   if ((argc < 1) || (argc > 1)) {
   19101           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   19102             :   }
   19103           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0 |  0 );
   19104           0 :   if (!SWIG_IsOK(res1)) {
   19105           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec > const *","count", 1, self )); 
   19106             :   }
   19107           0 :   arg1 = reinterpret_cast< std::map< int,kdb::tools::PluginSpec > * >(argp1);
   19108           0 :   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   19109           0 :   if (!SWIG_IsOK(ecode2)) {
   19110           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::map< int,kdb::tools::PluginSpec >::key_type","count", 2, argv[0] ));
   19111             :   } 
   19112           0 :   temp2 = static_cast< std::map< int,kdb::tools::PluginSpec >::key_type >(val2);
   19113           0 :   arg2 = &temp2;
   19114           0 :   result = ((std::map< int,kdb::tools::PluginSpec > const *)arg1)->count((std::map< int,kdb::tools::PluginSpec >::key_type const &)*arg2);
   19115           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
   19116             :   return vresult;
   19117             : fail:
   19118             :   return Qnil;
   19119             : }
   19120             : 
   19121             : 
   19122             : SWIGINTERN void
   19123           1 : free_std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg_(void *self) {
   19124           1 :     std::map< int,kdb::tools::PluginSpec > *arg1 = (std::map< int,kdb::tools::PluginSpec > *)self;
   19125           2 :     delete arg1;
   19126           1 : }
   19127             : 
   19128             : 
   19129             : /*
   19130             :   Document-class: Kdbtools::PluginDatabase
   19131             : 
   19132             :   Proxy of C++ Kdbtools::PluginDatabase class
   19133             : 
   19134             : 
   19135             : */
   19136             : static swig_class SwigClassPluginDatabase;
   19137             : 
   19138             : 
   19139             : /*
   19140             :   Document-method: Kdbtools::PluginDatabase.list_all_plugins
   19141             : 
   19142             :   call-seq:
   19143             :     list_all_plugins -> VectorStr
   19144             : 
   19145             : An instance method.
   19146             : 
   19147             : */
   19148             : SWIGINTERN VALUE
   19149           3 : _wrap_PluginDatabase_list_all_plugins(int argc, VALUE *argv, VALUE self) {
   19150           3 :   kdb::tools::PluginDatabase *arg1 = (kdb::tools::PluginDatabase *) 0 ;
   19151           3 :   void *argp1 = 0 ;
   19152           3 :   int res1 = 0 ;
   19153           6 :   std::shared_ptr< kdb::tools::PluginDatabase const > tempshared1 ;
   19154           3 :   std::shared_ptr< kdb::tools::PluginDatabase const > *smartarg1 = 0 ;
   19155           6 :   std::vector< std::string,std::allocator< std::string > > result;
   19156           3 :   VALUE vresult = Qnil;
   19157             :   
   19158           3 :   if ((argc < 0) || (argc > 0)) {
   19159           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   19160             :   }
   19161             :   {
   19162             :     swig_ruby_owntype newmem = {
   19163             :       0, 0
   19164           3 :     };
   19165           3 :     res1 = SWIG_ConvertPtrAndOwn(self, &argp1, SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, 0 |  0 , &newmem);
   19166           3 :     if (!SWIG_IsOK(res1)) {
   19167           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginDatabase const *","listAllPlugins", 1, self ));
   19168             :     }
   19169           3 :     if (newmem.own & SWIG_CAST_NEW_MEMORY) {
   19170           4 :       tempshared1 = *reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19171           4 :       delete reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19172           2 :       arg1 = const_cast< kdb::tools::PluginDatabase * >(tempshared1.get());
   19173             :     } else {
   19174           1 :       smartarg1 = reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19175           1 :       arg1 = const_cast< kdb::tools::PluginDatabase * >((smartarg1 ? smartarg1->get() : 0));
   19176             :     }
   19177             :   }
   19178             :   try {
   19179           6 :     result = ((kdb::tools::PluginDatabase const *)arg1)->listAllPlugins();
   19180             :   }
   19181           0 :   catch(kdb::tools::ToolException &_e) {
   19182           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   19183             :   }
   19184             :   
   19185           6 :   vresult = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
   19186             :   return vresult;
   19187             : fail:
   19188             :   return Qnil;
   19189             : }
   19190             : 
   19191             : 
   19192             : 
   19193             : /*
   19194             :   Document-method: Kdbtools::Status.Provides
   19195             : 
   19196             :   call-seq:
   19197             :     Provides -> int
   19198             : 
   19199             : A class method.
   19200             : 
   19201             : */
   19202             : 
   19203             : /*
   19204             :   Document-method: Kdbtools::Status.Real
   19205             : 
   19206             :   call-seq:
   19207             :     Real -> int
   19208             : 
   19209             : A class method.
   19210             : 
   19211             : */
   19212             : 
   19213             : /*
   19214             :   Document-method: Kdbtools::Status.Missing
   19215             : 
   19216             :   call-seq:
   19217             :     Missing -> int
   19218             : 
   19219             : A class method.
   19220             : 
   19221             : */
   19222             : 
   19223             : /*
   19224             :   Document-method: Kdbtools::PluginDatabase.status
   19225             : 
   19226             :   call-seq:
   19227             :     status(PluginSpec whichplugin) -> int
   19228             : 
   19229             : An instance method.
   19230             : 
   19231             : */
   19232             : SWIGINTERN VALUE
   19233           1 : _wrap_PluginDatabase_status(int argc, VALUE *argv, VALUE self) {
   19234           1 :   kdb::tools::PluginDatabase *arg1 = (kdb::tools::PluginDatabase *) 0 ;
   19235           1 :   kdb::tools::PluginSpec *arg2 = 0 ;
   19236           1 :   void *argp1 = 0 ;
   19237           1 :   int res1 = 0 ;
   19238           2 :   std::shared_ptr< kdb::tools::PluginDatabase const > tempshared1 ;
   19239           1 :   std::shared_ptr< kdb::tools::PluginDatabase const > *smartarg1 = 0 ;
   19240             :   void *argp2 ;
   19241           1 :   int res2 = 0 ;
   19242             :   kdb::tools::PluginDatabase::Status result;
   19243           1 :   VALUE vresult = Qnil;
   19244             :   
   19245           1 :   if ((argc < 1) || (argc > 1)) {
   19246           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   19247             :   }
   19248             :   {
   19249             :     swig_ruby_owntype newmem = {
   19250             :       0, 0
   19251           1 :     };
   19252           1 :     res1 = SWIG_ConvertPtrAndOwn(self, &argp1, SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, 0 |  0 , &newmem);
   19253           1 :     if (!SWIG_IsOK(res1)) {
   19254           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginDatabase const *","status", 1, self ));
   19255             :     }
   19256           1 :     if (newmem.own & SWIG_CAST_NEW_MEMORY) {
   19257           2 :       tempshared1 = *reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19258           2 :       delete reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19259           1 :       arg1 = const_cast< kdb::tools::PluginDatabase * >(tempshared1.get());
   19260             :     } else {
   19261           0 :       smartarg1 = reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19262           0 :       arg1 = const_cast< kdb::tools::PluginDatabase * >((smartarg1 ? smartarg1->get() : 0));
   19263             :     }
   19264             :   }
   19265           1 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   19266           1 :   if (!SWIG_IsOK(res2)) {
   19267           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","status", 2, argv[0] )); 
   19268             :   }
   19269           1 :   if (!argp2) {
   19270           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","status", 2, argv[0])); 
   19271             :   }
   19272           1 :   arg2 = reinterpret_cast< kdb::tools::PluginSpec * >(argp2);
   19273           1 :   result = (kdb::tools::PluginDatabase::Status)((kdb::tools::PluginDatabase const *)arg1)->status((kdb::tools::PluginSpec const &)*arg2);
   19274           2 :   vresult = SWIG_From_int(static_cast< int >(result));
   19275           1 :   return vresult;
   19276             : fail:
   19277             :   return Qnil;
   19278             : }
   19279             : 
   19280             : 
   19281             : 
   19282             : /*
   19283             :   Document-method: Kdbtools::PluginDatabase.lookup_info
   19284             : 
   19285             :   call-seq:
   19286             :     lookup_info(PluginSpec whichplugin, std::string const & which) -> std::string
   19287             : 
   19288             : An instance method.
   19289             : 
   19290             : */
   19291             : SWIGINTERN VALUE
   19292           0 : _wrap_PluginDatabase_lookup_info(int argc, VALUE *argv, VALUE self) {
   19293           0 :   kdb::tools::PluginDatabase *arg1 = (kdb::tools::PluginDatabase *) 0 ;
   19294           0 :   kdb::tools::PluginSpec *arg2 = 0 ;
   19295           0 :   std::string *arg3 = 0 ;
   19296           0 :   void *argp1 = 0 ;
   19297           0 :   int res1 = 0 ;
   19298           0 :   std::shared_ptr< kdb::tools::PluginDatabase const > tempshared1 ;
   19299           0 :   std::shared_ptr< kdb::tools::PluginDatabase const > *smartarg1 = 0 ;
   19300             :   void *argp2 ;
   19301           0 :   int res2 = 0 ;
   19302           0 :   int res3 = SWIG_OLDOBJ ;
   19303           0 :   std::string result;
   19304           0 :   VALUE vresult = Qnil;
   19305             :   
   19306           0 :   if ((argc < 2) || (argc > 2)) {
   19307           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   19308             :   }
   19309             :   {
   19310             :     swig_ruby_owntype newmem = {
   19311             :       0, 0
   19312           0 :     };
   19313           0 :     res1 = SWIG_ConvertPtrAndOwn(self, &argp1, SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, 0 |  0 , &newmem);
   19314           0 :     if (!SWIG_IsOK(res1)) {
   19315           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginDatabase const *","lookupInfo", 1, self ));
   19316             :     }
   19317           0 :     if (newmem.own & SWIG_CAST_NEW_MEMORY) {
   19318           0 :       tempshared1 = *reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19319           0 :       delete reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19320           0 :       arg1 = const_cast< kdb::tools::PluginDatabase * >(tempshared1.get());
   19321             :     } else {
   19322           0 :       smartarg1 = reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19323           0 :       arg1 = const_cast< kdb::tools::PluginDatabase * >((smartarg1 ? smartarg1->get() : 0));
   19324             :     }
   19325             :   }
   19326           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   19327           0 :   if (!SWIG_IsOK(res2)) {
   19328           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","lookupInfo", 2, argv[0] )); 
   19329             :   }
   19330           0 :   if (!argp2) {
   19331           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","lookupInfo", 2, argv[0])); 
   19332             :   }
   19333           0 :   arg2 = reinterpret_cast< kdb::tools::PluginSpec * >(argp2);
   19334             :   {
   19335           0 :     std::string *ptr = (std::string *)0;
   19336           0 :     res3 = SWIG_AsPtr_std_string(argv[1], &ptr);
   19337           0 :     if (!SWIG_IsOK(res3)) {
   19338           0 :       SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::string const &","lookupInfo", 3, argv[1] )); 
   19339             :     }
   19340           0 :     if (!ptr) {
   19341           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","lookupInfo", 3, argv[1])); 
   19342             :     }
   19343           0 :     arg3 = ptr;
   19344             :   }
   19345             :   try {
   19346           0 :     result = ((kdb::tools::PluginDatabase const *)arg1)->lookupInfo((kdb::tools::PluginSpec const &)*arg2,(std::string const &)*arg3);
   19347             :   }
   19348           0 :   catch(kdb::tools::ToolException &_e) {
   19349           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   19350             :   }
   19351             :   
   19352           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   19353           0 :   if (SWIG_IsNewObj(res3)) delete arg3;
   19354           0 :   return vresult;
   19355             : fail:
   19356             :   if (SWIG_IsNewObj(res3)) delete arg3;
   19357             :   return Qnil;
   19358             : }
   19359             : 
   19360             : 
   19361             : 
   19362             : /*
   19363             :   Document-method: Kdbtools::PluginDatabase.lookup_metadata
   19364             : 
   19365             :   call-seq:
   19366             :     lookup_metadata(std::string const & which) -> PluginSpec
   19367             : 
   19368             : An instance method.
   19369             : 
   19370             : */
   19371             : SWIGINTERN VALUE
   19372           0 : _wrap_PluginDatabase_lookup_metadata(int argc, VALUE *argv, VALUE self) {
   19373           0 :   kdb::tools::PluginDatabase *arg1 = (kdb::tools::PluginDatabase *) 0 ;
   19374           0 :   std::string *arg2 = 0 ;
   19375           0 :   void *argp1 = 0 ;
   19376           0 :   int res1 = 0 ;
   19377           0 :   std::shared_ptr< kdb::tools::PluginDatabase const > tempshared1 ;
   19378           0 :   std::shared_ptr< kdb::tools::PluginDatabase const > *smartarg1 = 0 ;
   19379           0 :   int res2 = SWIG_OLDOBJ ;
   19380           0 :   kdb::tools::PluginSpec result;
   19381           0 :   VALUE vresult = Qnil;
   19382             :   
   19383           0 :   if ((argc < 1) || (argc > 1)) {
   19384           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   19385             :   }
   19386             :   {
   19387             :     swig_ruby_owntype newmem = {
   19388             :       0, 0
   19389           0 :     };
   19390           0 :     res1 = SWIG_ConvertPtrAndOwn(self, &argp1, SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, 0 |  0 , &newmem);
   19391           0 :     if (!SWIG_IsOK(res1)) {
   19392           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginDatabase const *","lookupMetadata", 1, self ));
   19393             :     }
   19394           0 :     if (newmem.own & SWIG_CAST_NEW_MEMORY) {
   19395           0 :       tempshared1 = *reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19396           0 :       delete reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19397           0 :       arg1 = const_cast< kdb::tools::PluginDatabase * >(tempshared1.get());
   19398             :     } else {
   19399           0 :       smartarg1 = reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19400           0 :       arg1 = const_cast< kdb::tools::PluginDatabase * >((smartarg1 ? smartarg1->get() : 0));
   19401             :     }
   19402             :   }
   19403             :   {
   19404           0 :     std::string *ptr = (std::string *)0;
   19405           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   19406           0 :     if (!SWIG_IsOK(res2)) {
   19407           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","lookupMetadata", 2, argv[0] )); 
   19408             :     }
   19409           0 :     if (!ptr) {
   19410           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","lookupMetadata", 2, argv[0])); 
   19411             :     }
   19412           0 :     arg2 = ptr;
   19413             :   }
   19414             :   try {
   19415           0 :     result = ((kdb::tools::PluginDatabase const *)arg1)->lookupMetadata((std::string const &)*arg2);
   19416             :   }
   19417           0 :   catch(kdb::tools::NoPlugin &_e) {
   19418           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__NoPlugin, SWIG_NewPointerObj((new kdb::tools::NoPlugin(static_cast< const kdb::tools::NoPlugin& >(_e))),SWIGTYPE_p_kdb__tools__NoPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   19419             :   }
   19420           0 :   catch(kdb::tools::PluginCheckException &_e) {
   19421           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   19422             :   }
   19423           0 :   catch(kdb::tools::ToolException &_e) {
   19424           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   19425             :   }
   19426             :   
   19427           0 :   vresult = SWIG_NewPointerObj((new kdb::tools::PluginSpec(static_cast< const kdb::tools::PluginSpec& >(result))), SWIGTYPE_p_kdb__tools__PluginSpec, SWIG_POINTER_OWN |  0 );
   19428           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   19429             :   return vresult;
   19430             : fail:
   19431             :   if (SWIG_IsNewObj(res2)) delete arg2;
   19432             :   return Qnil;
   19433             : }
   19434             : 
   19435             : 
   19436             : 
   19437             : /*
   19438             :   Document-method: Kdbtools::PluginDatabase.lookup_provides
   19439             : 
   19440             :   call-seq:
   19441             :     lookup_provides(std::string const & provides) -> PluginSpec
   19442             : 
   19443             : An instance method.
   19444             : 
   19445             : */
   19446             : SWIGINTERN VALUE
   19447           1 : _wrap_PluginDatabase_lookup_provides(int argc, VALUE *argv, VALUE self) {
   19448           1 :   kdb::tools::PluginDatabase *arg1 = (kdb::tools::PluginDatabase *) 0 ;
   19449           1 :   std::string *arg2 = 0 ;
   19450           1 :   void *argp1 = 0 ;
   19451           1 :   int res1 = 0 ;
   19452           2 :   std::shared_ptr< kdb::tools::PluginDatabase const > tempshared1 ;
   19453           1 :   std::shared_ptr< kdb::tools::PluginDatabase const > *smartarg1 = 0 ;
   19454           1 :   int res2 = SWIG_OLDOBJ ;
   19455           2 :   kdb::tools::PluginSpec result;
   19456           1 :   VALUE vresult = Qnil;
   19457             :   
   19458           1 :   if ((argc < 1) || (argc > 1)) {
   19459           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   19460             :   }
   19461             :   {
   19462             :     swig_ruby_owntype newmem = {
   19463             :       0, 0
   19464           1 :     };
   19465           1 :     res1 = SWIG_ConvertPtrAndOwn(self, &argp1, SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, 0 |  0 , &newmem);
   19466           1 :     if (!SWIG_IsOK(res1)) {
   19467           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginDatabase const *","lookupProvides", 1, self ));
   19468             :     }
   19469           1 :     if (newmem.own & SWIG_CAST_NEW_MEMORY) {
   19470           2 :       tempshared1 = *reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19471           2 :       delete reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19472           1 :       arg1 = const_cast< kdb::tools::PluginDatabase * >(tempshared1.get());
   19473             :     } else {
   19474           0 :       smartarg1 = reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19475           0 :       arg1 = const_cast< kdb::tools::PluginDatabase * >((smartarg1 ? smartarg1->get() : 0));
   19476             :     }
   19477             :   }
   19478             :   {
   19479           1 :     std::string *ptr = (std::string *)0;
   19480           1 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   19481           1 :     if (!SWIG_IsOK(res2)) {
   19482           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","lookupProvides", 2, argv[0] )); 
   19483             :     }
   19484           1 :     if (!ptr) {
   19485           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","lookupProvides", 2, argv[0])); 
   19486             :     }
   19487           1 :     arg2 = ptr;
   19488             :   }
   19489             :   try {
   19490           1 :     result = ((kdb::tools::PluginDatabase const *)arg1)->lookupProvides((std::string const &)*arg2);
   19491             :   }
   19492           0 :   catch(kdb::tools::ToolException &_e) {
   19493           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   19494             :   }
   19495             :   
   19496           1 :   vresult = SWIG_NewPointerObj((new kdb::tools::PluginSpec(static_cast< const kdb::tools::PluginSpec& >(result))), SWIGTYPE_p_kdb__tools__PluginSpec, SWIG_POINTER_OWN |  0 );
   19497           2 :   if (SWIG_IsNewObj(res2)) delete arg2;
   19498             :   return vresult;
   19499             : fail:
   19500             :   if (SWIG_IsNewObj(res2)) delete arg2;
   19501             :   return Qnil;
   19502             : }
   19503             : 
   19504             : 
   19505             : 
   19506             : /*
   19507             :   Document-method: Kdbtools::PluginDatabase.lookup_all_provides_with_status
   19508             : 
   19509             :   call-seq:
   19510             :     lookup_all_provides_with_status(std::string const & provides) -> IntPluginSpecMap
   19511             : 
   19512             : An instance method.
   19513             : 
   19514             : */
   19515             : SWIGINTERN VALUE
   19516           1 : _wrap_PluginDatabase_lookup_all_provides_with_status(int argc, VALUE *argv, VALUE self) {
   19517           1 :   kdb::tools::PluginDatabase *arg1 = (kdb::tools::PluginDatabase *) 0 ;
   19518           1 :   std::string *arg2 = 0 ;
   19519           1 :   void *argp1 = 0 ;
   19520           1 :   int res1 = 0 ;
   19521           2 :   std::shared_ptr< kdb::tools::PluginDatabase const > tempshared1 ;
   19522           1 :   std::shared_ptr< kdb::tools::PluginDatabase const > *smartarg1 = 0 ;
   19523           1 :   int res2 = SWIG_OLDOBJ ;
   19524           2 :   std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > result;
   19525           1 :   VALUE vresult = Qnil;
   19526             :   
   19527           1 :   if ((argc < 1) || (argc > 1)) {
   19528           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   19529             :   }
   19530             :   {
   19531             :     swig_ruby_owntype newmem = {
   19532             :       0, 0
   19533           1 :     };
   19534           1 :     res1 = SWIG_ConvertPtrAndOwn(self, &argp1, SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, 0 |  0 , &newmem);
   19535           1 :     if (!SWIG_IsOK(res1)) {
   19536           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginDatabase const *","lookupAllProvidesWithStatus", 1, self ));
   19537             :     }
   19538           1 :     if (newmem.own & SWIG_CAST_NEW_MEMORY) {
   19539           2 :       tempshared1 = *reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19540           2 :       delete reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19541           1 :       arg1 = const_cast< kdb::tools::PluginDatabase * >(tempshared1.get());
   19542             :     } else {
   19543           0 :       smartarg1 = reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19544           0 :       arg1 = const_cast< kdb::tools::PluginDatabase * >((smartarg1 ? smartarg1->get() : 0));
   19545             :     }
   19546             :   }
   19547             :   {
   19548           1 :     std::string *ptr = (std::string *)0;
   19549           1 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   19550           1 :     if (!SWIG_IsOK(res2)) {
   19551           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","lookupAllProvidesWithStatus", 2, argv[0] )); 
   19552             :     }
   19553           1 :     if (!ptr) {
   19554           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","lookupAllProvidesWithStatus", 2, argv[0])); 
   19555             :     }
   19556           1 :     arg2 = ptr;
   19557             :   }
   19558             :   try {
   19559           3 :     result = ((kdb::tools::PluginDatabase const *)arg1)->lookupAllProvidesWithStatus((std::string const &)*arg2);
   19560             :   }
   19561           0 :   catch(kdb::tools::ToolException &_e) {
   19562           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   19563             :   }
   19564             :   
   19565           3 :   vresult = swig::from(static_cast< std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > >(result));
   19566           2 :   if (SWIG_IsNewObj(res2)) delete arg2;
   19567           1 :   return vresult;
   19568             : fail:
   19569             :   if (SWIG_IsNewObj(res2)) delete arg2;
   19570             :   return Qnil;
   19571             : }
   19572             : 
   19573             : 
   19574             : 
   19575             : /*
   19576             :   Document-method: Kdbtools::PluginDatabase.lookup_all_provides
   19577             : 
   19578             :   call-seq:
   19579             :     lookup_all_provides(std::string const & provides) -> PluginSpecVector
   19580             : 
   19581             : An instance method.
   19582             : 
   19583             : */
   19584             : SWIGINTERN VALUE
   19585           1 : _wrap_PluginDatabase_lookup_all_provides(int argc, VALUE *argv, VALUE self) {
   19586           1 :   kdb::tools::PluginDatabase *arg1 = (kdb::tools::PluginDatabase *) 0 ;
   19587           1 :   std::string *arg2 = 0 ;
   19588           1 :   void *argp1 = 0 ;
   19589           1 :   int res1 = 0 ;
   19590           2 :   std::shared_ptr< kdb::tools::PluginDatabase const > tempshared1 ;
   19591           1 :   std::shared_ptr< kdb::tools::PluginDatabase const > *smartarg1 = 0 ;
   19592           1 :   int res2 = SWIG_OLDOBJ ;
   19593           2 :   std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > result;
   19594           1 :   VALUE vresult = Qnil;
   19595             :   
   19596           1 :   if ((argc < 1) || (argc > 1)) {
   19597           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   19598             :   }
   19599             :   {
   19600             :     swig_ruby_owntype newmem = {
   19601             :       0, 0
   19602           1 :     };
   19603           1 :     res1 = SWIG_ConvertPtrAndOwn(self, &argp1, SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, 0 |  0 , &newmem);
   19604           1 :     if (!SWIG_IsOK(res1)) {
   19605           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginDatabase const *","lookupAllProvides", 1, self ));
   19606             :     }
   19607           1 :     if (newmem.own & SWIG_CAST_NEW_MEMORY) {
   19608           2 :       tempshared1 = *reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19609           2 :       delete reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19610           1 :       arg1 = const_cast< kdb::tools::PluginDatabase * >(tempshared1.get());
   19611             :     } else {
   19612           0 :       smartarg1 = reinterpret_cast< std::shared_ptr< const kdb::tools::PluginDatabase > * >(argp1);
   19613           0 :       arg1 = const_cast< kdb::tools::PluginDatabase * >((smartarg1 ? smartarg1->get() : 0));
   19614             :     }
   19615             :   }
   19616             :   {
   19617           1 :     std::string *ptr = (std::string *)0;
   19618           1 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   19619           1 :     if (!SWIG_IsOK(res2)) {
   19620           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","lookupAllProvides", 2, argv[0] )); 
   19621             :     }
   19622           1 :     if (!ptr) {
   19623           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","lookupAllProvides", 2, argv[0])); 
   19624             :     }
   19625           1 :     arg2 = ptr;
   19626             :   }
   19627             :   try {
   19628           2 :     result = ((kdb::tools::PluginDatabase const *)arg1)->lookupAllProvides((std::string const &)*arg2);
   19629             :   }
   19630           0 :   catch(kdb::tools::ToolException &_e) {
   19631           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   19632             :   }
   19633             :   
   19634           2 :   vresult = swig::from(static_cast< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > >(result));
   19635           2 :   if (SWIG_IsNewObj(res2)) delete arg2;
   19636             :   return vresult;
   19637             : fail:
   19638             :   if (SWIG_IsNewObj(res2)) delete arg2;
   19639             :   return Qnil;
   19640             : }
   19641             : 
   19642             : 
   19643             : 
   19644             : /*
   19645             :   Document-method: Kdbtools::PluginDatabase.calculate_status
   19646             : 
   19647             :   call-seq:
   19648             :     calculate_status(std::string statusString) -> int
   19649             : 
   19650             : A class method.
   19651             : 
   19652             : */
   19653             : SWIGINTERN VALUE
   19654           0 : _wrap_PluginDatabase_calculate_status(int argc, VALUE *argv, VALUE self) {
   19655           0 :   std::string arg1 ;
   19656             :   int result;
   19657           0 :   VALUE vresult = Qnil;
   19658             :   
   19659           0 :   if ((argc < 1) || (argc > 1)) {
   19660           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   19661             :   }
   19662             :   {
   19663           0 :     std::string *ptr = (std::string *)0;
   19664           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   19665           0 :     if (!SWIG_IsOK(res) || !ptr) {
   19666           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","kdb::tools::PluginDatabase::calculateStatus", 1, argv[0] )); 
   19667             :     }
   19668           0 :     arg1 = *ptr;
   19669           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   19670             :   }
   19671             :   try {
   19672           0 :     result = (int)kdb::tools::PluginDatabase::calculateStatus(arg1);
   19673             :   }
   19674           0 :   catch(kdb::tools::ToolException &_e) {
   19675           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   19676             :   }
   19677             :   
   19678           0 :   vresult = SWIG_From_int(static_cast< int >(result));
   19679           0 :   return vresult;
   19680             : fail:
   19681             :   return Qnil;
   19682             : }
   19683             : 
   19684             : 
   19685             : 
   19686             : /*
   19687             :   Document-method: Kdbtools::PluginDatabase.statusMap
   19688             : 
   19689             :   call-seq:
   19690             :     statusMap -> std::map< std::string,int,std::less< std::string >,std::allocator< std::pair< std::string const,int > > > const
   19691             : 
   19692             : Get value of attribute.
   19693             : 
   19694             : */
   19695             : 
   19696             : /*
   19697             :   Document-method: Kdbtools::PluginDatabase.PluginDatabase_statusMap
   19698             : 
   19699             :   call-seq:
   19700             :     PluginDatabase_statusMap -> std::map< std::string,int,std::less< std::string >,std::allocator< std::pair< std::string const,int > > > const
   19701             : 
   19702             : Get value of attribute.
   19703             : 
   19704             : */
   19705             : SWIGINTERN VALUE
   19706           0 : _wrap_PluginDatabase_statusMap_get(VALUE self) {
   19707             :   VALUE _val;
   19708             :   
   19709           0 :   _val = SWIG_NewPointerObj(SWIG_as_voidptr(&kdb::tools::PluginDatabase::statusMap), SWIGTYPE_p_std__mapT_std__string_int_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_int_t_t_t,  0 );
   19710           0 :   return _val;
   19711             : }
   19712             : 
   19713             : 
   19714             : SWIGINTERN void
   19715           1 : free_kdb_tools_PluginDatabase(void *self) {
   19716           1 :     kdb::tools::PluginDatabase *arg1 = (kdb::tools::PluginDatabase *)self;
   19717             :     (void)arg1;
   19718           2 :     delete reinterpret_cast< std::shared_ptr< kdb::tools::PluginDatabase > * >(self);
   19719           1 : }
   19720             : 
   19721             : 
   19722             : /*
   19723             :   Document-class: Kdbtools::ModulesPluginDatabase < Kdbtools::kdb::tools::PluginDatabase
   19724             : 
   19725             :   Proxy of C++ Kdbtools::ModulesPluginDatabase class
   19726             : 
   19727             : 
   19728             : */
   19729             : static swig_class SwigClassModulesPluginDatabase;
   19730             : 
   19731             : SWIGINTERN VALUE
   19732             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   19733           6 : _wrap_ModulesPluginDatabase_allocate(VALUE self)
   19734             : #else
   19735             : _wrap_ModulesPluginDatabase_allocate(int argc, VALUE *argv, VALUE self)
   19736             : #endif
   19737             : {
   19738           6 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t);
   19739             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   19740             :   rb_obj_call_init(vresult, argc, argv);
   19741             : #endif
   19742           6 :   return vresult;
   19743             : }
   19744             : 
   19745             : 
   19746             : 
   19747             : /*
   19748             :   Document-method: Kdbtools::ModulesPluginDatabase.new
   19749             : 
   19750             :   call-seq:
   19751             :     ModulesPluginDatabase.new
   19752             : 
   19753             : Class constructor.
   19754             : 
   19755             : */
   19756             : SWIGINTERN VALUE
   19757           6 : _wrap_new_ModulesPluginDatabase(int argc, VALUE *argv, VALUE self) {
   19758           6 :   std::shared_ptr< kdb::tools::ModulesPluginDatabase > *smartresult = 0;
   19759           6 :   kdb::tools::ModulesPluginDatabase *result = 0 ;
   19760             :   
   19761           6 :   if ((argc < 0) || (argc > 0)) {
   19762           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   19763             :   }
   19764           6 :   result = (kdb::tools::ModulesPluginDatabase *)new kdb::tools::ModulesPluginDatabase();
   19765          12 :   smartresult = new std::shared_ptr< kdb::tools::ModulesPluginDatabase >(result);
   19766           6 :   DATA_PTR(self) = smartresult;
   19767             :   return self;
   19768             : fail:
   19769             :   return Qnil;
   19770             : }
   19771             : 
   19772             : 
   19773             : SWIGINTERN void
   19774           6 : free_kdb_tools_ModulesPluginDatabase(void *self) {
   19775           6 :     kdb::tools::ModulesPluginDatabase *arg1 = (kdb::tools::ModulesPluginDatabase *)self;
   19776             :     (void)arg1;
   19777          12 :     delete reinterpret_cast< std::shared_ptr< kdb::tools::ModulesPluginDatabase > * >(self);
   19778           6 : }
   19779             : 
   19780             : 
   19781             : /*
   19782             :   Document-class: Kdbtools::PluginVariantDatabase < Kdbtools::kdb::tools::ModulesPluginDatabase
   19783             : 
   19784             :   Proxy of C++ Kdbtools::PluginVariantDatabase class
   19785             : 
   19786             : 
   19787             : */
   19788             : static swig_class SwigClassPluginVariantDatabase;
   19789             : 
   19790             : SWIGINTERN VALUE
   19791             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   19792           0 : _wrap_PluginVariantDatabase_allocate(VALUE self)
   19793             : #else
   19794             : _wrap_PluginVariantDatabase_allocate(int argc, VALUE *argv, VALUE self)
   19795             : #endif
   19796             : {
   19797           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t);
   19798             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   19799             :   rb_obj_call_init(vresult, argc, argv);
   19800             : #endif
   19801           0 :   return vresult;
   19802             : }
   19803             : 
   19804             : 
   19805             : 
   19806             : /*
   19807             :   Document-method: Kdbtools::PluginVariantDatabase.new
   19808             : 
   19809             :   call-seq:
   19810             :     PluginVariantDatabase.new(KeySet conf)
   19811             : 
   19812             : Class constructor.
   19813             : 
   19814             : */
   19815             : SWIGINTERN VALUE
   19816           0 : _wrap_new_PluginVariantDatabase(int argc, VALUE *argv, VALUE self) {
   19817           0 :   kdb::KeySet *arg1 = 0 ;
   19818             :   void *argp1 ;
   19819           0 :   int res1 = 0 ;
   19820           0 :   std::shared_ptr< kdb::tools::PluginVariantDatabase > *smartresult = 0;
   19821           0 :   kdb::tools::PluginVariantDatabase *result = 0 ;
   19822             :   
   19823           0 :   if ((argc < 1) || (argc > 1)) {
   19824           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   19825             :   }
   19826           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__KeySet,  0 );
   19827           0 :   if (!SWIG_IsOK(res1)) {
   19828           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::KeySet const &","PluginVariantDatabase", 1, argv[0] )); 
   19829             :   }
   19830           0 :   if (!argp1) {
   19831           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet const &","PluginVariantDatabase", 1, argv[0])); 
   19832             :   }
   19833           0 :   arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
   19834           0 :   result = (kdb::tools::PluginVariantDatabase *)new kdb::tools::PluginVariantDatabase((kdb::KeySet const &)*arg1);
   19835           0 :   smartresult = new std::shared_ptr< kdb::tools::PluginVariantDatabase >(result);
   19836           0 :   DATA_PTR(self) = smartresult;
   19837             :   return self;
   19838             : fail:
   19839             :   return Qnil;
   19840             : }
   19841             : 
   19842             : 
   19843             : SWIGINTERN void
   19844           0 : free_kdb_tools_PluginVariantDatabase(void *self) {
   19845           0 :     kdb::tools::PluginVariantDatabase *arg1 = (kdb::tools::PluginVariantDatabase *)self;
   19846             :     (void)arg1;
   19847           0 :     delete reinterpret_cast< std::shared_ptr< kdb::tools::PluginVariantDatabase > * >(self);
   19848           0 : }
   19849             : 
   19850             : 
   19851             : /*
   19852             :   Document-method: Kdbtools::PluginVariantDatabase.get_plugin_variants
   19853             : 
   19854             :   call-seq:
   19855             :     get_plugin_variants(PluginSpec whichplugin) -> PluginSpecVector
   19856             : 
   19857             : An instance method.
   19858             : 
   19859             : */
   19860             : SWIGINTERN VALUE
   19861           0 : _wrap_PluginVariantDatabase_get_plugin_variants(int argc, VALUE *argv, VALUE self) {
   19862           0 :   kdb::tools::PluginVariantDatabase *arg1 = (kdb::tools::PluginVariantDatabase *) 0 ;
   19863           0 :   kdb::tools::PluginSpec *arg2 = 0 ;
   19864           0 :   void *argp1 = 0 ;
   19865           0 :   int res1 = 0 ;
   19866           0 :   std::shared_ptr< kdb::tools::PluginVariantDatabase const > tempshared1 ;
   19867           0 :   std::shared_ptr< kdb::tools::PluginVariantDatabase const > *smartarg1 = 0 ;
   19868             :   void *argp2 ;
   19869           0 :   int res2 = 0 ;
   19870           0 :   std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > result;
   19871           0 :   VALUE vresult = Qnil;
   19872             :   
   19873           0 :   if ((argc < 1) || (argc > 1)) {
   19874           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   19875             :   }
   19876             :   {
   19877             :     swig_ruby_owntype newmem = {
   19878             :       0, 0
   19879           0 :     };
   19880           0 :     res1 = SWIG_ConvertPtrAndOwn(self, &argp1, SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t, 0 |  0 , &newmem);
   19881           0 :     if (!SWIG_IsOK(res1)) {
   19882           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::PluginVariantDatabase const *","getPluginVariants", 1, self ));
   19883             :     }
   19884           0 :     if (newmem.own & SWIG_CAST_NEW_MEMORY) {
   19885           0 :       tempshared1 = *reinterpret_cast< std::shared_ptr< const kdb::tools::PluginVariantDatabase > * >(argp1);
   19886           0 :       delete reinterpret_cast< std::shared_ptr< const kdb::tools::PluginVariantDatabase > * >(argp1);
   19887           0 :       arg1 = const_cast< kdb::tools::PluginVariantDatabase * >(tempshared1.get());
   19888             :     } else {
   19889           0 :       smartarg1 = reinterpret_cast< std::shared_ptr< const kdb::tools::PluginVariantDatabase > * >(argp1);
   19890           0 :       arg1 = const_cast< kdb::tools::PluginVariantDatabase * >((smartarg1 ? smartarg1->get() : 0));
   19891             :     }
   19892             :   }
   19893           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   19894           0 :   if (!SWIG_IsOK(res2)) {
   19895           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","getPluginVariants", 2, argv[0] )); 
   19896             :   }
   19897           0 :   if (!argp2) {
   19898           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","getPluginVariants", 2, argv[0])); 
   19899             :   }
   19900           0 :   arg2 = reinterpret_cast< kdb::tools::PluginSpec * >(argp2);
   19901             :   try {
   19902           0 :     result = ((kdb::tools::PluginVariantDatabase const *)arg1)->getPluginVariants((kdb::tools::PluginSpec const &)*arg2);
   19903             :   }
   19904           0 :   catch(kdb::tools::ToolException &_e) {
   19905           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   19906             :   }
   19907             :   
   19908           0 :   vresult = swig::from(static_cast< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > >(result));
   19909             :   return vresult;
   19910             : fail:
   19911             :   return Qnil;
   19912             : }
   19913             : 
   19914             : 
   19915             : 
   19916             : /*
   19917             :   Document-class: Kdbtools::MockPluginDatabase < Kdbtools::kdb::tools::ModulesPluginDatabase
   19918             : 
   19919             :   Proxy of C++ Kdbtools::MockPluginDatabase class
   19920             : 
   19921             : 
   19922             : */
   19923             : static swig_class SwigClassMockPluginDatabase;
   19924             : 
   19925             : 
   19926             : /*
   19927             :   Document-method: Kdbtools::MockPluginDatabase.data
   19928             : 
   19929             :   call-seq:
   19930             :     data -> std::unordered_map< kdb::tools::PluginSpec,std::unordered_map< std::string,std::string >,kdb::tools::PluginSpecHash,kdb::tools::PluginSpecName >
   19931             : 
   19932             : Get value of attribute.
   19933             : 
   19934             : */
   19935             : 
   19936             : /*
   19937             :   Document-method: Kdbtools::MockPluginDatabase.data=
   19938             : 
   19939             :   call-seq:
   19940             :     data=(x) -> std::unordered_map< kdb::tools::PluginSpec,std::unordered_map< std::string,std::string >,kdb::tools::PluginSpecHash,kdb::tools::PluginSpecName >
   19941             : 
   19942             : Set new value for attribute.
   19943             : 
   19944             : */
   19945             : SWIGINTERN VALUE
   19946           0 : _wrap_MockPluginDatabase_data_set(int argc, VALUE *argv, VALUE self) {
   19947           0 :   kdb::tools::MockPluginDatabase *arg1 = (kdb::tools::MockPluginDatabase *) 0 ;
   19948           0 :   std::unordered_map< kdb::tools::PluginSpec,std::unordered_map< std::string,std::string >,kdb::tools::PluginSpecHash,kdb::tools::PluginSpecName > *arg2 = (std::unordered_map< kdb::tools::PluginSpec,std::unordered_map< std::string,std::string >,kdb::tools::PluginSpecHash,kdb::tools::PluginSpecName > *) 0 ;
   19949           0 :   void *argp1 = 0 ;
   19950           0 :   int res1 = 0 ;
   19951           0 :   std::shared_ptr< kdb::tools::MockPluginDatabase > tempshared1 ;
   19952           0 :   std::shared_ptr< kdb::tools::MockPluginDatabase > *smartarg1 = 0 ;
   19953           0 :   void *argp2 = 0 ;
   19954           0 :   int res2 = 0 ;
   19955             :   
   19956           0 :   if ((argc < 1) || (argc > 1)) {
   19957           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   19958             :   }
   19959             :   {
   19960             :     swig_ruby_owntype newmem = {
   19961             :       0, 0
   19962           0 :     };
   19963           0 :     res1 = SWIG_ConvertPtrAndOwn(self, &argp1, SWIGTYPE_p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t, 0 |  0 , &newmem);
   19964           0 :     if (!SWIG_IsOK(res1)) {
   19965           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MockPluginDatabase *","data", 1, self ));
   19966             :     }
   19967           0 :     if (newmem.own & SWIG_CAST_NEW_MEMORY) {
   19968           0 :       tempshared1 = *reinterpret_cast< std::shared_ptr<  kdb::tools::MockPluginDatabase > * >(argp1);
   19969           0 :       delete reinterpret_cast< std::shared_ptr<  kdb::tools::MockPluginDatabase > * >(argp1);
   19970           0 :       arg1 = const_cast< kdb::tools::MockPluginDatabase * >(tempshared1.get());
   19971             :     } else {
   19972           0 :       smartarg1 = reinterpret_cast< std::shared_ptr<  kdb::tools::MockPluginDatabase > * >(argp1);
   19973           0 :       arg1 = const_cast< kdb::tools::MockPluginDatabase * >((smartarg1 ? smartarg1->get() : 0));
   19974             :     }
   19975             :   }
   19976           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__unordered_mapT_kdb__tools__PluginSpec_std__unordered_mapT_std__string_std__string_t_kdb__tools__PluginSpecHash_kdb__tools__PluginSpecName_t, 0 |  0 );
   19977           0 :   if (!SWIG_IsOK(res2)) {
   19978           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::unordered_map< kdb::tools::PluginSpec,std::unordered_map< std::string,std::string >,kdb::tools::PluginSpecHash,kdb::tools::PluginSpecName > *","data", 2, argv[0] )); 
   19979             :   }
   19980           0 :   arg2 = reinterpret_cast< std::unordered_map< kdb::tools::PluginSpec,std::unordered_map< std::string,std::string >,kdb::tools::PluginSpecHash,kdb::tools::PluginSpecName > * >(argp2);
   19981           0 :   if (arg1) (arg1)->data = *arg2;
   19982           0 :   return Qnil;
   19983             : fail:
   19984             :   return Qnil;
   19985             : }
   19986             : 
   19987             : 
   19988             : SWIGINTERN VALUE
   19989           0 : _wrap_MockPluginDatabase_data_get(int argc, VALUE *argv, VALUE self) {
   19990           0 :   kdb::tools::MockPluginDatabase *arg1 = (kdb::tools::MockPluginDatabase *) 0 ;
   19991           0 :   void *argp1 = 0 ;
   19992           0 :   int res1 = 0 ;
   19993           0 :   std::shared_ptr< kdb::tools::MockPluginDatabase > tempshared1 ;
   19994           0 :   std::shared_ptr< kdb::tools::MockPluginDatabase > *smartarg1 = 0 ;
   19995           0 :   std::unordered_map< kdb::tools::PluginSpec,std::unordered_map< std::string,std::string >,kdb::tools::PluginSpecHash,kdb::tools::PluginSpecName > *result = 0 ;
   19996           0 :   VALUE vresult = Qnil;
   19997             :   
   19998           0 :   if ((argc < 0) || (argc > 0)) {
   19999           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   20000             :   }
   20001             :   {
   20002             :     swig_ruby_owntype newmem = {
   20003             :       0, 0
   20004           0 :     };
   20005           0 :     res1 = SWIG_ConvertPtrAndOwn(self, &argp1, SWIGTYPE_p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t, 0 |  0 , &newmem);
   20006           0 :     if (!SWIG_IsOK(res1)) {
   20007           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MockPluginDatabase *","data", 1, self ));
   20008             :     }
   20009           0 :     if (newmem.own & SWIG_CAST_NEW_MEMORY) {
   20010           0 :       tempshared1 = *reinterpret_cast< std::shared_ptr<  kdb::tools::MockPluginDatabase > * >(argp1);
   20011           0 :       delete reinterpret_cast< std::shared_ptr<  kdb::tools::MockPluginDatabase > * >(argp1);
   20012           0 :       arg1 = const_cast< kdb::tools::MockPluginDatabase * >(tempshared1.get());
   20013             :     } else {
   20014           0 :       smartarg1 = reinterpret_cast< std::shared_ptr<  kdb::tools::MockPluginDatabase > * >(argp1);
   20015           0 :       arg1 = const_cast< kdb::tools::MockPluginDatabase * >((smartarg1 ? smartarg1->get() : 0));
   20016             :     }
   20017             :   }
   20018           0 :   result = (std::unordered_map< kdb::tools::PluginSpec,std::unordered_map< std::string,std::string >,kdb::tools::PluginSpecHash,kdb::tools::PluginSpecName > *)& ((arg1)->data);
   20019           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__unordered_mapT_kdb__tools__PluginSpec_std__unordered_mapT_std__string_std__string_t_kdb__tools__PluginSpecHash_kdb__tools__PluginSpecName_t, 0 |  0 );
   20020           0 :   return vresult;
   20021             : fail:
   20022             :   return Qnil;
   20023             : }
   20024             : 
   20025             : 
   20026             : 
   20027             : /*
   20028             :   Document-method: Kdbtools::MockPluginDatabase.set_checkconf_function
   20029             : 
   20030             :   call-seq:
   20031             :     set_checkconf_function(kdb::tools::MockPluginDatabase::checkConfPtr const newCheckconf)
   20032             : 
   20033             : An instance method.
   20034             : 
   20035             : */
   20036             : SWIGINTERN VALUE
   20037           0 : _wrap_MockPluginDatabase_set_checkconf_function(int argc, VALUE *argv, VALUE self) {
   20038           0 :   kdb::tools::MockPluginDatabase *arg1 = (kdb::tools::MockPluginDatabase *) 0 ;
   20039           0 :   kdb::tools::MockPluginDatabase::checkConfPtr arg2 = (kdb::tools::MockPluginDatabase::checkConfPtr) (kdb::tools::MockPluginDatabase::checkConfPtr)0 ;
   20040           0 :   void *argp1 = 0 ;
   20041           0 :   int res1 = 0 ;
   20042           0 :   std::shared_ptr< kdb::tools::MockPluginDatabase > tempshared1 ;
   20043           0 :   std::shared_ptr< kdb::tools::MockPluginDatabase > *smartarg1 = 0 ;
   20044           0 :   void *argp2 = 0 ;
   20045           0 :   int res2 = 0 ;
   20046             :   
   20047           0 :   if ((argc < 1) || (argc > 1)) {
   20048           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   20049             :   }
   20050             :   {
   20051             :     swig_ruby_owntype newmem = {
   20052             :       0, 0
   20053           0 :     };
   20054           0 :     res1 = SWIG_ConvertPtrAndOwn(self, &argp1, SWIGTYPE_p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t, 0 |  0 , &newmem);
   20055           0 :     if (!SWIG_IsOK(res1)) {
   20056           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MockPluginDatabase *","setCheckconfFunction", 1, self ));
   20057             :     }
   20058           0 :     if (newmem.own & SWIG_CAST_NEW_MEMORY) {
   20059           0 :       tempshared1 = *reinterpret_cast< std::shared_ptr<  kdb::tools::MockPluginDatabase > * >(argp1);
   20060           0 :       delete reinterpret_cast< std::shared_ptr<  kdb::tools::MockPluginDatabase > * >(argp1);
   20061           0 :       arg1 = const_cast< kdb::tools::MockPluginDatabase * >(tempshared1.get());
   20062             :     } else {
   20063           0 :       smartarg1 = reinterpret_cast< std::shared_ptr<  kdb::tools::MockPluginDatabase > * >(argp1);
   20064           0 :       arg1 = const_cast< kdb::tools::MockPluginDatabase * >((smartarg1 ? smartarg1->get() : 0));
   20065             :     }
   20066             :   }
   20067           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_f_p__Key_p__KeySet__int, 0 |  0 );
   20068           0 :   if (!SWIG_IsOK(res2)) {
   20069           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::MockPluginDatabase::checkConfPtr const","setCheckconfFunction", 2, argv[0] )); 
   20070             :   }
   20071           0 :   arg2 = reinterpret_cast< kdb::tools::MockPluginDatabase::checkConfPtr >(argp2);
   20072           0 :   (arg1)->setCheckconfFunction(arg2);
   20073           0 :   return Qnil;
   20074             : fail:
   20075             :   return Qnil;
   20076             : }
   20077             : 
   20078             : 
   20079             : SWIGINTERN VALUE
   20080             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   20081           0 : _wrap_MockPluginDatabase_allocate(VALUE self)
   20082             : #else
   20083             : _wrap_MockPluginDatabase_allocate(int argc, VALUE *argv, VALUE self)
   20084             : #endif
   20085             : {
   20086           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t);
   20087             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   20088             :   rb_obj_call_init(vresult, argc, argv);
   20089             : #endif
   20090           0 :   return vresult;
   20091             : }
   20092             : 
   20093             : 
   20094             : 
   20095             : /*
   20096             :   Document-method: Kdbtools::MockPluginDatabase.new
   20097             : 
   20098             :   call-seq:
   20099             :     MockPluginDatabase.new
   20100             : 
   20101             : Class constructor.
   20102             : 
   20103             : */
   20104             : SWIGINTERN VALUE
   20105           0 : _wrap_new_MockPluginDatabase(int argc, VALUE *argv, VALUE self) {
   20106           0 :   std::shared_ptr< kdb::tools::MockPluginDatabase > *smartresult = 0;
   20107           0 :   kdb::tools::MockPluginDatabase *result = 0 ;
   20108             :   
   20109           0 :   if ((argc < 0) || (argc > 0)) {
   20110           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   20111             :   }
   20112           0 :   result = (kdb::tools::MockPluginDatabase *)new kdb::tools::MockPluginDatabase();
   20113           0 :   smartresult = new std::shared_ptr< kdb::tools::MockPluginDatabase >(result);
   20114           0 :   DATA_PTR(self) = smartresult;
   20115             :   return self;
   20116             : fail:
   20117             :   return Qnil;
   20118             : }
   20119             : 
   20120             : 
   20121             : SWIGINTERN void
   20122           0 : free_kdb_tools_MockPluginDatabase(void *self) {
   20123           0 :     kdb::tools::MockPluginDatabase *arg1 = (kdb::tools::MockPluginDatabase *)self;
   20124             :     (void)arg1;
   20125           0 :     delete reinterpret_cast< std::shared_ptr< kdb::tools::MockPluginDatabase > * >(self);
   20126           0 : }
   20127             : 
   20128             : 
   20129             : /*
   20130             :   Document-class: Kdbtools::Modules
   20131             : 
   20132             :   Proxy of C++ Kdbtools::Modules class
   20133             : 
   20134             : 
   20135             : */
   20136             : static swig_class SwigClassModules;
   20137             : 
   20138             : SWIGINTERN VALUE
   20139             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   20140           5 : _wrap_Modules_allocate(VALUE self)
   20141             : #else
   20142             : _wrap_Modules_allocate(int argc, VALUE *argv, VALUE self)
   20143             : #endif
   20144             : {
   20145           5 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__Modules);
   20146             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   20147             :   rb_obj_call_init(vresult, argc, argv);
   20148             : #endif
   20149           5 :   return vresult;
   20150             : }
   20151             : 
   20152             : 
   20153             : 
   20154             : /*
   20155             :   Document-method: Kdbtools::Modules.new
   20156             : 
   20157             :   call-seq:
   20158             :     Modules.new
   20159             : 
   20160             : Class constructor.
   20161             : 
   20162             : */
   20163             : SWIGINTERN VALUE
   20164           5 : _wrap_new_Modules(int argc, VALUE *argv, VALUE self) {
   20165           5 :   kdb::tools::Modules *result = 0 ;
   20166             :   
   20167           5 :   if ((argc < 0) || (argc > 0)) {
   20168           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   20169             :   }
   20170           5 :   result = (kdb::tools::Modules *)new kdb::tools::Modules();
   20171           5 :   DATA_PTR(self) = result;
   20172             :   return self;
   20173             : fail:
   20174             :   return Qnil;
   20175             : }
   20176             : 
   20177             : 
   20178             : SWIGINTERN void
   20179           5 : free_kdb_tools_Modules(void *self) {
   20180           5 :     kdb::tools::Modules *arg1 = (kdb::tools::Modules *)self;
   20181           5 :     delete arg1;
   20182           5 : }
   20183             : 
   20184             : 
   20185             : /*
   20186             :   Document-method: Kdbtools::Modules.load
   20187             : 
   20188             :   call-seq:
   20189             :     load(std::string const & pluginName) -> kdb::tools::PluginPtr
   20190             :     load(std::string const & pluginName, KeySet config) -> kdb::tools::PluginPtr
   20191             :     load(PluginSpec spec) -> kdb::tools::PluginPtr
   20192             : 
   20193             : An instance method.
   20194             : 
   20195             : */
   20196             : SWIGINTERN VALUE
   20197           3 : _wrap_Modules_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
   20198           3 :   kdb::tools::Modules *arg1 = (kdb::tools::Modules *) 0 ;
   20199           3 :   std::string *arg2 = 0 ;
   20200           3 :   void *argp1 = 0 ;
   20201           3 :   int res1 = 0 ;
   20202           3 :   int res2 = SWIG_OLDOBJ ;
   20203           4 :   SwigValueWrapper< std::unique_ptr< kdb::tools::Plugin > > result;
   20204           3 :   VALUE vresult = Qnil;
   20205             :   
   20206           3 :   if ((argc < 1) || (argc > 1)) {
   20207           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   20208             :   }
   20209           3 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Modules, 0 |  0 );
   20210           3 :   if (!SWIG_IsOK(res1)) {
   20211           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Modules *","load", 1, self )); 
   20212             :   }
   20213           3 :   arg1 = reinterpret_cast< kdb::tools::Modules * >(argp1);
   20214             :   {
   20215           3 :     std::string *ptr = (std::string *)0;
   20216           3 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   20217           3 :     if (!SWIG_IsOK(res2)) {
   20218           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","load", 2, argv[0] )); 
   20219             :     }
   20220           3 :     if (!ptr) {
   20221           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","load", 2, argv[0])); 
   20222             :     }
   20223           3 :     arg2 = ptr;
   20224             :   }
   20225             :   try {
   20226           3 :     result = (arg1)->load((std::string const &)*arg2);
   20227             :   }
   20228           1 :   catch(kdb::tools::BadPluginName &_e) {
   20229           1 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   20230             :   }
   20231           1 :   catch(kdb::tools::NoPlugin &_e) {
   20232           1 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__NoPlugin, SWIG_NewPointerObj((new kdb::tools::NoPlugin(static_cast< const kdb::tools::NoPlugin& >(_e))),SWIGTYPE_p_kdb__tools__NoPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   20233             :   }
   20234           0 :   catch(kdb::tools::MissingSymbol &_e) {
   20235           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   20236             :   }
   20237           0 :   catch(kdb::tools::PluginNoContract &_e) {
   20238           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginNoContract, SWIG_NewPointerObj((new kdb::tools::PluginNoContract(static_cast< const kdb::tools::PluginNoContract& >(_e))),SWIGTYPE_p_kdb__tools__PluginNoContract,SWIG_POINTER_OWN))); SWIG_fail;
   20239             :   }
   20240           0 :   catch(kdb::tools::PluginNoInfo &_e) {
   20241           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginNoInfo, SWIG_NewPointerObj((new kdb::tools::PluginNoInfo(static_cast< const kdb::tools::PluginNoInfo& >(_e))),SWIGTYPE_p_kdb__tools__PluginNoInfo,SWIG_POINTER_OWN))); SWIG_fail;
   20242             :   }
   20243           0 :   catch(kdb::tools::VersionInfoMismatch &_e) {
   20244           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__VersionInfoMismatch, SWIG_NewPointerObj((new kdb::tools::VersionInfoMismatch(static_cast< const kdb::tools::VersionInfoMismatch& >(_e))),SWIGTYPE_p_kdb__tools__VersionInfoMismatch,SWIG_POINTER_OWN))); SWIG_fail;
   20245             :   }
   20246           0 :   catch(kdb::tools::WrongStatus &_e) {
   20247           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__WrongStatus, SWIG_NewPointerObj((new kdb::tools::WrongStatus(static_cast< const kdb::tools::WrongStatus& >(_e))),SWIGTYPE_p_kdb__tools__WrongStatus,SWIG_POINTER_OWN))); SWIG_fail;
   20248             :   }
   20249           0 :   catch(kdb::tools::SymbolMismatch &_e) {
   20250           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__SymbolMismatch, SWIG_NewPointerObj((new kdb::tools::SymbolMismatch(static_cast< const kdb::tools::SymbolMismatch& >(_e))),SWIGTYPE_p_kdb__tools__SymbolMismatch,SWIG_POINTER_OWN))); SWIG_fail;
   20251             :   }
   20252           0 :   catch(kdb::tools::SymbolDuplicate &_e) {
   20253           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__SymbolDuplicate, SWIG_NewPointerObj((new kdb::tools::SymbolDuplicate(static_cast< const kdb::tools::SymbolDuplicate& >(_e))),SWIGTYPE_p_kdb__tools__SymbolDuplicate,SWIG_POINTER_OWN))); SWIG_fail;
   20254             :   }
   20255           0 :   catch(kdb::tools::PluginCheckException &_e) {
   20256           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   20257             :   }
   20258           0 :   catch(kdb::tools::ToolException &_e) {
   20259           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   20260             :   }
   20261             :   
   20262             :   {
   20263           2 :     vresult = SWIG_NewPointerObj((&result)->release(), SWIGTYPE_p_kdb__tools__Plugin, SWIG_POINTER_OWN | 0);
   20264             :   }
   20265           2 :   if (SWIG_IsNewObj(res2)) delete arg2;
   20266           1 :   return vresult;
   20267             : fail:
   20268             :   if (SWIG_IsNewObj(res2)) delete arg2;
   20269             :   return Qnil;
   20270             : }
   20271             : 
   20272             : 
   20273             : SWIGINTERN VALUE
   20274           1 : _wrap_Modules_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
   20275           1 :   kdb::tools::Modules *arg1 = (kdb::tools::Modules *) 0 ;
   20276           1 :   std::string *arg2 = 0 ;
   20277           1 :   kdb::KeySet *arg3 = 0 ;
   20278           1 :   void *argp1 = 0 ;
   20279           1 :   int res1 = 0 ;
   20280           1 :   int res2 = SWIG_OLDOBJ ;
   20281             :   void *argp3 ;
   20282           1 :   int res3 = 0 ;
   20283           2 :   SwigValueWrapper< std::unique_ptr< kdb::tools::Plugin > > result;
   20284           1 :   VALUE vresult = Qnil;
   20285             :   
   20286           1 :   if ((argc < 2) || (argc > 2)) {
   20287           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   20288             :   }
   20289           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Modules, 0 |  0 );
   20290           1 :   if (!SWIG_IsOK(res1)) {
   20291           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Modules *","load", 1, self )); 
   20292             :   }
   20293           1 :   arg1 = reinterpret_cast< kdb::tools::Modules * >(argp1);
   20294             :   {
   20295           1 :     std::string *ptr = (std::string *)0;
   20296           1 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   20297           1 :     if (!SWIG_IsOK(res2)) {
   20298           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","load", 2, argv[0] )); 
   20299             :     }
   20300           1 :     if (!ptr) {
   20301           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","load", 2, argv[0])); 
   20302             :     }
   20303           1 :     arg2 = ptr;
   20304             :   }
   20305           1 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__KeySet,  0 );
   20306           1 :   if (!SWIG_IsOK(res3)) {
   20307           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::KeySet const &","load", 3, argv[1] )); 
   20308             :   }
   20309           1 :   if (!argp3) {
   20310           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet const &","load", 3, argv[1])); 
   20311             :   }
   20312           1 :   arg3 = reinterpret_cast< kdb::KeySet * >(argp3);
   20313             :   try {
   20314           1 :     result = (arg1)->load((std::string const &)*arg2,(kdb::KeySet const &)*arg3);
   20315             :   }
   20316           0 :   catch(kdb::tools::BadPluginName &_e) {
   20317           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   20318             :   }
   20319           0 :   catch(kdb::tools::NoPlugin &_e) {
   20320           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__NoPlugin, SWIG_NewPointerObj((new kdb::tools::NoPlugin(static_cast< const kdb::tools::NoPlugin& >(_e))),SWIGTYPE_p_kdb__tools__NoPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   20321             :   }
   20322           0 :   catch(kdb::tools::MissingSymbol &_e) {
   20323           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   20324             :   }
   20325           0 :   catch(kdb::tools::PluginNoContract &_e) {
   20326           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginNoContract, SWIG_NewPointerObj((new kdb::tools::PluginNoContract(static_cast< const kdb::tools::PluginNoContract& >(_e))),SWIGTYPE_p_kdb__tools__PluginNoContract,SWIG_POINTER_OWN))); SWIG_fail;
   20327             :   }
   20328           0 :   catch(kdb::tools::PluginNoInfo &_e) {
   20329           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginNoInfo, SWIG_NewPointerObj((new kdb::tools::PluginNoInfo(static_cast< const kdb::tools::PluginNoInfo& >(_e))),SWIGTYPE_p_kdb__tools__PluginNoInfo,SWIG_POINTER_OWN))); SWIG_fail;
   20330             :   }
   20331           0 :   catch(kdb::tools::VersionInfoMismatch &_e) {
   20332           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__VersionInfoMismatch, SWIG_NewPointerObj((new kdb::tools::VersionInfoMismatch(static_cast< const kdb::tools::VersionInfoMismatch& >(_e))),SWIGTYPE_p_kdb__tools__VersionInfoMismatch,SWIG_POINTER_OWN))); SWIG_fail;
   20333             :   }
   20334           0 :   catch(kdb::tools::WrongStatus &_e) {
   20335           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__WrongStatus, SWIG_NewPointerObj((new kdb::tools::WrongStatus(static_cast< const kdb::tools::WrongStatus& >(_e))),SWIGTYPE_p_kdb__tools__WrongStatus,SWIG_POINTER_OWN))); SWIG_fail;
   20336             :   }
   20337           0 :   catch(kdb::tools::SymbolMismatch &_e) {
   20338           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__SymbolMismatch, SWIG_NewPointerObj((new kdb::tools::SymbolMismatch(static_cast< const kdb::tools::SymbolMismatch& >(_e))),SWIGTYPE_p_kdb__tools__SymbolMismatch,SWIG_POINTER_OWN))); SWIG_fail;
   20339             :   }
   20340           0 :   catch(kdb::tools::SymbolDuplicate &_e) {
   20341           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__SymbolDuplicate, SWIG_NewPointerObj((new kdb::tools::SymbolDuplicate(static_cast< const kdb::tools::SymbolDuplicate& >(_e))),SWIGTYPE_p_kdb__tools__SymbolDuplicate,SWIG_POINTER_OWN))); SWIG_fail;
   20342             :   }
   20343           0 :   catch(kdb::tools::PluginCheckException &_e) {
   20344           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   20345             :   }
   20346           0 :   catch(kdb::tools::ToolException &_e) {
   20347           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   20348             :   }
   20349             :   
   20350             :   {
   20351           2 :     vresult = SWIG_NewPointerObj((&result)->release(), SWIGTYPE_p_kdb__tools__Plugin, SWIG_POINTER_OWN | 0);
   20352             :   }
   20353           2 :   if (SWIG_IsNewObj(res2)) delete arg2;
   20354           1 :   return vresult;
   20355             : fail:
   20356             :   if (SWIG_IsNewObj(res2)) delete arg2;
   20357             :   return Qnil;
   20358             : }
   20359             : 
   20360             : 
   20361             : SWIGINTERN VALUE
   20362           1 : _wrap_Modules_load__SWIG_2(int argc, VALUE *argv, VALUE self) {
   20363           1 :   kdb::tools::Modules *arg1 = (kdb::tools::Modules *) 0 ;
   20364           1 :   kdb::tools::PluginSpec *arg2 = 0 ;
   20365           1 :   void *argp1 = 0 ;
   20366           1 :   int res1 = 0 ;
   20367             :   void *argp2 ;
   20368           1 :   int res2 = 0 ;
   20369           2 :   SwigValueWrapper< std::unique_ptr< kdb::tools::Plugin > > result;
   20370           1 :   VALUE vresult = Qnil;
   20371             :   
   20372           1 :   if ((argc < 1) || (argc > 1)) {
   20373           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   20374             :   }
   20375           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Modules, 0 |  0 );
   20376           1 :   if (!SWIG_IsOK(res1)) {
   20377           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Modules *","load", 1, self )); 
   20378             :   }
   20379           1 :   arg1 = reinterpret_cast< kdb::tools::Modules * >(argp1);
   20380           1 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   20381           1 :   if (!SWIG_IsOK(res2)) {
   20382           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","load", 2, argv[0] )); 
   20383             :   }
   20384           1 :   if (!argp2) {
   20385           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","load", 2, argv[0])); 
   20386             :   }
   20387           1 :   arg2 = reinterpret_cast< kdb::tools::PluginSpec * >(argp2);
   20388             :   try {
   20389           1 :     result = (arg1)->load((kdb::tools::PluginSpec const &)*arg2);
   20390             :   }
   20391           0 :   catch(kdb::tools::BadPluginName &_e) {
   20392           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BadPluginName, SWIG_NewPointerObj((new kdb::tools::BadPluginName(static_cast< const kdb::tools::BadPluginName& >(_e))),SWIGTYPE_p_kdb__tools__BadPluginName,SWIG_POINTER_OWN))); SWIG_fail;
   20393             :   }
   20394           0 :   catch(kdb::tools::NoPlugin &_e) {
   20395           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__NoPlugin, SWIG_NewPointerObj((new kdb::tools::NoPlugin(static_cast< const kdb::tools::NoPlugin& >(_e))),SWIGTYPE_p_kdb__tools__NoPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   20396             :   }
   20397           0 :   catch(kdb::tools::MissingSymbol &_e) {
   20398           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   20399             :   }
   20400           0 :   catch(kdb::tools::PluginNoContract &_e) {
   20401           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginNoContract, SWIG_NewPointerObj((new kdb::tools::PluginNoContract(static_cast< const kdb::tools::PluginNoContract& >(_e))),SWIGTYPE_p_kdb__tools__PluginNoContract,SWIG_POINTER_OWN))); SWIG_fail;
   20402             :   }
   20403           0 :   catch(kdb::tools::PluginNoInfo &_e) {
   20404           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginNoInfo, SWIG_NewPointerObj((new kdb::tools::PluginNoInfo(static_cast< const kdb::tools::PluginNoInfo& >(_e))),SWIGTYPE_p_kdb__tools__PluginNoInfo,SWIG_POINTER_OWN))); SWIG_fail;
   20405             :   }
   20406           0 :   catch(kdb::tools::VersionInfoMismatch &_e) {
   20407           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__VersionInfoMismatch, SWIG_NewPointerObj((new kdb::tools::VersionInfoMismatch(static_cast< const kdb::tools::VersionInfoMismatch& >(_e))),SWIGTYPE_p_kdb__tools__VersionInfoMismatch,SWIG_POINTER_OWN))); SWIG_fail;
   20408             :   }
   20409           0 :   catch(kdb::tools::WrongStatus &_e) {
   20410           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__WrongStatus, SWIG_NewPointerObj((new kdb::tools::WrongStatus(static_cast< const kdb::tools::WrongStatus& >(_e))),SWIGTYPE_p_kdb__tools__WrongStatus,SWIG_POINTER_OWN))); SWIG_fail;
   20411             :   }
   20412           0 :   catch(kdb::tools::SymbolMismatch &_e) {
   20413           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__SymbolMismatch, SWIG_NewPointerObj((new kdb::tools::SymbolMismatch(static_cast< const kdb::tools::SymbolMismatch& >(_e))),SWIGTYPE_p_kdb__tools__SymbolMismatch,SWIG_POINTER_OWN))); SWIG_fail;
   20414             :   }
   20415           0 :   catch(kdb::tools::SymbolDuplicate &_e) {
   20416           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__SymbolDuplicate, SWIG_NewPointerObj((new kdb::tools::SymbolDuplicate(static_cast< const kdb::tools::SymbolDuplicate& >(_e))),SWIGTYPE_p_kdb__tools__SymbolDuplicate,SWIG_POINTER_OWN))); SWIG_fail;
   20417             :   }
   20418           0 :   catch(kdb::tools::PluginCheckException &_e) {
   20419           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   20420             :   }
   20421           0 :   catch(kdb::tools::ToolException &_e) {
   20422           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   20423             :   }
   20424             :   
   20425             :   {
   20426           2 :     vresult = SWIG_NewPointerObj((&result)->release(), SWIGTYPE_p_kdb__tools__Plugin, SWIG_POINTER_OWN | 0);
   20427             :   }
   20428           1 :   return vresult;
   20429             : fail:
   20430             :   return Qnil;
   20431             : }
   20432             : 
   20433             : 
   20434           5 : SWIGINTERN VALUE _wrap_Modules_load(int nargs, VALUE *args, VALUE self) {
   20435             :   int argc;
   20436             :   VALUE argv[4];
   20437             :   int ii;
   20438             :   
   20439           5 :   argc = nargs + 1;
   20440             :   argv[0] = self;
   20441           5 :   if (argc > 4) SWIG_fail;
   20442          17 :   for (ii = 1; (ii < argc); ++ii) {
   20443           6 :     argv[ii] = args[ii-1];
   20444             :   }
   20445           5 :   if (argc == 2) {
   20446           4 :     int _v = 0;
   20447             :     {
   20448           4 :       void *vptr = 0;
   20449           4 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_kdb__tools__PluginSpec, 0);
   20450           4 :       _v = SWIG_CheckState(res);
   20451             :     }
   20452           4 :     if (!_v) goto check_1;
   20453           1 :     return _wrap_Modules_load__SWIG_2(nargs, args, self);
   20454             :   }
   20455             : check_1:
   20456             :   
   20457           4 :   if (argc == 2) {
   20458           3 :     return _wrap_Modules_load__SWIG_0(nargs, args, self);
   20459             :   }
   20460           1 :   if (argc == 3) {
   20461           1 :     return _wrap_Modules_load__SWIG_1(nargs, args, self);
   20462             :   }
   20463             :   
   20464             : fail:
   20465             :   Ruby_Format_OverloadedError( argc, 4, "Modules.load", 
   20466             :     "    kdb::tools::PluginPtr Modules.load(std::string const &pluginName)\n"
   20467             :     "    kdb::tools::PluginPtr Modules.load(std::string const &pluginName, kdb::KeySet const &config)\n"
   20468           0 :     "    kdb::tools::PluginPtr Modules.load(kdb::tools::PluginSpec const &spec)\n");
   20469             :   
   20470             :   return Qnil;
   20471             : }
   20472             : 
   20473             : 
   20474             : 
   20475             : /*
   20476             :   Document-method: Kdbtools::tools.parse_plugin_arguments
   20477             : 
   20478             :   call-seq:
   20479             :     parse_plugin_arguments(std::string const & pluginArguments, std::string const & basename="user") -> KeySet
   20480             :     parse_plugin_arguments(std::string const & pluginArguments) -> KeySet
   20481             : 
   20482             : A module function.
   20483             : 
   20484             : */
   20485             : SWIGINTERN VALUE
   20486           0 : _wrap_parse_plugin_arguments__SWIG_0(int argc, VALUE *argv, VALUE self) {
   20487           0 :   std::string *arg1 = 0 ;
   20488           0 :   std::string *arg2 = 0 ;
   20489           0 :   int res1 = SWIG_OLDOBJ ;
   20490           0 :   int res2 = SWIG_OLDOBJ ;
   20491           0 :   kdb::KeySet result;
   20492           0 :   VALUE vresult = Qnil;
   20493             :   
   20494           0 :   if ((argc < 2) || (argc > 2)) {
   20495           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   20496             :   }
   20497             :   {
   20498           0 :     std::string *ptr = (std::string *)0;
   20499           0 :     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
   20500           0 :     if (!SWIG_IsOK(res1)) {
   20501           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","kdb::tools::parsePluginArguments", 1, argv[0] )); 
   20502             :     }
   20503           0 :     if (!ptr) {
   20504           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","kdb::tools::parsePluginArguments", 1, argv[0])); 
   20505             :     }
   20506           0 :     arg1 = ptr;
   20507             :   }
   20508             :   {
   20509           0 :     std::string *ptr = (std::string *)0;
   20510           0 :     res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
   20511           0 :     if (!SWIG_IsOK(res2)) {
   20512           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","kdb::tools::parsePluginArguments", 2, argv[1] )); 
   20513             :     }
   20514           0 :     if (!ptr) {
   20515           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","kdb::tools::parsePluginArguments", 2, argv[1])); 
   20516             :     }
   20517           0 :     arg2 = ptr;
   20518             :   }
   20519             :   try {
   20520           0 :     result = kdb::tools::parsePluginArguments((std::string const &)*arg1,(std::string const &)*arg2);
   20521             :   }
   20522           0 :   catch(kdb::tools::ParseException &_e) {
   20523           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ParseException, SWIG_NewPointerObj((new kdb::tools::ParseException(static_cast< const kdb::tools::ParseException& >(_e))),SWIGTYPE_p_kdb__tools__ParseException,SWIG_POINTER_OWN))); SWIG_fail;
   20524             :   }
   20525             :   
   20526           0 :   vresult = SWIG_NewPointerObj((new kdb::KeySet(static_cast< const kdb::KeySet& >(result))), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_OWN |  0 );
   20527           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
   20528           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   20529           0 :   return vresult;
   20530             : fail:
   20531             :   if (SWIG_IsNewObj(res1)) delete arg1;
   20532             :   if (SWIG_IsNewObj(res2)) delete arg2;
   20533             :   return Qnil;
   20534             : }
   20535             : 
   20536             : 
   20537             : SWIGINTERN VALUE
   20538           1 : _wrap_parse_plugin_arguments__SWIG_1(int argc, VALUE *argv, VALUE self) {
   20539           1 :   std::string *arg1 = 0 ;
   20540           1 :   int res1 = SWIG_OLDOBJ ;
   20541           2 :   kdb::KeySet result;
   20542           1 :   VALUE vresult = Qnil;
   20543             :   
   20544           1 :   if ((argc < 1) || (argc > 1)) {
   20545           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   20546             :   }
   20547             :   {
   20548           1 :     std::string *ptr = (std::string *)0;
   20549           1 :     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
   20550           1 :     if (!SWIG_IsOK(res1)) {
   20551           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","kdb::tools::parsePluginArguments", 1, argv[0] )); 
   20552             :     }
   20553           1 :     if (!ptr) {
   20554           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","kdb::tools::parsePluginArguments", 1, argv[0])); 
   20555             :     }
   20556           1 :     arg1 = ptr;
   20557             :   }
   20558             :   try {
   20559           6 :     result = kdb::tools::parsePluginArguments((std::string const &)*arg1);
   20560             :   }
   20561           0 :   catch(kdb::tools::ParseException &_e) {
   20562           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ParseException, SWIG_NewPointerObj((new kdb::tools::ParseException(static_cast< const kdb::tools::ParseException& >(_e))),SWIGTYPE_p_kdb__tools__ParseException,SWIG_POINTER_OWN))); SWIG_fail;
   20563             :   }
   20564             :   
   20565           2 :   vresult = SWIG_NewPointerObj((new kdb::KeySet(static_cast< const kdb::KeySet& >(result))), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_OWN |  0 );
   20566           2 :   if (SWIG_IsNewObj(res1)) delete arg1;
   20567           1 :   return vresult;
   20568             : fail:
   20569             :   if (SWIG_IsNewObj(res1)) delete arg1;
   20570             :   return Qnil;
   20571             : }
   20572             : 
   20573             : 
   20574           1 : SWIGINTERN VALUE _wrap_parse_plugin_arguments(int nargs, VALUE *args, VALUE self) {
   20575             :   int argc;
   20576             :   VALUE argv[2];
   20577             :   int ii;
   20578             :   
   20579           1 :   argc = nargs;
   20580           1 :   if (argc > 2) SWIG_fail;
   20581             :   for (ii = 0; (ii < argc); ++ii) {
   20582             :     argv[ii] = args[ii];
   20583             :   }
   20584           1 :   if (argc == 1) {
   20585           1 :     return _wrap_parse_plugin_arguments__SWIG_1(nargs, args, self);
   20586             :   }
   20587           0 :   if (argc == 2) {
   20588           0 :     return _wrap_parse_plugin_arguments__SWIG_0(nargs, args, self);
   20589             :   }
   20590             :   
   20591             : fail:
   20592             :   Ruby_Format_OverloadedError( argc, 2, "parse_plugin_arguments", 
   20593             :     "    kdb::KeySet parse_plugin_arguments(std::string const &pluginArguments, std::string const &basename)\n"
   20594           0 :     "    kdb::KeySet parse_plugin_arguments(std::string const &pluginArguments)\n");
   20595             :   
   20596             :   return Qnil;
   20597             : }
   20598             : 
   20599             : 
   20600             : 
   20601             : /*
   20602             :   Document-method: Kdbtools::tools.parse_arguments
   20603             : 
   20604             :   call-seq:
   20605             :     parse_arguments(std::string const & cmdline) -> PluginSpecVector
   20606             : 
   20607             : A module function.
   20608             : 
   20609             : */
   20610             : SWIGINTERN VALUE
   20611           3 : _wrap_parse_arguments(int argc, VALUE *argv, VALUE self) {
   20612           3 :   std::string *arg1 = 0 ;
   20613           3 :   int res1 = SWIG_OLDOBJ ;
   20614           5 :   kdb::tools::PluginSpecVector result;
   20615           3 :   VALUE vresult = Qnil;
   20616             :   
   20617           3 :   if ((argc < 1) || (argc > 1)) {
   20618           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   20619             :   }
   20620             :   {
   20621           3 :     std::string *ptr = (std::string *)0;
   20622           3 :     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
   20623           3 :     if (!SWIG_IsOK(res1)) {
   20624           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","kdb::tools::parseArguments", 1, argv[0] )); 
   20625             :     }
   20626           3 :     if (!ptr) {
   20627           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","kdb::tools::parseArguments", 1, argv[0])); 
   20628             :     }
   20629           3 :     arg1 = ptr;
   20630             :   }
   20631             :   try {
   20632           5 :     result = kdb::tools::parseArguments((std::string const &)*arg1);
   20633             :   }
   20634           1 :   catch(kdb::tools::ParseException &_e) {
   20635           1 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ParseException, SWIG_NewPointerObj((new kdb::tools::ParseException(static_cast< const kdb::tools::ParseException& >(_e))),SWIGTYPE_p_kdb__tools__ParseException,SWIG_POINTER_OWN))); SWIG_fail;
   20636             :   }
   20637             :   
   20638           4 :   vresult = swig::from(static_cast< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > >(result));
   20639           4 :   if (SWIG_IsNewObj(res1)) delete arg1;
   20640             :   return vresult;
   20641             : fail:
   20642             :   if (SWIG_IsNewObj(res1)) delete arg1;
   20643             :   return Qnil;
   20644             : }
   20645             : 
   20646             : 
   20647             : 
   20648             : /*
   20649             :   Document-class: Kdbtools::BackendInterface
   20650             : 
   20651             :   Proxy of C++ Kdbtools::BackendInterface class
   20652             : 
   20653             : 
   20654             : */
   20655             : static swig_class SwigClassBackendInterface;
   20656             : 
   20657             : 
   20658             : /*
   20659             :   Document-method: Kdbtools::BackendInterface.add_plugin
   20660             : 
   20661             :   call-seq:
   20662             :     add_plugin(PluginSpec spec)
   20663             : 
   20664             : An instance method.
   20665             : 
   20666             : */
   20667             : SWIGINTERN VALUE
   20668           0 : _wrap_BackendInterface_add_plugin(int argc, VALUE *argv, VALUE self) {
   20669           0 :   kdb::tools::BackendInterface *arg1 = (kdb::tools::BackendInterface *) 0 ;
   20670           0 :   kdb::tools::PluginSpec *arg2 = 0 ;
   20671           0 :   void *argp1 = 0 ;
   20672           0 :   int res1 = 0 ;
   20673             :   void *argp2 ;
   20674           0 :   int res2 = 0 ;
   20675             :   
   20676           0 :   if ((argc < 1) || (argc > 1)) {
   20677           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   20678             :   }
   20679           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendInterface, 0 |  0 );
   20680           0 :   if (!SWIG_IsOK(res1)) {
   20681           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendInterface *","addPlugin", 1, self )); 
   20682             :   }
   20683           0 :   arg1 = reinterpret_cast< kdb::tools::BackendInterface * >(argp1);
   20684           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   20685           0 :   if (!SWIG_IsOK(res2)) {
   20686           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","addPlugin", 2, argv[0] )); 
   20687             :   }
   20688           0 :   if (!argp2) {
   20689           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","addPlugin", 2, argv[0])); 
   20690             :   }
   20691           0 :   arg2 = reinterpret_cast< kdb::tools::PluginSpec * >(argp2);
   20692             :   try {
   20693           0 :     (arg1)->addPlugin((kdb::tools::PluginSpec const &)*arg2);
   20694             :   }
   20695           0 :   catch(kdb::tools::BackendCheckException &_e) {
   20696           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BackendCheckException, SWIG_NewPointerObj((new kdb::tools::BackendCheckException(static_cast< const kdb::tools::BackendCheckException& >(_e))),SWIGTYPE_p_kdb__tools__BackendCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   20697             :   }
   20698           0 :   catch(kdb::tools::PluginCheckException &_e) {
   20699           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginCheckException, SWIG_NewPointerObj((new kdb::tools::PluginCheckException(static_cast< const kdb::tools::PluginCheckException& >(_e))),SWIGTYPE_p_kdb__tools__PluginCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   20700             :   }
   20701           0 :   catch(kdb::tools::ToolException &_e) {
   20702           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   20703             :   }
   20704             :   
   20705             :   return Qnil;
   20706             : fail:
   20707             :   return Qnil;
   20708             : }
   20709             : 
   20710             : 
   20711             : SWIGINTERN void
   20712           0 : free_kdb_tools_BackendInterface(void *self) {
   20713           0 :     kdb::tools::BackendInterface *arg1 = (kdb::tools::BackendInterface *)self;
   20714           0 :     delete arg1;
   20715           0 : }
   20716             : 
   20717             : 
   20718             : /*
   20719             :   Document-class: Kdbtools::SerializeInterface
   20720             : 
   20721             :   Proxy of C++ Kdbtools::SerializeInterface class
   20722             : 
   20723             : 
   20724             : */
   20725             : static swig_class SwigClassSerializeInterface;
   20726             : 
   20727             : 
   20728             : /*
   20729             :   Document-method: Kdbtools::SerializeInterface.serialize
   20730             : 
   20731             :   call-seq:
   20732             :     serialize(KeySet ret)
   20733             : 
   20734             : An instance method.
   20735             : 
   20736             : */
   20737             : SWIGINTERN VALUE
   20738           0 : _wrap_SerializeInterface_serialize(int argc, VALUE *argv, VALUE self) {
   20739           0 :   kdb::tools::SerializeInterface *arg1 = (kdb::tools::SerializeInterface *) 0 ;
   20740           0 :   kdb::KeySet *arg2 = 0 ;
   20741           0 :   void *argp1 = 0 ;
   20742           0 :   int res1 = 0 ;
   20743           0 :   void *argp2 = 0 ;
   20744           0 :   int res2 = 0 ;
   20745             :   
   20746           0 :   if ((argc < 1) || (argc > 1)) {
   20747           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   20748             :   }
   20749           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SerializeInterface, 0 |  0 );
   20750           0 :   if (!SWIG_IsOK(res1)) {
   20751           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SerializeInterface *","serialize", 1, self )); 
   20752             :   }
   20753           0 :   arg1 = reinterpret_cast< kdb::tools::SerializeInterface * >(argp1);
   20754           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   20755           0 :   if (!SWIG_IsOK(res2)) {
   20756           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet &","serialize", 2, argv[0] )); 
   20757             :   }
   20758           0 :   if (!argp2) {
   20759           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","serialize", 2, argv[0])); 
   20760             :   }
   20761           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   20762             :   try {
   20763           0 :     (arg1)->serialize(*arg2);
   20764             :   }
   20765           0 :   catch(kdb::tools::TooManyPlugins &_e) {
   20766           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__TooManyPlugins, SWIG_NewPointerObj((new kdb::tools::TooManyPlugins(static_cast< const kdb::tools::TooManyPlugins& >(_e))),SWIGTYPE_p_kdb__tools__TooManyPlugins,SWIG_POINTER_OWN))); SWIG_fail;
   20767             :   }
   20768           0 :   catch(kdb::tools::OrderingViolation &_e) {
   20769           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__OrderingViolation, SWIG_NewPointerObj((new kdb::tools::OrderingViolation(static_cast< const kdb::tools::OrderingViolation& >(_e))),SWIGTYPE_p_kdb__tools__OrderingViolation,SWIG_POINTER_OWN))); SWIG_fail;
   20770             :   }
   20771           0 :   catch(kdb::tools::ToolException &_e) {
   20772           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   20773             :   }
   20774           0 :   catch(...) {
   20775           0 :     SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
   20776             :   }
   20777             :   
   20778             :   return Qnil;
   20779             : fail:
   20780             :   return Qnil;
   20781             : }
   20782             : 
   20783             : 
   20784             : SWIGINTERN void
   20785           0 : free_kdb_tools_SerializeInterface(void *self) {
   20786           0 :     kdb::tools::SerializeInterface *arg1 = (kdb::tools::SerializeInterface *)self;
   20787           0 :     delete arg1;
   20788           0 : }
   20789             : 
   20790             : 
   20791             : /*
   20792             :   Document-class: Kdbtools::MountBackendInterface < Kdbtools::kdb::tools::BackendInterface, Kdbtools::kdb::tools::SerializeInterface
   20793             : 
   20794             :   Proxy of C++ Kdbtools::MountBackendInterface class
   20795             : 
   20796             : 
   20797             : */
   20798             : static swig_class SwigClassMountBackendInterface;
   20799             : 
   20800             : 
   20801             : /*
   20802             :   Document-method: Kdbtools::MountBackendInterface.validated
   20803             : 
   20804             :   call-seq:
   20805             :     validated -> bool
   20806             : 
   20807             : An instance method.
   20808             : 
   20809             : */
   20810             : SWIGINTERN VALUE
   20811           0 : _wrap_MountBackendInterface_validated(int argc, VALUE *argv, VALUE self) {
   20812           0 :   kdb::tools::MountBackendInterface *arg1 = (kdb::tools::MountBackendInterface *) 0 ;
   20813           0 :   void *argp1 = 0 ;
   20814           0 :   int res1 = 0 ;
   20815             :   bool result;
   20816           0 :   VALUE vresult = Qnil;
   20817             :   
   20818           0 :   if ((argc < 0) || (argc > 0)) {
   20819           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   20820             :   }
   20821           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MountBackendInterface, 0 |  0 );
   20822           0 :   if (!SWIG_IsOK(res1)) {
   20823           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MountBackendInterface const *","validated", 1, self )); 
   20824             :   }
   20825           0 :   arg1 = reinterpret_cast< kdb::tools::MountBackendInterface * >(argp1);
   20826           0 :   result = (bool)((kdb::tools::MountBackendInterface const *)arg1)->validated();
   20827           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   20828             :   return vresult;
   20829             : fail:
   20830             :   return Qnil;
   20831             : }
   20832             : 
   20833             : 
   20834             : 
   20835             : /*
   20836             :   Document-method: Kdbtools::MountBackendInterface.set_mountpoint
   20837             : 
   20838             :   call-seq:
   20839             :     set_mountpoint(Key mountpoint, KeySet mountConf)
   20840             : 
   20841             : An instance method.
   20842             : 
   20843             : */
   20844             : SWIGINTERN VALUE
   20845           0 : _wrap_MountBackendInterface_set_mountpoint(int argc, VALUE *argv, VALUE self) {
   20846           0 :   kdb::tools::MountBackendInterface *arg1 = (kdb::tools::MountBackendInterface *) 0 ;
   20847           0 :   kdb::Key arg2 ;
   20848           0 :   kdb::KeySet arg3 ;
   20849           0 :   void *argp1 = 0 ;
   20850           0 :   int res1 = 0 ;
   20851             :   void *argp2 ;
   20852           0 :   int res2 = 0 ;
   20853             :   void *argp3 ;
   20854           0 :   int res3 = 0 ;
   20855             :   
   20856           0 :   if ((argc < 2) || (argc > 2)) {
   20857           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   20858             :   }
   20859           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MountBackendInterface, 0 |  0 );
   20860           0 :   if (!SWIG_IsOK(res1)) {
   20861           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MountBackendInterface *","setMountpoint", 1, self )); 
   20862             :   }
   20863           0 :   arg1 = reinterpret_cast< kdb::tools::MountBackendInterface * >(argp1);
   20864             :   {
   20865           0 :     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   20866           0 :     if (!SWIG_IsOK(res2)) {
   20867           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::Key","setMountpoint", 2, argv[0] )); 
   20868             :     }  
   20869           0 :     if (!argp2) {
   20870           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key","setMountpoint", 2, argv[0]));
   20871             :     } else {
   20872           0 :       arg2 = *(reinterpret_cast< kdb::Key * >(argp2));
   20873             :     }
   20874             :   }
   20875             :   {
   20876           0 :     res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__KeySet,  0 );
   20877           0 :     if (!SWIG_IsOK(res3)) {
   20878           0 :       SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::KeySet","setMountpoint", 3, argv[1] )); 
   20879             :     }  
   20880           0 :     if (!argp3) {
   20881           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet","setMountpoint", 3, argv[1]));
   20882             :     } else {
   20883           0 :       arg3 = *(reinterpret_cast< kdb::KeySet * >(argp3));
   20884             :     }
   20885             :   }
   20886             :   try {
   20887           0 :     (arg1)->setMountpoint(arg2,arg3);
   20888             :   }
   20889           0 :   catch(kdb::tools::MountpointAlreadyInUseException &_e) {
   20890           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MountpointAlreadyInUseException, SWIG_NewPointerObj((new kdb::tools::MountpointAlreadyInUseException(static_cast< const kdb::tools::MountpointAlreadyInUseException& >(_e))),SWIGTYPE_p_kdb__tools__MountpointAlreadyInUseException,SWIG_POINTER_OWN))); SWIG_fail;
   20891             :   }
   20892           0 :   catch(kdb::tools::MountpointInvalidException &_e) {
   20893           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MountpointInvalidException, SWIG_NewPointerObj((new kdb::tools::MountpointInvalidException(static_cast< const kdb::tools::MountpointInvalidException& >(_e))),SWIGTYPE_p_kdb__tools__MountpointInvalidException,SWIG_POINTER_OWN))); SWIG_fail;
   20894             :   }
   20895           0 :   catch(kdb::tools::BackendCheckException &_e) {
   20896           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BackendCheckException, SWIG_NewPointerObj((new kdb::tools::BackendCheckException(static_cast< const kdb::tools::BackendCheckException& >(_e))),SWIGTYPE_p_kdb__tools__BackendCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   20897             :   }
   20898           0 :   catch(kdb::tools::ToolException &_e) {
   20899           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   20900             :   }
   20901             :   
   20902           0 :   return Qnil;
   20903             : fail:
   20904             :   return Qnil;
   20905             : }
   20906             : 
   20907             : 
   20908             : 
   20909             : /*
   20910             :   Document-method: Kdbtools::MountBackendInterface.get_mountpoint
   20911             : 
   20912             :   call-seq:
   20913             :     get_mountpoint -> std::string
   20914             : 
   20915             : An instance method.
   20916             : 
   20917             : */
   20918             : SWIGINTERN VALUE
   20919           0 : _wrap_MountBackendInterface_get_mountpoint(int argc, VALUE *argv, VALUE self) {
   20920           0 :   kdb::tools::MountBackendInterface *arg1 = (kdb::tools::MountBackendInterface *) 0 ;
   20921           0 :   void *argp1 = 0 ;
   20922           0 :   int res1 = 0 ;
   20923           0 :   std::string result;
   20924           0 :   VALUE vresult = Qnil;
   20925             :   
   20926           0 :   if ((argc < 0) || (argc > 0)) {
   20927           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   20928             :   }
   20929           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MountBackendInterface, 0 |  0 );
   20930           0 :   if (!SWIG_IsOK(res1)) {
   20931           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MountBackendInterface const *","getMountpoint", 1, self )); 
   20932             :   }
   20933           0 :   arg1 = reinterpret_cast< kdb::tools::MountBackendInterface * >(argp1);
   20934           0 :   result = ((kdb::tools::MountBackendInterface const *)arg1)->getMountpoint();
   20935           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   20936           0 :   return vresult;
   20937             : fail:
   20938             :   return Qnil;
   20939             : }
   20940             : 
   20941             : 
   20942             : 
   20943             : /*
   20944             :   Document-method: Kdbtools::MountBackendInterface.set_backend_config
   20945             : 
   20946             :   call-seq:
   20947             :     set_backend_config(KeySet ks)
   20948             : 
   20949             : An instance method.
   20950             : 
   20951             : */
   20952             : SWIGINTERN VALUE
   20953           0 : _wrap_MountBackendInterface_set_backend_config(int argc, VALUE *argv, VALUE self) {
   20954           0 :   kdb::tools::MountBackendInterface *arg1 = (kdb::tools::MountBackendInterface *) 0 ;
   20955           0 :   kdb::KeySet *arg2 = 0 ;
   20956           0 :   void *argp1 = 0 ;
   20957           0 :   int res1 = 0 ;
   20958             :   void *argp2 ;
   20959           0 :   int res2 = 0 ;
   20960             :   
   20961           0 :   if ((argc < 1) || (argc > 1)) {
   20962           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   20963             :   }
   20964           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MountBackendInterface, 0 |  0 );
   20965           0 :   if (!SWIG_IsOK(res1)) {
   20966           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MountBackendInterface *","setBackendConfig", 1, self )); 
   20967             :   }
   20968           0 :   arg1 = reinterpret_cast< kdb::tools::MountBackendInterface * >(argp1);
   20969           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   20970           0 :   if (!SWIG_IsOK(res2)) {
   20971           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet const &","setBackendConfig", 2, argv[0] )); 
   20972             :   }
   20973           0 :   if (!argp2) {
   20974           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet const &","setBackendConfig", 2, argv[0])); 
   20975             :   }
   20976           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   20977           0 :   (arg1)->setBackendConfig((kdb::KeySet const &)*arg2);
   20978             :   return Qnil;
   20979             : fail:
   20980             :   return Qnil;
   20981             : }
   20982             : 
   20983             : 
   20984             : 
   20985             : /*
   20986             :   Document-method: Kdbtools::MountBackendInterface.use_config_file
   20987             : 
   20988             :   call-seq:
   20989             :     use_config_file(std::string file)
   20990             : 
   20991             : An instance method.
   20992             : 
   20993             : */
   20994             : SWIGINTERN VALUE
   20995           0 : _wrap_MountBackendInterface_use_config_file(int argc, VALUE *argv, VALUE self) {
   20996           0 :   kdb::tools::MountBackendInterface *arg1 = (kdb::tools::MountBackendInterface *) 0 ;
   20997           0 :   std::string arg2 ;
   20998           0 :   void *argp1 = 0 ;
   20999           0 :   int res1 = 0 ;
   21000             :   
   21001           0 :   if ((argc < 1) || (argc > 1)) {
   21002           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   21003             :   }
   21004           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MountBackendInterface, 0 |  0 );
   21005           0 :   if (!SWIG_IsOK(res1)) {
   21006           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MountBackendInterface *","useConfigFile", 1, self )); 
   21007             :   }
   21008           0 :   arg1 = reinterpret_cast< kdb::tools::MountBackendInterface * >(argp1);
   21009             :   {
   21010           0 :     std::string *ptr = (std::string *)0;
   21011           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   21012           0 :     if (!SWIG_IsOK(res) || !ptr) {
   21013           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","useConfigFile", 2, argv[0] )); 
   21014             :     }
   21015           0 :     arg2 = *ptr;
   21016           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   21017             :   }
   21018             :   try {
   21019           0 :     (arg1)->useConfigFile(arg2);
   21020             :   }
   21021           0 :   catch(kdb::tools::MissingSymbol &_e) {
   21022           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__MissingSymbol, SWIG_NewPointerObj((new kdb::tools::MissingSymbol(static_cast< const kdb::tools::MissingSymbol& >(_e))),SWIGTYPE_p_kdb__tools__MissingSymbol,SWIG_POINTER_OWN))); SWIG_fail;
   21023             :   }
   21024           0 :   catch(kdb::tools::FileNotValidException &_e) {
   21025           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__FileNotValidException, SWIG_NewPointerObj((new kdb::tools::FileNotValidException(static_cast< const kdb::tools::FileNotValidException& >(_e))),SWIGTYPE_p_kdb__tools__FileNotValidException,SWIG_POINTER_OWN))); SWIG_fail;
   21026             :   }
   21027           0 :   catch(kdb::tools::BackendCheckException &_e) {
   21028           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BackendCheckException, SWIG_NewPointerObj((new kdb::tools::BackendCheckException(static_cast< const kdb::tools::BackendCheckException& >(_e))),SWIGTYPE_p_kdb__tools__BackendCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   21029             :   }
   21030           0 :   catch(kdb::tools::ToolException &_e) {
   21031           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   21032             :   }
   21033             :   
   21034           0 :   return Qnil;
   21035             : fail:
   21036             :   return Qnil;
   21037             : }
   21038             : 
   21039             : 
   21040             : 
   21041             : /*
   21042             :   Document-method: Kdbtools::MountBackendInterface.get_config_file
   21043             : 
   21044             :   call-seq:
   21045             :     get_config_file -> std::string
   21046             : 
   21047             : An instance method.
   21048             : 
   21049             : */
   21050             : SWIGINTERN VALUE
   21051           0 : _wrap_MountBackendInterface_get_config_file(int argc, VALUE *argv, VALUE self) {
   21052           0 :   kdb::tools::MountBackendInterface *arg1 = (kdb::tools::MountBackendInterface *) 0 ;
   21053           0 :   void *argp1 = 0 ;
   21054           0 :   int res1 = 0 ;
   21055           0 :   std::string result;
   21056           0 :   VALUE vresult = Qnil;
   21057             :   
   21058           0 :   if ((argc < 0) || (argc > 0)) {
   21059           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21060             :   }
   21061           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__MountBackendInterface, 0 |  0 );
   21062           0 :   if (!SWIG_IsOK(res1)) {
   21063           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::MountBackendInterface const *","getConfigFile", 1, self )); 
   21064             :   }
   21065           0 :   arg1 = reinterpret_cast< kdb::tools::MountBackendInterface * >(argp1);
   21066           0 :   result = ((kdb::tools::MountBackendInterface const *)arg1)->getConfigFile();
   21067           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   21068           0 :   return vresult;
   21069             : fail:
   21070             :   return Qnil;
   21071             : }
   21072             : 
   21073             : 
   21074             : SWIGINTERN void
   21075           0 : free_kdb_tools_MountBackendInterface(void *self) {
   21076           0 :     kdb::tools::MountBackendInterface *arg1 = (kdb::tools::MountBackendInterface *)self;
   21077           0 :     delete arg1;
   21078           0 : }
   21079             : 
   21080             : 
   21081             : /*
   21082             :   Document-class: Kdbtools::Backend < Kdbtools::kdb::tools::MountBackendInterface
   21083             : 
   21084             :   Proxy of C++ Kdbtools::Backend class
   21085             : 
   21086             : 
   21087             : */
   21088             : static swig_class SwigClassBackend;
   21089             : 
   21090             : 
   21091             : /*
   21092             :   Document-method: Kdbtools::Backend.new
   21093             : 
   21094             :   call-seq:
   21095             :     Backend.new
   21096             :     Backend.new(Backend other)
   21097             : 
   21098             : Class constructor.
   21099             : 
   21100             : */
   21101             : SWIGINTERN VALUE
   21102           0 : _wrap_new_Backend__SWIG_0(int argc, VALUE *argv, VALUE self) {
   21103           0 :   kdb::tools::Backend *result = 0 ;
   21104             :   
   21105           0 :   if ((argc < 0) || (argc > 0)) {
   21106           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21107             :   }
   21108           0 :   result = (kdb::tools::Backend *)new kdb::tools::Backend();
   21109           0 :   DATA_PTR(self) = result;
   21110             :   return self;
   21111             : fail:
   21112             :   return Qnil;
   21113             : }
   21114             : 
   21115             : 
   21116             : SWIGINTERN void
   21117           0 : free_kdb_tools_Backend(void *self) {
   21118           0 :     kdb::tools::Backend *arg1 = (kdb::tools::Backend *)self;
   21119           0 :     delete arg1;
   21120           0 : }
   21121             : 
   21122             : SWIGINTERN VALUE
   21123             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   21124           0 : _wrap_Backend_allocate(VALUE self)
   21125             : #else
   21126             : _wrap_Backend_allocate(int argc, VALUE *argv, VALUE self)
   21127             : #endif
   21128             : {
   21129           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__Backend);
   21130             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   21131             :   rb_obj_call_init(vresult, argc, argv);
   21132             : #endif
   21133           0 :   return vresult;
   21134             : }
   21135             : 
   21136             : 
   21137             : SWIGINTERN VALUE
   21138           0 : _wrap_new_Backend__SWIG_1(int argc, VALUE *argv, VALUE self) {
   21139           0 :   kdb::tools::Backend *arg1 = 0 ;
   21140           0 :   void *argp1 = 0 ;
   21141           0 :   int res1 = 0 ;
   21142           0 :   kdb::tools::Backend *result = 0 ;
   21143             :   
   21144           0 :   if ((argc < 1) || (argc > 1)) {
   21145           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   21146             :   }
   21147           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__tools__Backend,  0 );
   21148           0 :   if (!SWIG_IsOK(res1)) {
   21149           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Backend &&","Backend", 1, argv[0] )); 
   21150             :   }
   21151           0 :   if (!argp1) {
   21152           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::Backend &&","Backend", 1, argv[0])); 
   21153             :   }
   21154           0 :   arg1 = reinterpret_cast< kdb::tools::Backend * >(argp1);
   21155           0 :   result = (kdb::tools::Backend *)new kdb::tools::Backend((kdb::tools::Backend &&)*arg1);
   21156           0 :   DATA_PTR(self) = result;
   21157             :   return self;
   21158             : fail:
   21159             :   return Qnil;
   21160             : }
   21161             : 
   21162             : 
   21163           0 : SWIGINTERN VALUE _wrap_new_Backend(int nargs, VALUE *args, VALUE self) {
   21164             :   int argc;
   21165             :   VALUE argv[1];
   21166             :   int ii;
   21167             :   
   21168           0 :   argc = nargs;
   21169           0 :   if (argc > 1) SWIG_fail;
   21170             :   for (ii = 0; (ii < argc); ++ii) {
   21171             :     argv[ii] = args[ii];
   21172             :   }
   21173           0 :   if (argc == 0) {
   21174           0 :     return _wrap_new_Backend__SWIG_0(nargs, args, self);
   21175             :   }
   21176           0 :   if (argc == 1) {
   21177           0 :     return _wrap_new_Backend__SWIG_1(nargs, args, self);
   21178             :   }
   21179             :   
   21180             : fail:
   21181             :   Ruby_Format_OverloadedError( argc, 1, "Backend.new", 
   21182             :     "    Backend.new()\n"
   21183           0 :     "    Backend.new(kdb::tools::Backend &&other)\n");
   21184             :   
   21185             :   return Qnil;
   21186             : }
   21187             : 
   21188             : 
   21189             : 
   21190             : /*
   21191             :   Document-method: Kdbtools::Backend.status
   21192             : 
   21193             :   call-seq:
   21194             :     status -> std::string
   21195             : 
   21196             : An instance method.
   21197             : 
   21198             : */
   21199             : SWIGINTERN VALUE
   21200           0 : _wrap_Backend_status(int argc, VALUE *argv, VALUE self) {
   21201           0 :   kdb::tools::Backend *arg1 = (kdb::tools::Backend *) 0 ;
   21202           0 :   void *argp1 = 0 ;
   21203           0 :   int res1 = 0 ;
   21204           0 :   std::string result;
   21205           0 :   VALUE vresult = Qnil;
   21206             :   
   21207           0 :   if ((argc < 0) || (argc > 0)) {
   21208           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21209             :   }
   21210           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__Backend, 0 |  0 );
   21211           0 :   if (!SWIG_IsOK(res1)) {
   21212           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::Backend *","status", 1, self )); 
   21213             :   }
   21214           0 :   arg1 = reinterpret_cast< kdb::tools::Backend * >(argp1);
   21215           0 :   result = kdb_tools_Backend_status(arg1);
   21216           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   21217           0 :   return vresult;
   21218             : fail:
   21219             :   return Qnil;
   21220             : }
   21221             : 
   21222             : 
   21223             : 
   21224             : /*
   21225             :   Document-class: Kdbtools::BackendFactory
   21226             : 
   21227             :   Proxy of C++ Kdbtools::BackendFactory class
   21228             : 
   21229             : 
   21230             : */
   21231             : static swig_class SwigClassBackendFactory;
   21232             : 
   21233             : SWIGINTERN VALUE
   21234             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   21235           0 : _wrap_BackendFactory_allocate(VALUE self)
   21236             : #else
   21237             : _wrap_BackendFactory_allocate(int argc, VALUE *argv, VALUE self)
   21238             : #endif
   21239             : {
   21240           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__BackendFactory);
   21241             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   21242             :   rb_obj_call_init(vresult, argc, argv);
   21243             : #endif
   21244           0 :   return vresult;
   21245             : }
   21246             : 
   21247             : 
   21248             : 
   21249             : /*
   21250             :   Document-method: Kdbtools::BackendFactory.new
   21251             : 
   21252             :   call-seq:
   21253             :     BackendFactory.new(std::string whichBackend)
   21254             : 
   21255             : Class constructor.
   21256             : 
   21257             : */
   21258             : SWIGINTERN VALUE
   21259           0 : _wrap_new_BackendFactory(int argc, VALUE *argv, VALUE self) {
   21260           0 :   std::string arg1 ;
   21261           0 :   kdb::tools::BackendFactory *result = 0 ;
   21262             :   
   21263           0 :   if ((argc < 1) || (argc > 1)) {
   21264           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   21265             :   }
   21266             :   {
   21267           0 :     std::string *ptr = (std::string *)0;
   21268           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   21269           0 :     if (!SWIG_IsOK(res) || !ptr) {
   21270           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","BackendFactory", 1, argv[0] )); 
   21271             :     }
   21272           0 :     arg1 = *ptr;
   21273           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   21274             :   }
   21275           0 :   result = (kdb::tools::BackendFactory *)new kdb::tools::BackendFactory(arg1);
   21276           0 :   DATA_PTR(self) = result;
   21277           0 :   return self;
   21278             : fail:
   21279             :   return Qnil;
   21280             : }
   21281             : 
   21282             : 
   21283             : 
   21284             : /*
   21285             :   Document-method: Kdbtools::BackendFactory.create
   21286             : 
   21287             :   call-seq:
   21288             :     create -> kdb::tools::MountBackendInterfacePtr
   21289             : 
   21290             : An instance method.
   21291             : 
   21292             : */
   21293             : SWIGINTERN VALUE
   21294           0 : _wrap_BackendFactory_create(int argc, VALUE *argv, VALUE self) {
   21295           0 :   kdb::tools::BackendFactory *arg1 = (kdb::tools::BackendFactory *) 0 ;
   21296           0 :   void *argp1 = 0 ;
   21297           0 :   int res1 = 0 ;
   21298           0 :   SwigValueWrapper< std::unique_ptr< kdb::tools::MountBackendInterface > > result;
   21299           0 :   VALUE vresult = Qnil;
   21300             :   
   21301           0 :   if ((argc < 0) || (argc > 0)) {
   21302           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21303             :   }
   21304           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendFactory, 0 |  0 );
   21305           0 :   if (!SWIG_IsOK(res1)) {
   21306           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendFactory const *","create", 1, self )); 
   21307             :   }
   21308           0 :   arg1 = reinterpret_cast< kdb::tools::BackendFactory * >(argp1);
   21309             :   try {
   21310           0 :     result = ((kdb::tools::BackendFactory const *)arg1)->create();
   21311             :   }
   21312           0 :   catch(kdb::tools::NoSuchBackend &_e) {
   21313           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__NoSuchBackend, SWIG_NewPointerObj((new kdb::tools::NoSuchBackend(static_cast< const kdb::tools::NoSuchBackend& >(_e))),SWIGTYPE_p_kdb__tools__NoSuchBackend,SWIG_POINTER_OWN))); SWIG_fail;
   21314             :   }
   21315           0 :   catch(kdb::tools::BackendCheckException &_e) {
   21316           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BackendCheckException, SWIG_NewPointerObj((new kdb::tools::BackendCheckException(static_cast< const kdb::tools::BackendCheckException& >(_e))),SWIGTYPE_p_kdb__tools__BackendCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   21317             :   }
   21318           0 :   catch(kdb::tools::ToolException &_e) {
   21319           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   21320             :   }
   21321             :   
   21322             :   {
   21323           0 :     vresult = SWIG_NewPointerObj((&result)->release(), SWIGTYPE_p_kdb__tools__MountBackendInterface, SWIG_POINTER_OWN | 0);
   21324             :   }
   21325           0 :   return vresult;
   21326             : fail:
   21327             :   return Qnil;
   21328             : }
   21329             : 
   21330             : 
   21331             : SWIGINTERN void
   21332           0 : free_kdb_tools_BackendFactory(void *self) {
   21333           0 :     kdb::tools::BackendFactory *arg1 = (kdb::tools::BackendFactory *)self;
   21334           0 :     delete arg1;
   21335           0 : }
   21336             : 
   21337             : 
   21338             : /*
   21339             :   Document-class: Kdbtools::PluginAdder < Kdbtools::kdb::tools::BackendInterface
   21340             : 
   21341             :   Proxy of C++ Kdbtools::PluginAdder class
   21342             : 
   21343             : 
   21344             : */
   21345             : static swig_class SwigClassPluginAdder;
   21346             : 
   21347             : SWIGINTERN VALUE
   21348             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   21349           0 : _wrap_PluginAdder_allocate(VALUE self)
   21350             : #else
   21351             : _wrap_PluginAdder_allocate(int argc, VALUE *argv, VALUE self)
   21352             : #endif
   21353             : {
   21354           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__PluginAdder);
   21355             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   21356             :   rb_obj_call_init(vresult, argc, argv);
   21357             : #endif
   21358           0 :   return vresult;
   21359             : }
   21360             : 
   21361             : 
   21362             : 
   21363             : /*
   21364             :   Document-method: Kdbtools::PluginAdder.new
   21365             : 
   21366             :   call-seq:
   21367             :     PluginAdder.new
   21368             : 
   21369             : Class constructor.
   21370             : 
   21371             : */
   21372             : SWIGINTERN VALUE
   21373           0 : _wrap_new_PluginAdder(int argc, VALUE *argv, VALUE self) {
   21374           0 :   kdb::tools::PluginAdder *result = 0 ;
   21375             :   
   21376           0 :   if ((argc < 0) || (argc > 0)) {
   21377           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21378             :   }
   21379           0 :   result = (kdb::tools::PluginAdder *)new kdb::tools::PluginAdder();
   21380           0 :   DATA_PTR(self) = result;
   21381             :   return self;
   21382             : fail:
   21383             :   return Qnil;
   21384             : }
   21385             : 
   21386             : 
   21387             : SWIGINTERN void
   21388           0 : free_kdb_tools_PluginAdder(void *self) {
   21389           0 :     kdb::tools::PluginAdder *arg1 = (kdb::tools::PluginAdder *)self;
   21390           0 :     delete arg1;
   21391           0 : }
   21392             : 
   21393             : 
   21394             : /*
   21395             :   Document-class: Kdbtools::GlobalPlugins < Kdbtools::kdb::tools::PluginAdder, Kdbtools::kdb::tools::SerializeInterface
   21396             : 
   21397             :   Proxy of C++ Kdbtools::GlobalPlugins class
   21398             : 
   21399             : 
   21400             : */
   21401             : static swig_class SwigClassGlobalPlugins;
   21402             : 
   21403             : SWIGINTERN VALUE
   21404             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   21405           0 : _wrap_GlobalPlugins_allocate(VALUE self)
   21406             : #else
   21407             : _wrap_GlobalPlugins_allocate(int argc, VALUE *argv, VALUE self)
   21408             : #endif
   21409             : {
   21410           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__GlobalPlugins);
   21411             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   21412             :   rb_obj_call_init(vresult, argc, argv);
   21413             : #endif
   21414           0 :   return vresult;
   21415             : }
   21416             : 
   21417             : 
   21418             : 
   21419             : /*
   21420             :   Document-method: Kdbtools::GlobalPlugins.new
   21421             : 
   21422             :   call-seq:
   21423             :     GlobalPlugins.new
   21424             : 
   21425             : Class constructor.
   21426             : 
   21427             : */
   21428             : SWIGINTERN VALUE
   21429           0 : _wrap_new_GlobalPlugins(int argc, VALUE *argv, VALUE self) {
   21430           0 :   kdb::tools::GlobalPlugins *result = 0 ;
   21431             :   
   21432           0 :   if ((argc < 0) || (argc > 0)) {
   21433           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21434             :   }
   21435           0 :   result = (kdb::tools::GlobalPlugins *)new kdb::tools::GlobalPlugins();
   21436           0 :   DATA_PTR(self) = result;
   21437             :   return self;
   21438             : fail:
   21439             :   return Qnil;
   21440             : }
   21441             : 
   21442             : 
   21443             : SWIGINTERN void
   21444           0 : free_kdb_tools_GlobalPlugins(void *self) {
   21445           0 :     kdb::tools::GlobalPlugins *arg1 = (kdb::tools::GlobalPlugins *)self;
   21446           0 :     delete arg1;
   21447           0 : }
   21448             : 
   21449             : 
   21450             : /*
   21451             :   Document-class: Kdbtools::ImportExportBackend < Kdbtools::kdb::tools::PluginAdder
   21452             : 
   21453             :   Proxy of C++ Kdbtools::ImportExportBackend class
   21454             : 
   21455             : 
   21456             : */
   21457             : static swig_class SwigClassImportExportBackend;
   21458             : 
   21459             : SWIGINTERN VALUE
   21460             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   21461           0 : _wrap_ImportExportBackend_allocate(VALUE self)
   21462             : #else
   21463             : _wrap_ImportExportBackend_allocate(int argc, VALUE *argv, VALUE self)
   21464             : #endif
   21465             : {
   21466           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__ImportExportBackend);
   21467             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   21468             :   rb_obj_call_init(vresult, argc, argv);
   21469             : #endif
   21470           0 :   return vresult;
   21471             : }
   21472             : 
   21473             : 
   21474             : 
   21475             : /*
   21476             :   Document-method: Kdbtools::ImportExportBackend.new
   21477             : 
   21478             :   call-seq:
   21479             :     ImportExportBackend.new
   21480             : 
   21481             : Class constructor.
   21482             : 
   21483             : */
   21484             : SWIGINTERN VALUE
   21485           0 : _wrap_new_ImportExportBackend(int argc, VALUE *argv, VALUE self) {
   21486           0 :   kdb::tools::ImportExportBackend *result = 0 ;
   21487             :   
   21488           0 :   if ((argc < 0) || (argc > 0)) {
   21489           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21490             :   }
   21491           0 :   result = (kdb::tools::ImportExportBackend *)new kdb::tools::ImportExportBackend();
   21492           0 :   DATA_PTR(self) = result;
   21493             :   return self;
   21494             : fail:
   21495             :   return Qnil;
   21496             : }
   21497             : 
   21498             : 
   21499             : 
   21500             : /*
   21501             :   Document-method: Kdbtools::ImportExportBackend.status
   21502             : 
   21503             :   call-seq:
   21504             :     status(std::ostream & os)
   21505             :     status -> std::string
   21506             : 
   21507             : An instance method.
   21508             : 
   21509             : */
   21510             : SWIGINTERN VALUE
   21511           0 : _wrap_ImportExportBackend_status__SWIG_0(int argc, VALUE *argv, VALUE self) {
   21512           0 :   kdb::tools::ImportExportBackend *arg1 = (kdb::tools::ImportExportBackend *) 0 ;
   21513           0 :   std::ostream *arg2 = 0 ;
   21514           0 :   void *argp1 = 0 ;
   21515           0 :   int res1 = 0 ;
   21516           0 :   void *argp2 = 0 ;
   21517           0 :   int res2 = 0 ;
   21518             :   
   21519           0 :   if ((argc < 1) || (argc > 1)) {
   21520           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   21521             :   }
   21522           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ImportExportBackend, 0 |  0 );
   21523           0 :   if (!SWIG_IsOK(res1)) {
   21524           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ImportExportBackend const *","status", 1, self )); 
   21525             :   }
   21526           0 :   arg1 = reinterpret_cast< kdb::tools::ImportExportBackend * >(argp1);
   21527           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__ostream,  0 );
   21528           0 :   if (!SWIG_IsOK(res2)) {
   21529           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::ostream &","status", 2, argv[0] )); 
   21530             :   }
   21531           0 :   if (!argp2) {
   21532           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ostream &","status", 2, argv[0])); 
   21533             :   }
   21534           0 :   arg2 = reinterpret_cast< std::ostream * >(argp2);
   21535           0 :   ((kdb::tools::ImportExportBackend const *)arg1)->status(*arg2);
   21536             :   return Qnil;
   21537             : fail:
   21538             :   return Qnil;
   21539             : }
   21540             : 
   21541             : 
   21542             : 
   21543             : /*
   21544             :   Document-method: Kdbtools::ImportExportBackend.import_from_file
   21545             : 
   21546             :   call-seq:
   21547             :     import_from_file(KeySet ks, Key parentKey)
   21548             : 
   21549             : An instance method.
   21550             : 
   21551             : */
   21552             : SWIGINTERN VALUE
   21553           0 : _wrap_ImportExportBackend_import_from_file(int argc, VALUE *argv, VALUE self) {
   21554           0 :   kdb::tools::ImportExportBackend *arg1 = (kdb::tools::ImportExportBackend *) 0 ;
   21555           0 :   kdb::KeySet *arg2 = 0 ;
   21556           0 :   kdb::Key *arg3 = 0 ;
   21557           0 :   void *argp1 = 0 ;
   21558           0 :   int res1 = 0 ;
   21559           0 :   void *argp2 = 0 ;
   21560           0 :   int res2 = 0 ;
   21561             :   void *argp3 ;
   21562           0 :   int res3 = 0 ;
   21563             :   
   21564           0 :   if ((argc < 2) || (argc > 2)) {
   21565           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   21566             :   }
   21567           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ImportExportBackend, 0 |  0 );
   21568           0 :   if (!SWIG_IsOK(res1)) {
   21569           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ImportExportBackend const *","importFromFile", 1, self )); 
   21570             :   }
   21571           0 :   arg1 = reinterpret_cast< kdb::tools::ImportExportBackend * >(argp1);
   21572           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   21573           0 :   if (!SWIG_IsOK(res2)) {
   21574           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet &","importFromFile", 2, argv[0] )); 
   21575             :   }
   21576           0 :   if (!argp2) {
   21577           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","importFromFile", 2, argv[0])); 
   21578             :   }
   21579           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   21580           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__Key,  0 );
   21581           0 :   if (!SWIG_IsOK(res3)) {
   21582           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::Key const &","importFromFile", 3, argv[1] )); 
   21583             :   }
   21584           0 :   if (!argp3) {
   21585           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key const &","importFromFile", 3, argv[1])); 
   21586             :   }
   21587           0 :   arg3 = reinterpret_cast< kdb::Key * >(argp3);
   21588           0 :   ((kdb::tools::ImportExportBackend const *)arg1)->importFromFile(*arg2,(kdb::Key const &)*arg3);
   21589             :   return Qnil;
   21590             : fail:
   21591             :   return Qnil;
   21592             : }
   21593             : 
   21594             : 
   21595             : 
   21596             : /*
   21597             :   Document-method: Kdbtools::ImportExportBackend.export_to_file
   21598             : 
   21599             :   call-seq:
   21600             :     export_to_file(KeySet ks, Key parentKey)
   21601             : 
   21602             : An instance method.
   21603             : 
   21604             : */
   21605             : SWIGINTERN VALUE
   21606           0 : _wrap_ImportExportBackend_export_to_file(int argc, VALUE *argv, VALUE self) {
   21607           0 :   kdb::tools::ImportExportBackend *arg1 = (kdb::tools::ImportExportBackend *) 0 ;
   21608           0 :   kdb::KeySet *arg2 = 0 ;
   21609           0 :   kdb::Key *arg3 = 0 ;
   21610           0 :   void *argp1 = 0 ;
   21611           0 :   int res1 = 0 ;
   21612             :   void *argp2 ;
   21613           0 :   int res2 = 0 ;
   21614             :   void *argp3 ;
   21615           0 :   int res3 = 0 ;
   21616             :   
   21617           0 :   if ((argc < 2) || (argc > 2)) {
   21618           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   21619             :   }
   21620           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ImportExportBackend, 0 |  0 );
   21621           0 :   if (!SWIG_IsOK(res1)) {
   21622           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ImportExportBackend const *","exportToFile", 1, self )); 
   21623             :   }
   21624           0 :   arg1 = reinterpret_cast< kdb::tools::ImportExportBackend * >(argp1);
   21625           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   21626           0 :   if (!SWIG_IsOK(res2)) {
   21627           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet const &","exportToFile", 2, argv[0] )); 
   21628             :   }
   21629           0 :   if (!argp2) {
   21630           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet const &","exportToFile", 2, argv[0])); 
   21631             :   }
   21632           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   21633           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__Key,  0 );
   21634           0 :   if (!SWIG_IsOK(res3)) {
   21635           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "kdb::Key const &","exportToFile", 3, argv[1] )); 
   21636             :   }
   21637           0 :   if (!argp3) {
   21638           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::Key const &","exportToFile", 3, argv[1])); 
   21639             :   }
   21640           0 :   arg3 = reinterpret_cast< kdb::Key * >(argp3);
   21641           0 :   ((kdb::tools::ImportExportBackend const *)arg1)->exportToFile((kdb::KeySet const &)*arg2,(kdb::Key const &)*arg3);
   21642             :   return Qnil;
   21643             : fail:
   21644             :   return Qnil;
   21645             : }
   21646             : 
   21647             : 
   21648             : 
   21649             : /*
   21650             :   Document-method: Kdbtools::ImportExportBackend.status
   21651             : 
   21652             :   call-seq:
   21653             :     status(std::ostream & os)
   21654             :     status -> std::string
   21655             : 
   21656             : An instance method.
   21657             : 
   21658             : */
   21659             : SWIGINTERN VALUE
   21660           0 : _wrap_ImportExportBackend_status__SWIG_1(int argc, VALUE *argv, VALUE self) {
   21661           0 :   kdb::tools::ImportExportBackend *arg1 = (kdb::tools::ImportExportBackend *) 0 ;
   21662           0 :   void *argp1 = 0 ;
   21663           0 :   int res1 = 0 ;
   21664           0 :   std::string result;
   21665           0 :   VALUE vresult = Qnil;
   21666             :   
   21667           0 :   if ((argc < 0) || (argc > 0)) {
   21668           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21669             :   }
   21670           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__ImportExportBackend, 0 |  0 );
   21671           0 :   if (!SWIG_IsOK(res1)) {
   21672           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::ImportExportBackend *","status", 1, self )); 
   21673             :   }
   21674           0 :   arg1 = reinterpret_cast< kdb::tools::ImportExportBackend * >(argp1);
   21675           0 :   result = kdb_tools_ImportExportBackend_status__SWIG_1(arg1);
   21676           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   21677           0 :   return vresult;
   21678             : fail:
   21679             :   return Qnil;
   21680             : }
   21681             : 
   21682             : 
   21683           0 : SWIGINTERN VALUE _wrap_ImportExportBackend_status(int nargs, VALUE *args, VALUE self) {
   21684             :   int argc;
   21685             :   VALUE argv[3];
   21686             :   int ii;
   21687             :   
   21688           0 :   argc = nargs + 1;
   21689             :   argv[0] = self;
   21690           0 :   if (argc > 3) SWIG_fail;
   21691             :   for (ii = 1; (ii < argc); ++ii) {
   21692             :     argv[ii] = args[ii-1];
   21693             :   }
   21694           0 :   if (argc == 1) {
   21695           0 :     return _wrap_ImportExportBackend_status__SWIG_1(nargs, args, self);
   21696             :   }
   21697           0 :   if (argc == 2) {
   21698           0 :     return _wrap_ImportExportBackend_status__SWIG_0(nargs, args, self);
   21699             :   }
   21700             :   
   21701             : fail:
   21702             :   Ruby_Format_OverloadedError( argc, 3, "ImportExportBackend.status", 
   21703             :     "    void ImportExportBackend.status(std::ostream &os)\n"
   21704           0 :     "    std::string ImportExportBackend.status()\n");
   21705             :   
   21706             :   return Qnil;
   21707             : }
   21708             : 
   21709             : 
   21710             : SWIGINTERN void
   21711           0 : free_kdb_tools_ImportExportBackend(void *self) {
   21712           0 :     kdb::tools::ImportExportBackend *arg1 = (kdb::tools::ImportExportBackend *)self;
   21713           0 :     delete arg1;
   21714           0 : }
   21715             : 
   21716             : 
   21717             : /*
   21718             :   Document-class: Kdbtools::BackendInfoVector
   21719             : 
   21720             :   Proxy of C++ Kdbtools::BackendInfoVector class
   21721             : 
   21722             : 
   21723             : */
   21724             : static swig_class SwigClassBackendInfoVector;
   21725             : 
   21726             : 
   21727             : /*
   21728             :   Document-method: Kdbtools::BackendInfoVector.dup
   21729             : 
   21730             :   call-seq:
   21731             :     dup -> BackendInfoVector
   21732             : 
   21733             : Create a duplicate of the class and unfreeze it if needed.
   21734             : */
   21735             : SWIGINTERN VALUE
   21736           0 : _wrap_BackendInfoVector_dup(int argc, VALUE *argv, VALUE self) {
   21737           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   21738           0 :   void *argp1 = 0 ;
   21739           0 :   int res1 = 0 ;
   21740           0 :   std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *result = 0 ;
   21741           0 :   VALUE vresult = Qnil;
   21742             :   
   21743           0 :   if ((argc < 0) || (argc > 0)) {
   21744           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21745             :   }
   21746           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   21747           0 :   if (!SWIG_IsOK(res1)) {
   21748           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","dup", 1, self )); 
   21749             :   }
   21750           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   21751           0 :   result = (std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *)std_vector_Sl_kdb_tools_BackendInfo_Sg__dup(arg1);
   21752           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, SWIG_POINTER_OWN |  0 );
   21753             :   return vresult;
   21754             : fail:
   21755             :   return Qnil;
   21756             : }
   21757             : 
   21758             : 
   21759             : 
   21760             : /*
   21761             :   Document-method: Kdbtools::BackendInfoVector.inspect
   21762             : 
   21763             :   call-seq:
   21764             :     inspect -> VALUE
   21765             : 
   21766             : Inspect class and its contents.
   21767             : */
   21768             : SWIGINTERN VALUE
   21769           0 : _wrap_BackendInfoVector_inspect(int argc, VALUE *argv, VALUE self) {
   21770           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   21771           0 :   void *argp1 = 0 ;
   21772           0 :   int res1 = 0 ;
   21773             :   VALUE result;
   21774           0 :   VALUE vresult = Qnil;
   21775             :   
   21776           0 :   if ((argc < 0) || (argc > 0)) {
   21777           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21778             :   }
   21779           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   21780           0 :   if (!SWIG_IsOK(res1)) {
   21781           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","inspect", 1, self )); 
   21782             :   }
   21783           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   21784           0 :   result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg__inspect(arg1);
   21785           0 :   vresult = result;
   21786             :   return vresult;
   21787             : fail:
   21788             :   return Qnil;
   21789             : }
   21790             : 
   21791             : 
   21792             : 
   21793             : /*
   21794             :   Document-method: Kdbtools::BackendInfoVector.to_a
   21795             : 
   21796             :   call-seq:
   21797             :     to_a -> VALUE
   21798             : 
   21799             : Convert BackendInfoVector to an Array.
   21800             : */
   21801             : SWIGINTERN VALUE
   21802           0 : _wrap_BackendInfoVector_to_a(int argc, VALUE *argv, VALUE self) {
   21803           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   21804           0 :   void *argp1 = 0 ;
   21805           0 :   int res1 = 0 ;
   21806             :   VALUE result;
   21807           0 :   VALUE vresult = Qnil;
   21808             :   
   21809           0 :   if ((argc < 0) || (argc > 0)) {
   21810           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21811             :   }
   21812           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   21813           0 :   if (!SWIG_IsOK(res1)) {
   21814           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","to_a", 1, self )); 
   21815             :   }
   21816           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   21817           0 :   result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg__to_a(arg1);
   21818           0 :   vresult = result;
   21819             :   return vresult;
   21820             : fail:
   21821             :   return Qnil;
   21822             : }
   21823             : 
   21824             : 
   21825             : 
   21826             : /*
   21827             :   Document-method: Kdbtools::BackendInfoVector.to_s
   21828             : 
   21829             :   call-seq:
   21830             :     to_s -> VALUE
   21831             : 
   21832             : Convert class to a String representation.
   21833             : */
   21834             : SWIGINTERN VALUE
   21835           0 : _wrap_BackendInfoVector_to_s(int argc, VALUE *argv, VALUE self) {
   21836           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   21837           0 :   void *argp1 = 0 ;
   21838           0 :   int res1 = 0 ;
   21839             :   VALUE result;
   21840           0 :   VALUE vresult = Qnil;
   21841             :   
   21842           0 :   if ((argc < 0) || (argc > 0)) {
   21843           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21844             :   }
   21845           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   21846           0 :   if (!SWIG_IsOK(res1)) {
   21847           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","to_s", 1, self )); 
   21848             :   }
   21849           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   21850           0 :   result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg__to_s(arg1);
   21851           0 :   vresult = result;
   21852             :   return vresult;
   21853             : fail:
   21854             :   return Qnil;
   21855             : }
   21856             : 
   21857             : 
   21858             : 
   21859             : /*
   21860             :   Document-method: Kdbtools::BackendInfoVector.slice
   21861             : 
   21862             :   call-seq:
   21863             :     slice(i, length) -> VALUE
   21864             : 
   21865             : Return a slice (portion of) the BackendInfoVector.
   21866             : */
   21867             : SWIGINTERN VALUE
   21868           0 : _wrap_BackendInfoVector_slice(int argc, VALUE *argv, VALUE self) {
   21869           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   21870             :   std::vector< kdb::tools::BackendInfo >::difference_type arg2 ;
   21871             :   std::vector< kdb::tools::BackendInfo >::difference_type arg3 ;
   21872           0 :   void *argp1 = 0 ;
   21873           0 :   int res1 = 0 ;
   21874             :   ptrdiff_t val2 ;
   21875           0 :   int ecode2 = 0 ;
   21876             :   ptrdiff_t val3 ;
   21877           0 :   int ecode3 = 0 ;
   21878             :   VALUE result;
   21879           0 :   VALUE vresult = Qnil;
   21880             :   
   21881           0 :   if ((argc < 2) || (argc > 2)) {
   21882           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   21883             :   }
   21884           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   21885           0 :   if (!SWIG_IsOK(res1)) {
   21886           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","slice", 1, self )); 
   21887             :   }
   21888           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   21889           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   21890           0 :   if (!SWIG_IsOK(ecode2)) {
   21891           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::difference_type","slice", 2, argv[0] ));
   21892             :   } 
   21893           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::difference_type >(val2);
   21894           0 :   ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
   21895           0 :   if (!SWIG_IsOK(ecode3)) {
   21896           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::difference_type","slice", 3, argv[1] ));
   21897             :   } 
   21898           0 :   arg3 = static_cast< std::vector< kdb::tools::BackendInfo >::difference_type >(val3);
   21899             :   try {
   21900           0 :     result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg__slice(arg1,arg2,arg3);
   21901             :   }
   21902           0 :   catch(std::invalid_argument &_e) {
   21903           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
   21904             :   }
   21905             :   
   21906           0 :   vresult = result;
   21907             :   return vresult;
   21908             : fail:
   21909             :   return Qnil;
   21910             : }
   21911             : 
   21912             : 
   21913             : 
   21914             : /*
   21915             :   Document-method: Kdbtools::BackendInfoVector.each
   21916             : 
   21917             :   call-seq:
   21918             :     each -> BackendInfoVector
   21919             : 
   21920             : Iterate thru each element in the BackendInfoVector.  A block must be provided.
   21921             : */
   21922             : SWIGINTERN VALUE
   21923           0 : _wrap_BackendInfoVector_each(int argc, VALUE *argv, VALUE self) {
   21924           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   21925           0 :   void *argp1 = 0 ;
   21926           0 :   int res1 = 0 ;
   21927           0 :   std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *result = 0 ;
   21928           0 :   VALUE vresult = Qnil;
   21929             :   
   21930           0 :   if ((argc < 0) || (argc > 0)) {
   21931           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   21932             :   }
   21933           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   21934           0 :   if (!SWIG_IsOK(res1)) {
   21935           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","each", 1, self )); 
   21936             :   }
   21937           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   21938           0 :   result = (std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *)std_vector_Sl_kdb_tools_BackendInfo_Sg__each(arg1);
   21939           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   21940             :   return vresult;
   21941             : fail:
   21942             :   return Qnil;
   21943             : }
   21944             : 
   21945             : 
   21946             : 
   21947             : /*
   21948             :   Document-method: Kdbtools::BackendInfoVector.__delete_2__
   21949             : 
   21950             :   call-seq:
   21951             :     __delete_2__(BackendInfo i) -> VALUE
   21952             : 
   21953             : An instance method.
   21954             : 
   21955             : */
   21956             : SWIGINTERN VALUE
   21957           0 : _wrap_BackendInfoVector___delete_2__(int argc, VALUE *argv, VALUE self) {
   21958           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   21959           0 :   std::vector< kdb::tools::BackendInfo >::value_type *arg2 = 0 ;
   21960           0 :   void *argp1 = 0 ;
   21961           0 :   int res1 = 0 ;
   21962             :   void *argp2 ;
   21963           0 :   int res2 = 0 ;
   21964             :   VALUE result;
   21965           0 :   VALUE vresult = Qnil;
   21966             :   
   21967           0 :   if ((argc < 1) || (argc > 1)) {
   21968           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   21969             :   }
   21970           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   21971           0 :   if (!SWIG_IsOK(res1)) {
   21972           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","__delete2__", 1, self )); 
   21973             :   }
   21974           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   21975           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__BackendInfo,  0 );
   21976           0 :   if (!SWIG_IsOK(res2)) {
   21977           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::value_type const &","__delete2__", 2, argv[0] )); 
   21978             :   }
   21979           0 :   if (!argp2) {
   21980           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::BackendInfo >::value_type const &","__delete2__", 2, argv[0])); 
   21981             :   }
   21982           0 :   arg2 = reinterpret_cast< std::vector< kdb::tools::BackendInfo >::value_type * >(argp2);
   21983           0 :   result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg____delete2__(arg1,(kdb::tools::BackendInfo const &)*arg2);
   21984           0 :   vresult = result;
   21985             :   return vresult;
   21986             : fail:
   21987             :   return Qnil;
   21988             : }
   21989             : 
   21990             : 
   21991             : 
   21992             : /*
   21993             :   Document-method: Kdbtools::BackendInfoVector.select
   21994             : 
   21995             :   call-seq:
   21996             :     select -> BackendInfoVector
   21997             : 
   21998             : Iterate thru each element in the BackendInfoVector and select those that match a condition.  A block must be provided.
   21999             : */
   22000             : SWIGINTERN VALUE
   22001           0 : _wrap_BackendInfoVector_select(int argc, VALUE *argv, VALUE self) {
   22002           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22003           0 :   void *argp1 = 0 ;
   22004           0 :   int res1 = 0 ;
   22005           0 :   std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *result = 0 ;
   22006           0 :   VALUE vresult = Qnil;
   22007             :   
   22008           0 :   if ((argc < 0) || (argc > 0)) {
   22009           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   22010             :   }
   22011           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22012           0 :   if (!SWIG_IsOK(res1)) {
   22013           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","select", 1, self )); 
   22014             :   }
   22015           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22016           0 :   result = (std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *)std_vector_Sl_kdb_tools_BackendInfo_Sg__select(arg1);
   22017           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, SWIG_POINTER_OWN |  0 );
   22018             :   return vresult;
   22019             : fail:
   22020             :   return Qnil;
   22021             : }
   22022             : 
   22023             : 
   22024             : 
   22025             : /*
   22026             :   Document-method: Kdbtools::BackendInfoVector.delete_at
   22027             : 
   22028             :   call-seq:
   22029             :     delete_at(i) -> VALUE
   22030             : 
   22031             : Delete an element at a certain index.
   22032             : */
   22033             : SWIGINTERN VALUE
   22034           0 : _wrap_BackendInfoVector_delete_at(int argc, VALUE *argv, VALUE self) {
   22035           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22036             :   std::vector< kdb::tools::BackendInfo >::difference_type arg2 ;
   22037           0 :   void *argp1 = 0 ;
   22038           0 :   int res1 = 0 ;
   22039             :   ptrdiff_t val2 ;
   22040           0 :   int ecode2 = 0 ;
   22041             :   VALUE result;
   22042           0 :   VALUE vresult = Qnil;
   22043             :   
   22044           0 :   if ((argc < 1) || (argc > 1)) {
   22045           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   22046             :   }
   22047           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22048           0 :   if (!SWIG_IsOK(res1)) {
   22049           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","delete_at", 1, self )); 
   22050             :   }
   22051           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22052           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   22053           0 :   if (!SWIG_IsOK(ecode2)) {
   22054           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::difference_type","delete_at", 2, argv[0] ));
   22055             :   } 
   22056           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::difference_type >(val2);
   22057           0 :   result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg__delete_at(arg1,arg2);
   22058           0 :   vresult = result;
   22059             :   return vresult;
   22060             : fail:
   22061             :   return Qnil;
   22062             : }
   22063             : 
   22064             : 
   22065             : 
   22066             : /*
   22067             :   Document-method: Kdbtools::BackendInfoVector.at
   22068             : 
   22069             :   call-seq:
   22070             :     at(i) -> VALUE
   22071             : 
   22072             : Return element at a certain index.
   22073             : */
   22074             : SWIGINTERN VALUE
   22075           0 : _wrap_BackendInfoVector_at(int argc, VALUE *argv, VALUE self) {
   22076           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22077             :   std::vector< kdb::tools::BackendInfo >::difference_type arg2 ;
   22078           0 :   void *argp1 = 0 ;
   22079           0 :   int res1 = 0 ;
   22080             :   ptrdiff_t val2 ;
   22081           0 :   int ecode2 = 0 ;
   22082             :   VALUE result;
   22083           0 :   VALUE vresult = Qnil;
   22084             :   
   22085           0 :   if ((argc < 1) || (argc > 1)) {
   22086           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   22087             :   }
   22088           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22089           0 :   if (!SWIG_IsOK(res1)) {
   22090           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > const *","at", 1, self )); 
   22091             :   }
   22092           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22093           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   22094           0 :   if (!SWIG_IsOK(ecode2)) {
   22095           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::difference_type","at", 2, argv[0] ));
   22096             :   } 
   22097           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::difference_type >(val2);
   22098           0 :   result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg__at((std::vector< kdb::tools::BackendInfo > const *)arg1,arg2);
   22099           0 :   vresult = result;
   22100             :   return vresult;
   22101             : fail:
   22102             :   return Qnil;
   22103             : }
   22104             : 
   22105             : 
   22106             : 
   22107             : /*
   22108             :   Document-method: Kdbtools::BackendInfoVector.[]
   22109             : 
   22110             :   call-seq:
   22111             :     [](i, length) -> VALUE
   22112             :     [](i) -> VALUE
   22113             :     [](i) -> VALUE
   22114             : 
   22115             : Element accessor/slicing.
   22116             : */
   22117             : SWIGINTERN VALUE
   22118           0 : _wrap_BackendInfoVector___getitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
   22119           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22120             :   std::vector< kdb::tools::BackendInfo >::difference_type arg2 ;
   22121             :   std::vector< kdb::tools::BackendInfo >::difference_type arg3 ;
   22122           0 :   void *argp1 = 0 ;
   22123           0 :   int res1 = 0 ;
   22124             :   ptrdiff_t val2 ;
   22125           0 :   int ecode2 = 0 ;
   22126             :   ptrdiff_t val3 ;
   22127           0 :   int ecode3 = 0 ;
   22128             :   VALUE result;
   22129           0 :   VALUE vresult = Qnil;
   22130             :   
   22131           0 :   if ((argc < 2) || (argc > 2)) {
   22132           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   22133             :   }
   22134           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22135           0 :   if (!SWIG_IsOK(res1)) {
   22136           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > const *","__getitem__", 1, self )); 
   22137             :   }
   22138           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22139           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   22140           0 :   if (!SWIG_IsOK(ecode2)) {
   22141           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::difference_type","__getitem__", 2, argv[0] ));
   22142             :   } 
   22143           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::difference_type >(val2);
   22144           0 :   ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
   22145           0 :   if (!SWIG_IsOK(ecode3)) {
   22146           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::difference_type","__getitem__", 3, argv[1] ));
   22147             :   } 
   22148           0 :   arg3 = static_cast< std::vector< kdb::tools::BackendInfo >::difference_type >(val3);
   22149             :   try {
   22150           0 :     result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg____getitem____SWIG_0((std::vector< kdb::tools::BackendInfo > const *)arg1,arg2,arg3);
   22151             :   }
   22152           0 :   catch(std::invalid_argument &_e) {
   22153           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
   22154             :   }
   22155             :   
   22156           0 :   vresult = result;
   22157             :   return vresult;
   22158             : fail:
   22159             :   return Qnil;
   22160             : }
   22161             : 
   22162             : 
   22163             : SWIGINTERN VALUE
   22164           0 : _wrap_BackendInfoVector___getitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
   22165           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22166             :   std::vector< kdb::tools::BackendInfo >::difference_type arg2 ;
   22167           0 :   void *argp1 = 0 ;
   22168           0 :   int res1 = 0 ;
   22169             :   ptrdiff_t val2 ;
   22170           0 :   int ecode2 = 0 ;
   22171             :   VALUE result;
   22172           0 :   VALUE vresult = Qnil;
   22173             :   
   22174           0 :   if ((argc < 1) || (argc > 1)) {
   22175           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   22176             :   }
   22177           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22178           0 :   if (!SWIG_IsOK(res1)) {
   22179           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > const *","__getitem__", 1, self )); 
   22180             :   }
   22181           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22182           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   22183           0 :   if (!SWIG_IsOK(ecode2)) {
   22184           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::difference_type","__getitem__", 2, argv[0] ));
   22185             :   } 
   22186           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::difference_type >(val2);
   22187           0 :   result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg____getitem____SWIG_1((std::vector< kdb::tools::BackendInfo > const *)arg1,arg2);
   22188           0 :   vresult = result;
   22189             :   return vresult;
   22190             : fail:
   22191             :   return Qnil;
   22192             : }
   22193             : 
   22194             : 
   22195             : SWIGINTERN VALUE
   22196           0 : _wrap_BackendInfoVector___getitem____SWIG_2(int argc, VALUE *argv, VALUE self) {
   22197           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22198           0 :   VALUE arg2 = (VALUE) 0 ;
   22199           0 :   void *argp1 = 0 ;
   22200           0 :   int res1 = 0 ;
   22201             :   VALUE result;
   22202           0 :   VALUE vresult = Qnil;
   22203             :   
   22204           0 :   if ((argc < 1) || (argc > 1)) {
   22205           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   22206             :   }
   22207           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22208           0 :   if (!SWIG_IsOK(res1)) {
   22209           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > const *","__getitem__", 1, self )); 
   22210             :   }
   22211           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22212           0 :   arg2 = argv[0];
   22213             :   try {
   22214           0 :     result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg____getitem____SWIG_2((std::vector< kdb::tools::BackendInfo > const *)arg1,arg2);
   22215             :   }
   22216           0 :   catch(std::invalid_argument &_e) {
   22217           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
   22218             :   }
   22219             :   
   22220           0 :   vresult = result;
   22221             :   return vresult;
   22222             : fail:
   22223             :   return Qnil;
   22224             : }
   22225             : 
   22226             : 
   22227           0 : SWIGINTERN VALUE _wrap_BackendInfoVector___getitem__(int nargs, VALUE *args, VALUE self) {
   22228             :   int argc;
   22229             :   VALUE argv[4];
   22230             :   int ii;
   22231             :   
   22232           0 :   argc = nargs + 1;
   22233             :   argv[0] = self;
   22234           0 :   if (argc > 4) SWIG_fail;
   22235           0 :   for (ii = 1; (ii < argc); ++ii) {
   22236           0 :     argv[ii] = args[ii-1];
   22237             :   }
   22238           0 :   if (argc == 2) {
   22239           0 :     int _v = 0;
   22240             :     {
   22241             :       {
   22242           0 :         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
   22243           0 :         _v = SWIG_CheckState(res);
   22244             :       }
   22245             :     }
   22246           0 :     if (!_v) goto check_1;
   22247           0 :     return _wrap_BackendInfoVector___getitem____SWIG_1(nargs, args, self);
   22248             :   }
   22249             : check_1:
   22250             :   
   22251           0 :   if (argc == 2) {
   22252           0 :     return _wrap_BackendInfoVector___getitem____SWIG_2(nargs, args, self);
   22253             :   }
   22254           0 :   if (argc == 3) {
   22255           0 :     return _wrap_BackendInfoVector___getitem____SWIG_0(nargs, args, self);
   22256             :   }
   22257             :   
   22258             : fail:
   22259             :   Ruby_Format_OverloadedError( argc, 4, "__getitem__", 
   22260             :     "    VALUE __getitem__(std::vector< kdb::tools::BackendInfo >::difference_type i, std::vector< kdb::tools::BackendInfo >::difference_type length)\n"
   22261             :     "    VALUE __getitem__(std::vector< kdb::tools::BackendInfo >::difference_type i)\n"
   22262           0 :     "    VALUE __getitem__(VALUE i)\n");
   22263             :   
   22264             :   return Qnil;
   22265             : }
   22266             : 
   22267             : 
   22268             : 
   22269             : /*
   22270             :   Document-method: Kdbtools::BackendInfoVector.[]=
   22271             : 
   22272             :   call-seq:
   22273             :     []=(i, x) -> VALUE
   22274             :     []=(i, length, v) -> VALUE
   22275             : 
   22276             : Element setter/slicing.
   22277             : */
   22278             : SWIGINTERN VALUE
   22279           0 : _wrap_BackendInfoVector___setitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
   22280           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22281             :   std::vector< kdb::tools::BackendInfo >::difference_type arg2 ;
   22282           0 :   std::vector< kdb::tools::BackendInfo >::value_type *arg3 = 0 ;
   22283           0 :   void *argp1 = 0 ;
   22284           0 :   int res1 = 0 ;
   22285             :   ptrdiff_t val2 ;
   22286           0 :   int ecode2 = 0 ;
   22287             :   void *argp3 ;
   22288           0 :   int res3 = 0 ;
   22289             :   VALUE result;
   22290           0 :   VALUE vresult = Qnil;
   22291             :   
   22292           0 :   if ((argc < 2) || (argc > 2)) {
   22293           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   22294             :   }
   22295           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22296           0 :   if (!SWIG_IsOK(res1)) {
   22297           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","__setitem__", 1, self )); 
   22298             :   }
   22299           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22300           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   22301           0 :   if (!SWIG_IsOK(ecode2)) {
   22302           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::difference_type","__setitem__", 2, argv[0] ));
   22303             :   } 
   22304           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::difference_type >(val2);
   22305           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__tools__BackendInfo,  0 );
   22306           0 :   if (!SWIG_IsOK(res3)) {
   22307           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::value_type const &","__setitem__", 3, argv[1] )); 
   22308             :   }
   22309           0 :   if (!argp3) {
   22310           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::BackendInfo >::value_type const &","__setitem__", 3, argv[1])); 
   22311             :   }
   22312           0 :   arg3 = reinterpret_cast< std::vector< kdb::tools::BackendInfo >::value_type * >(argp3);
   22313             :   try {
   22314           0 :     result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg____setitem____SWIG_0(arg1,arg2,(kdb::tools::BackendInfo const &)*arg3);
   22315             :   }
   22316           0 :   catch(std::invalid_argument &_e) {
   22317           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
   22318             :   }
   22319           0 :   catch(std::out_of_range &_e) {
   22320           0 :     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   22321             :   }
   22322             :   
   22323           0 :   vresult = result;
   22324             :   return vresult;
   22325             : fail:
   22326             :   return Qnil;
   22327             : }
   22328             : 
   22329             : 
   22330             : SWIGINTERN VALUE
   22331           0 : _wrap_BackendInfoVector___setitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
   22332           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22333             :   std::vector< kdb::tools::BackendInfo >::difference_type arg2 ;
   22334             :   std::vector< kdb::tools::BackendInfo >::difference_type arg3 ;
   22335           0 :   std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *arg4 = 0 ;
   22336           0 :   void *argp1 = 0 ;
   22337           0 :   int res1 = 0 ;
   22338             :   ptrdiff_t val2 ;
   22339           0 :   int ecode2 = 0 ;
   22340             :   ptrdiff_t val3 ;
   22341           0 :   int ecode3 = 0 ;
   22342           0 :   int res4 = SWIG_OLDOBJ ;
   22343             :   VALUE result;
   22344           0 :   VALUE vresult = Qnil;
   22345             :   
   22346           0 :   if ((argc < 3) || (argc > 3)) {
   22347           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   22348             :   }
   22349           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22350           0 :   if (!SWIG_IsOK(res1)) {
   22351           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","__setitem__", 1, self )); 
   22352             :   }
   22353           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22354           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   22355           0 :   if (!SWIG_IsOK(ecode2)) {
   22356           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::difference_type","__setitem__", 2, argv[0] ));
   22357             :   } 
   22358           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::difference_type >(val2);
   22359           0 :   ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
   22360           0 :   if (!SWIG_IsOK(ecode3)) {
   22361           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::difference_type","__setitem__", 3, argv[1] ));
   22362             :   } 
   22363           0 :   arg3 = static_cast< std::vector< kdb::tools::BackendInfo >::difference_type >(val3);
   22364             :   {
   22365           0 :     std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *ptr = (std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *)0;
   22366           0 :     res4 = swig::asptr(argv[2], &ptr);
   22367           0 :     if (!SWIG_IsOK(res4)) {
   22368           0 :       SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > const &","__setitem__", 4, argv[2] )); 
   22369             :     }
   22370           0 :     if (!ptr) {
   22371           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > const &","__setitem__", 4, argv[2])); 
   22372             :     }
   22373           0 :     arg4 = ptr;
   22374             :   }
   22375             :   try {
   22376           0 :     result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg____setitem____SWIG_1(arg1,arg2,arg3,(std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > const &)*arg4);
   22377             :   }
   22378           0 :   catch(std::invalid_argument &_e) {
   22379           0 :     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
   22380             :   }
   22381             :   
   22382           0 :   vresult = result;
   22383           0 :   if (SWIG_IsNewObj(res4)) delete arg4;
   22384             :   return vresult;
   22385             : fail:
   22386             :   if (SWIG_IsNewObj(res4)) delete arg4;
   22387             :   return Qnil;
   22388             : }
   22389             : 
   22390             : 
   22391           0 : SWIGINTERN VALUE _wrap_BackendInfoVector___setitem__(int nargs, VALUE *args, VALUE self) {
   22392             :   int argc;
   22393             :   VALUE argv[5];
   22394             :   int ii;
   22395             :   
   22396           0 :   argc = nargs + 1;
   22397             :   argv[0] = self;
   22398           0 :   if (argc > 5) SWIG_fail;
   22399             :   for (ii = 1; (ii < argc); ++ii) {
   22400             :     argv[ii] = args[ii-1];
   22401             :   }
   22402           0 :   if (argc == 3) {
   22403           0 :     return _wrap_BackendInfoVector___setitem____SWIG_0(nargs, args, self);
   22404             :   }
   22405           0 :   if (argc == 4) {
   22406           0 :     return _wrap_BackendInfoVector___setitem____SWIG_1(nargs, args, self);
   22407             :   }
   22408             :   
   22409             : fail:
   22410             :   Ruby_Format_OverloadedError( argc, 5, "__setitem__", 
   22411             :     "    VALUE __setitem__(std::vector< kdb::tools::BackendInfo >::difference_type i, std::vector< kdb::tools::BackendInfo >::value_type const &x)\n"
   22412           0 :     "    VALUE __setitem__(std::vector< kdb::tools::BackendInfo >::difference_type i, std::vector< kdb::tools::BackendInfo >::difference_type length, std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > const &v)\n");
   22413             :   
   22414             :   return Qnil;
   22415             : }
   22416             : 
   22417             : 
   22418             : 
   22419             : /*
   22420             :   Document-method: Kdbtools::BackendInfoVector.reject_bang
   22421             : 
   22422             :   call-seq:
   22423             :     reject_bang -> BackendInfoVector
   22424             : 
   22425             : Iterate thru each element in the BackendInfoVector and reject those that fail a condition.  A block must be provided.  BackendInfoVector is modified in place.
   22426             : */
   22427             : SWIGINTERN VALUE
   22428           0 : _wrap_BackendInfoVector_reject_bang(int argc, VALUE *argv, VALUE self) {
   22429           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22430           0 :   void *argp1 = 0 ;
   22431           0 :   int res1 = 0 ;
   22432           0 :   std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *result = 0 ;
   22433           0 :   VALUE vresult = Qnil;
   22434             :   
   22435           0 :   if ((argc < 0) || (argc > 0)) {
   22436           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   22437             :   }
   22438           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22439           0 :   if (!SWIG_IsOK(res1)) {
   22440           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","reject_bang", 1, self )); 
   22441             :   }
   22442           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22443           0 :   result = (std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *)std_vector_Sl_kdb_tools_BackendInfo_Sg__reject_bang(arg1);
   22444           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22445             :   return vresult;
   22446             : fail:
   22447             :   return Qnil;
   22448             : }
   22449             : 
   22450             : 
   22451             : 
   22452             : /*
   22453             :   Document-method: Kdbtools::BackendInfoVector.pop
   22454             : 
   22455             :   call-seq:
   22456             :     pop -> VALUE
   22457             : 
   22458             : Remove and return element at the end of the BackendInfoVector.
   22459             : */
   22460             : SWIGINTERN VALUE
   22461           0 : _wrap_BackendInfoVector_pop(int argc, VALUE *argv, VALUE self) {
   22462           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22463           0 :   void *argp1 = 0 ;
   22464           0 :   int res1 = 0 ;
   22465             :   VALUE result;
   22466           0 :   VALUE vresult = Qnil;
   22467             :   
   22468           0 :   if ((argc < 0) || (argc > 0)) {
   22469           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   22470             :   }
   22471           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22472           0 :   if (!SWIG_IsOK(res1)) {
   22473           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","pop", 1, self )); 
   22474             :   }
   22475           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22476           0 :   result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg__pop(arg1);
   22477           0 :   vresult = result;
   22478             :   return vresult;
   22479             : fail:
   22480             :   return Qnil;
   22481             : }
   22482             : 
   22483             : 
   22484             : 
   22485             : /*
   22486             :   Document-method: Kdbtools::BackendInfoVector.push
   22487             : 
   22488             :   call-seq:
   22489             :     push(e) -> BackendInfo
   22490             : 
   22491             : Add an element at the end of the BackendInfoVector.
   22492             : */
   22493             : SWIGINTERN VALUE
   22494           0 : _wrap_BackendInfoVector_push(int argc, VALUE *argv, VALUE self) {
   22495           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22496           0 :   std::vector< kdb::tools::BackendInfo >::value_type *arg2 = 0 ;
   22497           0 :   void *argp1 = 0 ;
   22498           0 :   int res1 = 0 ;
   22499             :   void *argp2 ;
   22500           0 :   int res2 = 0 ;
   22501           0 :   std::vector< kdb::tools::BackendInfo >::value_type result;
   22502           0 :   VALUE vresult = Qnil;
   22503             :   
   22504           0 :   if ((argc < 1) || (argc > 1)) {
   22505           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   22506             :   }
   22507           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22508           0 :   if (!SWIG_IsOK(res1)) {
   22509           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","push", 1, self )); 
   22510             :   }
   22511           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22512           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__BackendInfo,  0 );
   22513           0 :   if (!SWIG_IsOK(res2)) {
   22514           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::value_type const &","push", 2, argv[0] )); 
   22515             :   }
   22516           0 :   if (!argp2) {
   22517           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::BackendInfo >::value_type const &","push", 2, argv[0])); 
   22518             :   }
   22519           0 :   arg2 = reinterpret_cast< std::vector< kdb::tools::BackendInfo >::value_type * >(argp2);
   22520           0 :   result = std_vector_Sl_kdb_tools_BackendInfo_Sg__push(arg1,(kdb::tools::BackendInfo const &)*arg2);
   22521           0 :   vresult = SWIG_NewPointerObj((new std::vector< kdb::tools::BackendInfo >::value_type(static_cast< const std::vector< kdb::tools::BackendInfo >::value_type& >(result))), SWIGTYPE_p_kdb__tools__BackendInfo, SWIG_POINTER_OWN |  0 );
   22522             :   return vresult;
   22523             : fail:
   22524             :   return Qnil;
   22525             : }
   22526             : 
   22527             : 
   22528             : 
   22529             : /*
   22530             :   Document-method: Kdbtools::BackendInfoVector.reject
   22531             : 
   22532             :   call-seq:
   22533             :     reject -> BackendInfoVector
   22534             : 
   22535             : Iterate thru each element in the BackendInfoVector and reject those that fail a condition returning a new BackendInfoVector.  A block must be provided.
   22536             : */
   22537             : SWIGINTERN VALUE
   22538           0 : _wrap_BackendInfoVector_reject(int argc, VALUE *argv, VALUE self) {
   22539           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22540           0 :   void *argp1 = 0 ;
   22541           0 :   int res1 = 0 ;
   22542           0 :   std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *result = 0 ;
   22543           0 :   VALUE vresult = Qnil;
   22544             :   
   22545           0 :   if ((argc < 0) || (argc > 0)) {
   22546           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   22547             :   }
   22548           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22549           0 :   if (!SWIG_IsOK(res1)) {
   22550           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","reject", 1, self )); 
   22551             :   }
   22552           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22553           0 :   result = (std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *)std_vector_Sl_kdb_tools_BackendInfo_Sg__reject(arg1);
   22554           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, SWIG_POINTER_OWN |  0 );
   22555             :   return vresult;
   22556             : fail:
   22557             :   return Qnil;
   22558             : }
   22559             : 
   22560             : 
   22561             : 
   22562             : /*
   22563             :   Document-method: Kdbtools::BackendInfoVector.shift
   22564             : 
   22565             :   call-seq:
   22566             :     shift -> VALUE
   22567             : 
   22568             : Remove and return element at the beginning of the BackendInfoVector.
   22569             : */
   22570             : SWIGINTERN VALUE
   22571           0 : _wrap_BackendInfoVector_shift(int argc, VALUE *argv, VALUE self) {
   22572           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22573           0 :   void *argp1 = 0 ;
   22574           0 :   int res1 = 0 ;
   22575             :   VALUE result;
   22576           0 :   VALUE vresult = Qnil;
   22577             :   
   22578           0 :   if ((argc < 0) || (argc > 0)) {
   22579           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   22580             :   }
   22581           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22582           0 :   if (!SWIG_IsOK(res1)) {
   22583           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","shift", 1, self )); 
   22584             :   }
   22585           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22586           0 :   result = (VALUE)std_vector_Sl_kdb_tools_BackendInfo_Sg__shift(arg1);
   22587           0 :   vresult = result;
   22588             :   return vresult;
   22589             : fail:
   22590             :   return Qnil;
   22591             : }
   22592             : 
   22593             : 
   22594             : 
   22595             : /*
   22596             :   Document-method: Kdbtools::BackendInfoVector.insert
   22597             : 
   22598             :   call-seq:
   22599             :     insert(pos, argc) -> BackendInfoVector
   22600             : 
   22601             : Insert one or more new elements in the BackendInfoVector.
   22602             : */
   22603             : SWIGINTERN VALUE
   22604           0 : _wrap_BackendInfoVector_insert(int argc, VALUE *argv, VALUE self) {
   22605           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22606             :   std::vector< kdb::tools::BackendInfo >::difference_type arg2 ;
   22607             :   int arg3 ;
   22608           0 :   VALUE *arg4 = (VALUE *) 0 ;
   22609           0 :   void *arg5 = 0 ;
   22610           0 :   void *argp1 = 0 ;
   22611           0 :   int res1 = 0 ;
   22612             :   ptrdiff_t val2 ;
   22613           0 :   int ecode2 = 0 ;
   22614           0 :   std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *result = 0 ;
   22615           0 :   VALUE vresult = Qnil;
   22616             :   
   22617           0 :   if (argc < 2) {
   22618           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   22619             :   }
   22620           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22621           0 :   if (!SWIG_IsOK(res1)) {
   22622           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","insert", 1, self )); 
   22623             :   }
   22624           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22625           0 :   ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
   22626           0 :   if (!SWIG_IsOK(ecode2)) {
   22627           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::difference_type","insert", 2, argv[0] ));
   22628             :   } 
   22629           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::difference_type >(val2);
   22630             :   {
   22631           0 :     arg3 = argc - 1;
   22632           0 :     arg4 = argv + 1;
   22633             :   }
   22634           0 :   result = (std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *)std_vector_Sl_kdb_tools_BackendInfo_Sg__insert(arg1,arg2,arg3,arg4,arg5);
   22635           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22636             :   return vresult;
   22637             : fail:
   22638             :   return Qnil;
   22639             : }
   22640             : 
   22641             : 
   22642             : 
   22643             : /*
   22644             :   Document-method: Kdbtools::BackendInfoVector.unshift
   22645             : 
   22646             :   call-seq:
   22647             :     unshift(argc) -> BackendInfoVector
   22648             : 
   22649             : Add one or more elements at the beginning of the BackendInfoVector.
   22650             : */
   22651             : SWIGINTERN VALUE
   22652           0 : _wrap_BackendInfoVector_unshift(int argc, VALUE *argv, VALUE self) {
   22653           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22654             :   int arg2 ;
   22655           0 :   VALUE *arg3 = (VALUE *) 0 ;
   22656           0 :   void *arg4 = 0 ;
   22657           0 :   void *argp1 = 0 ;
   22658           0 :   int res1 = 0 ;
   22659           0 :   std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *result = 0 ;
   22660           0 :   VALUE vresult = Qnil;
   22661             :   
   22662           0 :   if (argc < 1) {
   22663           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   22664             :   }
   22665           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22666           0 :   if (!SWIG_IsOK(res1)) {
   22667           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","unshift", 1, self )); 
   22668             :   }
   22669           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22670             :   {
   22671           0 :     arg2 = argc;
   22672           0 :     arg3 = argv;
   22673             :   }
   22674           0 :   result = (std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *)std_vector_Sl_kdb_tools_BackendInfo_Sg__unshift(arg1,arg2,arg3,arg4);
   22675           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22676             :   return vresult;
   22677             : fail:
   22678             :   return Qnil;
   22679             : }
   22680             : 
   22681             : 
   22682             : 
   22683             : /*
   22684             :   Document-method: Kdbtools::BackendInfoVector.new
   22685             : 
   22686             :   call-seq:
   22687             :     BackendInfoVector.new
   22688             :     BackendInfoVector.new(BackendInfoVector arg2)
   22689             :     BackendInfoVector.new(std::vector< kdb::tools::BackendInfo >::size_type size)
   22690             :     BackendInfoVector.new(std::vector< kdb::tools::BackendInfo >::size_type size, BackendInfo value)
   22691             : 
   22692             : Class constructor.
   22693             : 
   22694             : */
   22695             : SWIGINTERN VALUE
   22696           0 : _wrap_new_BackendInfoVector__SWIG_0(int argc, VALUE *argv, VALUE self) {
   22697           0 :   std::vector< kdb::tools::BackendInfo > *result = 0 ;
   22698             :   
   22699           0 :   if ((argc < 0) || (argc > 0)) {
   22700           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   22701             :   }
   22702           0 :   result = (std::vector< kdb::tools::BackendInfo > *)new std::vector< kdb::tools::BackendInfo >();
   22703           0 :   DATA_PTR(self) = result;
   22704             :   return self;
   22705             : fail:
   22706             :   return Qnil;
   22707             : }
   22708             : 
   22709             : 
   22710             : SWIGINTERN VALUE
   22711           0 : _wrap_new_BackendInfoVector__SWIG_1(int argc, VALUE *argv, VALUE self) {
   22712           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = 0 ;
   22713           0 :   int res1 = SWIG_OLDOBJ ;
   22714           0 :   std::vector< kdb::tools::BackendInfo > *result = 0 ;
   22715             :   
   22716           0 :   if ((argc < 1) || (argc > 1)) {
   22717           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   22718             :   }
   22719             :   {
   22720           0 :     std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *ptr = (std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *)0;
   22721           0 :     res1 = swig::asptr(argv[0], &ptr);
   22722           0 :     if (!SWIG_IsOK(res1)) {
   22723           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > const &","vector<(kdb::tools::BackendInfo)>", 1, argv[0] )); 
   22724             :     }
   22725           0 :     if (!ptr) {
   22726           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::BackendInfo > const &","vector<(kdb::tools::BackendInfo)>", 1, argv[0])); 
   22727             :     }
   22728           0 :     arg1 = ptr;
   22729             :   }
   22730           0 :   result = (std::vector< kdb::tools::BackendInfo > *)new std::vector< kdb::tools::BackendInfo >((std::vector< kdb::tools::BackendInfo > const &)*arg1);
   22731           0 :   DATA_PTR(self) = result;
   22732           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
   22733             :   return self;
   22734             : fail:
   22735             :   if (SWIG_IsNewObj(res1)) delete arg1;
   22736             :   return Qnil;
   22737             : }
   22738             : 
   22739             : 
   22740             : 
   22741             : /*
   22742             :   Document-method: Kdbtools::BackendInfoVector.empty
   22743             : 
   22744             :   call-seq:
   22745             :     empty -> bool
   22746             : 
   22747             : Check if the BackendInfoVector is empty or not.
   22748             : */
   22749             : SWIGINTERN VALUE
   22750           0 : _wrap_BackendInfoVector_empty(int argc, VALUE *argv, VALUE self) {
   22751           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22752           0 :   void *argp1 = 0 ;
   22753           0 :   int res1 = 0 ;
   22754             :   bool result;
   22755           0 :   VALUE vresult = Qnil;
   22756             :   
   22757           0 :   if ((argc < 0) || (argc > 0)) {
   22758           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   22759             :   }
   22760           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22761           0 :   if (!SWIG_IsOK(res1)) {
   22762           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > const *","empty", 1, self )); 
   22763             :   }
   22764           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22765           0 :   result = (bool)((std::vector< kdb::tools::BackendInfo > const *)arg1)->empty();
   22766           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   22767             :   return vresult;
   22768             : fail:
   22769             :   return Qnil;
   22770             : }
   22771             : 
   22772             : 
   22773             : 
   22774             : /*
   22775             :   Document-method: Kdbtools::BackendInfoVector.size
   22776             : 
   22777             :   call-seq:
   22778             :     size -> std::vector< kdb::tools::BackendInfo >::size_type
   22779             : 
   22780             : Size or Length of the BackendInfoVector.
   22781             : */
   22782             : SWIGINTERN VALUE
   22783           0 : _wrap_BackendInfoVector_size(int argc, VALUE *argv, VALUE self) {
   22784           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22785           0 :   void *argp1 = 0 ;
   22786           0 :   int res1 = 0 ;
   22787             :   std::vector< kdb::tools::BackendInfo >::size_type result;
   22788           0 :   VALUE vresult = Qnil;
   22789             :   
   22790           0 :   if ((argc < 0) || (argc > 0)) {
   22791           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   22792             :   }
   22793           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22794           0 :   if (!SWIG_IsOK(res1)) {
   22795           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > const *","size", 1, self )); 
   22796             :   }
   22797           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22798           0 :   result = ((std::vector< kdb::tools::BackendInfo > const *)arg1)->size();
   22799           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
   22800             :   return vresult;
   22801             : fail:
   22802             :   return Qnil;
   22803             : }
   22804             : 
   22805             : 
   22806             : 
   22807             : /*
   22808             :   Document-method: Kdbtools::BackendInfoVector.swap
   22809             : 
   22810             :   call-seq:
   22811             :     swap(BackendInfoVector v)
   22812             : 
   22813             : An instance method.
   22814             : 
   22815             : */
   22816             : SWIGINTERN VALUE
   22817           0 : _wrap_BackendInfoVector_swap(int argc, VALUE *argv, VALUE self) {
   22818           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22819           0 :   std::vector< kdb::tools::BackendInfo > *arg2 = 0 ;
   22820           0 :   void *argp1 = 0 ;
   22821           0 :   int res1 = 0 ;
   22822           0 :   void *argp2 = 0 ;
   22823           0 :   int res2 = 0 ;
   22824             :   
   22825           0 :   if ((argc < 1) || (argc > 1)) {
   22826           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   22827             :   }
   22828           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22829           0 :   if (!SWIG_IsOK(res1)) {
   22830           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","swap", 1, self )); 
   22831             :   }
   22832           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22833           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t,  0 );
   22834           0 :   if (!SWIG_IsOK(res2)) {
   22835           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > &","swap", 2, argv[0] )); 
   22836             :   }
   22837           0 :   if (!argp2) {
   22838           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::BackendInfo > &","swap", 2, argv[0])); 
   22839             :   }
   22840           0 :   arg2 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp2);
   22841           0 :   (arg1)->swap(*arg2);
   22842             :   return Qnil;
   22843             : fail:
   22844             :   return Qnil;
   22845             : }
   22846             : 
   22847             : 
   22848             : 
   22849             : /*
   22850             :   Document-method: Kdbtools::BackendInfoVector.clear
   22851             : 
   22852             :   call-seq:
   22853             :     clear
   22854             : 
   22855             : Clear BackendInfoVector contents.
   22856             : */
   22857             : SWIGINTERN VALUE
   22858           0 : _wrap_BackendInfoVector_clear(int argc, VALUE *argv, VALUE self) {
   22859           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22860           0 :   void *argp1 = 0 ;
   22861           0 :   int res1 = 0 ;
   22862             :   
   22863           0 :   if ((argc < 0) || (argc > 0)) {
   22864           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   22865             :   }
   22866           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22867           0 :   if (!SWIG_IsOK(res1)) {
   22868           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","clear", 1, self )); 
   22869             :   }
   22870           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22871           0 :   (arg1)->clear();
   22872             :   return Qnil;
   22873             : fail:
   22874             :   return Qnil;
   22875             : }
   22876             : 
   22877             : 
   22878             : 
   22879             : /*
   22880             :   Document-method: Kdbtools::BackendInfoVector.get_allocator
   22881             : 
   22882             :   call-seq:
   22883             :     get_allocator -> std::vector< kdb::tools::BackendInfo >::allocator_type
   22884             : 
   22885             : An instance method.
   22886             : 
   22887             : */
   22888             : SWIGINTERN VALUE
   22889           0 : _wrap_BackendInfoVector_get_allocator(int argc, VALUE *argv, VALUE self) {
   22890           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22891           0 :   void *argp1 = 0 ;
   22892           0 :   int res1 = 0 ;
   22893           0 :   SwigValueWrapper< std::allocator< kdb::tools::BackendInfo > > result;
   22894           0 :   VALUE vresult = Qnil;
   22895             :   
   22896           0 :   if ((argc < 0) || (argc > 0)) {
   22897           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   22898             :   }
   22899           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22900           0 :   if (!SWIG_IsOK(res1)) {
   22901           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > const *","get_allocator", 1, self )); 
   22902             :   }
   22903           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22904           0 :   result = ((std::vector< kdb::tools::BackendInfo > const *)arg1)->get_allocator();
   22905           0 :   vresult = SWIG_NewPointerObj((new std::vector< kdb::tools::BackendInfo >::allocator_type(static_cast< const std::vector< kdb::tools::BackendInfo >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_kdb__tools__BackendInfo_t, SWIG_POINTER_OWN |  0 );
   22906           0 :   return vresult;
   22907             : fail:
   22908             :   return Qnil;
   22909             : }
   22910             : 
   22911             : 
   22912             : 
   22913             : /*
   22914             :   Document-method: Kdbtools::BackendInfoVector.new
   22915             : 
   22916             :   call-seq:
   22917             :     BackendInfoVector.new
   22918             :     BackendInfoVector.new(BackendInfoVector arg2)
   22919             :     BackendInfoVector.new(std::vector< kdb::tools::BackendInfo >::size_type size)
   22920             :     BackendInfoVector.new(std::vector< kdb::tools::BackendInfo >::size_type size, BackendInfo value)
   22921             : 
   22922             : Class constructor.
   22923             : 
   22924             : */
   22925             : SWIGINTERN VALUE
   22926           0 : _wrap_new_BackendInfoVector__SWIG_2(int argc, VALUE *argv, VALUE self) {
   22927             :   std::vector< kdb::tools::BackendInfo >::size_type arg1 ;
   22928             :   size_t val1 ;
   22929           0 :   int ecode1 = 0 ;
   22930           0 :   std::vector< kdb::tools::BackendInfo > *result = 0 ;
   22931             :   
   22932           0 :   if ((argc < 1) || (argc > 1)) {
   22933           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   22934             :   }
   22935           0 :   ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
   22936           0 :   if (!SWIG_IsOK(ecode1)) {
   22937           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::size_type","vector<(kdb::tools::BackendInfo)>", 1, argv[0] ));
   22938             :   } 
   22939           0 :   arg1 = static_cast< std::vector< kdb::tools::BackendInfo >::size_type >(val1);
   22940           0 :   result = (std::vector< kdb::tools::BackendInfo > *)new std::vector< kdb::tools::BackendInfo >(arg1);
   22941           0 :   DATA_PTR(self) = result;
   22942             :   return self;
   22943             : fail:
   22944             :   return Qnil;
   22945             : }
   22946             : 
   22947             : 
   22948             : 
   22949             : /*
   22950             :   Document-method: Kdbtools::BackendInfoVector.resize
   22951             : 
   22952             :   call-seq:
   22953             :     resize(new_size)
   22954             :     resize(new_size, x)
   22955             : 
   22956             : Resize the size of the BackendInfoVector.
   22957             : */
   22958             : SWIGINTERN VALUE
   22959           0 : _wrap_BackendInfoVector_resize__SWIG_0(int argc, VALUE *argv, VALUE self) {
   22960           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   22961             :   std::vector< kdb::tools::BackendInfo >::size_type arg2 ;
   22962           0 :   void *argp1 = 0 ;
   22963           0 :   int res1 = 0 ;
   22964             :   size_t val2 ;
   22965           0 :   int ecode2 = 0 ;
   22966             :   
   22967           0 :   if ((argc < 1) || (argc > 1)) {
   22968           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   22969             :   }
   22970           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   22971           0 :   if (!SWIG_IsOK(res1)) {
   22972           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","resize", 1, self )); 
   22973             :   }
   22974           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   22975           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
   22976           0 :   if (!SWIG_IsOK(ecode2)) {
   22977           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::size_type","resize", 2, argv[0] ));
   22978             :   } 
   22979           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::size_type >(val2);
   22980           0 :   (arg1)->resize(arg2);
   22981             :   return Qnil;
   22982             : fail:
   22983             :   return Qnil;
   22984             : }
   22985             : 
   22986             : 
   22987             : SWIGINTERN VALUE
   22988             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   22989           0 : _wrap_BackendInfoVector_allocate(VALUE self)
   22990             : #else
   22991             : _wrap_BackendInfoVector_allocate(int argc, VALUE *argv, VALUE self)
   22992             : #endif
   22993             : {
   22994           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t);
   22995             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   22996             :   rb_obj_call_init(vresult, argc, argv);
   22997             : #endif
   22998           0 :   return vresult;
   22999             : }
   23000             : 
   23001             : 
   23002             : 
   23003             : /*
   23004             :   Document-method: Kdbtools::BackendInfoVector.new
   23005             : 
   23006             :   call-seq:
   23007             :     BackendInfoVector.new
   23008             :     BackendInfoVector.new(BackendInfoVector arg2)
   23009             :     BackendInfoVector.new(std::vector< kdb::tools::BackendInfo >::size_type size)
   23010             :     BackendInfoVector.new(std::vector< kdb::tools::BackendInfo >::size_type size, BackendInfo value)
   23011             : 
   23012             : Class constructor.
   23013             : 
   23014             : */
   23015             : SWIGINTERN VALUE
   23016           0 : _wrap_new_BackendInfoVector__SWIG_3(int argc, VALUE *argv, VALUE self) {
   23017             :   std::vector< kdb::tools::BackendInfo >::size_type arg1 ;
   23018           0 :   std::vector< kdb::tools::BackendInfo >::value_type *arg2 = 0 ;
   23019             :   size_t val1 ;
   23020           0 :   int ecode1 = 0 ;
   23021             :   void *argp2 ;
   23022           0 :   int res2 = 0 ;
   23023           0 :   std::vector< kdb::tools::BackendInfo > *result = 0 ;
   23024             :   
   23025           0 :   if ((argc < 2) || (argc > 2)) {
   23026           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   23027             :   }
   23028           0 :   ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
   23029           0 :   if (!SWIG_IsOK(ecode1)) {
   23030           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::size_type","vector<(kdb::tools::BackendInfo)>", 1, argv[0] ));
   23031             :   } 
   23032           0 :   arg1 = static_cast< std::vector< kdb::tools::BackendInfo >::size_type >(val1);
   23033           0 :   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_kdb__tools__BackendInfo,  0 );
   23034           0 :   if (!SWIG_IsOK(res2)) {
   23035           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::value_type const &","vector<(kdb::tools::BackendInfo)>", 2, argv[1] )); 
   23036             :   }
   23037           0 :   if (!argp2) {
   23038           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::BackendInfo >::value_type const &","vector<(kdb::tools::BackendInfo)>", 2, argv[1])); 
   23039             :   }
   23040           0 :   arg2 = reinterpret_cast< std::vector< kdb::tools::BackendInfo >::value_type * >(argp2);
   23041           0 :   result = (std::vector< kdb::tools::BackendInfo > *)new std::vector< kdb::tools::BackendInfo >(arg1,(std::vector< kdb::tools::BackendInfo >::value_type const &)*arg2);
   23042           0 :   DATA_PTR(self) = result;
   23043             :   return self;
   23044             : fail:
   23045             :   return Qnil;
   23046             : }
   23047             : 
   23048             : 
   23049           0 : SWIGINTERN VALUE _wrap_new_BackendInfoVector(int nargs, VALUE *args, VALUE self) {
   23050             :   int argc;
   23051             :   VALUE argv[2];
   23052             :   int ii;
   23053             :   
   23054           0 :   argc = nargs;
   23055           0 :   if (argc > 2) SWIG_fail;
   23056           0 :   for (ii = 0; (ii < argc); ++ii) {
   23057           0 :     argv[ii] = args[ii];
   23058             :   }
   23059           0 :   if (argc == 0) {
   23060           0 :     return _wrap_new_BackendInfoVector__SWIG_0(nargs, args, self);
   23061             :   }
   23062           0 :   if (argc == 1) {
   23063           0 :     int _v = 0;
   23064             :     {
   23065             :       {
   23066           0 :         int res = SWIG_AsVal_size_t(argv[0], NULL);
   23067           0 :         _v = SWIG_CheckState(res);
   23068             :       }
   23069             :     }
   23070           0 :     if (!_v) goto check_2;
   23071           0 :     return _wrap_new_BackendInfoVector__SWIG_2(nargs, args, self);
   23072             :   }
   23073             : check_2:
   23074             :   
   23075           0 :   if (argc == 1) {
   23076           0 :     return _wrap_new_BackendInfoVector__SWIG_1(nargs, args, self);
   23077             :   }
   23078           0 :   if (argc == 2) {
   23079           0 :     return _wrap_new_BackendInfoVector__SWIG_3(nargs, args, self);
   23080             :   }
   23081             :   
   23082             : fail:
   23083             :   Ruby_Format_OverloadedError( argc, 2, "BackendInfoVector.new", 
   23084             :     "    BackendInfoVector.new()\n"
   23085             :     "    BackendInfoVector.new(std::vector< kdb::tools::BackendInfo > const &)\n"
   23086             :     "    BackendInfoVector.new(std::vector< kdb::tools::BackendInfo >::size_type size)\n"
   23087           0 :     "    BackendInfoVector.new(std::vector< kdb::tools::BackendInfo >::size_type size, std::vector< kdb::tools::BackendInfo >::value_type const &value)\n");
   23088             :   
   23089             :   return Qnil;
   23090             : }
   23091             : 
   23092             : 
   23093             : 
   23094             : /*
   23095             :   Document-method: Kdbtools::BackendInfoVector.front
   23096             : 
   23097             :   call-seq:
   23098             :     front -> BackendInfo
   23099             : 
   23100             : Return the first element in BackendInfoVector.
   23101             : */
   23102             : SWIGINTERN VALUE
   23103           0 : _wrap_BackendInfoVector_front(int argc, VALUE *argv, VALUE self) {
   23104           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   23105           0 :   void *argp1 = 0 ;
   23106           0 :   int res1 = 0 ;
   23107           0 :   std::vector< kdb::tools::BackendInfo >::value_type *result = 0 ;
   23108           0 :   VALUE vresult = Qnil;
   23109             :   
   23110           0 :   if ((argc < 0) || (argc > 0)) {
   23111           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   23112             :   }
   23113           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   23114           0 :   if (!SWIG_IsOK(res1)) {
   23115           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > const *","front", 1, self )); 
   23116             :   }
   23117           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   23118           0 :   result = (std::vector< kdb::tools::BackendInfo >::value_type *) &((std::vector< kdb::tools::BackendInfo > const *)arg1)->front();
   23119           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__tools__BackendInfo, 0 |  0 );
   23120             :   return vresult;
   23121             : fail:
   23122             :   return Qnil;
   23123             : }
   23124             : 
   23125             : 
   23126             : 
   23127             : /*
   23128             :   Document-method: Kdbtools::BackendInfoVector.back
   23129             : 
   23130             :   call-seq:
   23131             :     back -> BackendInfo
   23132             : 
   23133             : Return the last element in BackendInfoVector.
   23134             : */
   23135             : SWIGINTERN VALUE
   23136           0 : _wrap_BackendInfoVector_back(int argc, VALUE *argv, VALUE self) {
   23137           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   23138           0 :   void *argp1 = 0 ;
   23139           0 :   int res1 = 0 ;
   23140           0 :   std::vector< kdb::tools::BackendInfo >::value_type *result = 0 ;
   23141           0 :   VALUE vresult = Qnil;
   23142             :   
   23143           0 :   if ((argc < 0) || (argc > 0)) {
   23144           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   23145             :   }
   23146           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   23147           0 :   if (!SWIG_IsOK(res1)) {
   23148           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > const *","back", 1, self )); 
   23149             :   }
   23150           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   23151           0 :   result = (std::vector< kdb::tools::BackendInfo >::value_type *) &((std::vector< kdb::tools::BackendInfo > const *)arg1)->back();
   23152           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__tools__BackendInfo, 0 |  0 );
   23153             :   return vresult;
   23154             : fail:
   23155             :   return Qnil;
   23156             : }
   23157             : 
   23158             : 
   23159             : 
   23160             : /*
   23161             :   Document-method: Kdbtools::BackendInfoVector.assign
   23162             : 
   23163             :   call-seq:
   23164             :     assign(n, x)
   23165             : 
   23166             : Assign a new BackendInfoVector or portion of it.
   23167             : */
   23168             : SWIGINTERN VALUE
   23169           0 : _wrap_BackendInfoVector_assign(int argc, VALUE *argv, VALUE self) {
   23170           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   23171             :   std::vector< kdb::tools::BackendInfo >::size_type arg2 ;
   23172           0 :   std::vector< kdb::tools::BackendInfo >::value_type *arg3 = 0 ;
   23173           0 :   void *argp1 = 0 ;
   23174           0 :   int res1 = 0 ;
   23175             :   size_t val2 ;
   23176           0 :   int ecode2 = 0 ;
   23177             :   void *argp3 ;
   23178           0 :   int res3 = 0 ;
   23179             :   
   23180           0 :   if ((argc < 2) || (argc > 2)) {
   23181           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   23182             :   }
   23183           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   23184           0 :   if (!SWIG_IsOK(res1)) {
   23185           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","assign", 1, self )); 
   23186             :   }
   23187           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   23188           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
   23189           0 :   if (!SWIG_IsOK(ecode2)) {
   23190           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::size_type","assign", 2, argv[0] ));
   23191             :   } 
   23192           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::size_type >(val2);
   23193           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__tools__BackendInfo,  0 );
   23194           0 :   if (!SWIG_IsOK(res3)) {
   23195           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::value_type const &","assign", 3, argv[1] )); 
   23196             :   }
   23197           0 :   if (!argp3) {
   23198           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::BackendInfo >::value_type const &","assign", 3, argv[1])); 
   23199             :   }
   23200           0 :   arg3 = reinterpret_cast< std::vector< kdb::tools::BackendInfo >::value_type * >(argp3);
   23201           0 :   (arg1)->assign(arg2,(std::vector< kdb::tools::BackendInfo >::value_type const &)*arg3);
   23202             :   return Qnil;
   23203             : fail:
   23204             :   return Qnil;
   23205             : }
   23206             : 
   23207             : 
   23208             : 
   23209             : /*
   23210             :   Document-method: Kdbtools::BackendInfoVector.resize
   23211             : 
   23212             :   call-seq:
   23213             :     resize(new_size)
   23214             :     resize(new_size, x)
   23215             : 
   23216             : Resize the size of the BackendInfoVector.
   23217             : */
   23218             : SWIGINTERN VALUE
   23219           0 : _wrap_BackendInfoVector_resize__SWIG_1(int argc, VALUE *argv, VALUE self) {
   23220           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   23221             :   std::vector< kdb::tools::BackendInfo >::size_type arg2 ;
   23222           0 :   std::vector< kdb::tools::BackendInfo >::value_type *arg3 = 0 ;
   23223           0 :   void *argp1 = 0 ;
   23224           0 :   int res1 = 0 ;
   23225             :   size_t val2 ;
   23226           0 :   int ecode2 = 0 ;
   23227             :   void *argp3 ;
   23228           0 :   int res3 = 0 ;
   23229             :   
   23230           0 :   if ((argc < 2) || (argc > 2)) {
   23231           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   23232             :   }
   23233           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   23234           0 :   if (!SWIG_IsOK(res1)) {
   23235           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","resize", 1, self )); 
   23236             :   }
   23237           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   23238           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
   23239           0 :   if (!SWIG_IsOK(ecode2)) {
   23240           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::size_type","resize", 2, argv[0] ));
   23241             :   } 
   23242           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::size_type >(val2);
   23243           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__tools__BackendInfo,  0 );
   23244           0 :   if (!SWIG_IsOK(res3)) {
   23245           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::value_type const &","resize", 3, argv[1] )); 
   23246             :   }
   23247           0 :   if (!argp3) {
   23248           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< kdb::tools::BackendInfo >::value_type const &","resize", 3, argv[1])); 
   23249             :   }
   23250           0 :   arg3 = reinterpret_cast< std::vector< kdb::tools::BackendInfo >::value_type * >(argp3);
   23251           0 :   (arg1)->resize(arg2,(std::vector< kdb::tools::BackendInfo >::value_type const &)*arg3);
   23252             :   return Qnil;
   23253             : fail:
   23254             :   return Qnil;
   23255             : }
   23256             : 
   23257             : 
   23258           0 : SWIGINTERN VALUE _wrap_BackendInfoVector_resize(int nargs, VALUE *args, VALUE self) {
   23259             :   int argc;
   23260             :   VALUE argv[4];
   23261             :   int ii;
   23262             :   
   23263           0 :   argc = nargs + 1;
   23264             :   argv[0] = self;
   23265           0 :   if (argc > 4) SWIG_fail;
   23266             :   for (ii = 1; (ii < argc); ++ii) {
   23267             :     argv[ii] = args[ii-1];
   23268             :   }
   23269           0 :   if (argc == 2) {
   23270           0 :     return _wrap_BackendInfoVector_resize__SWIG_0(nargs, args, self);
   23271             :   }
   23272           0 :   if (argc == 3) {
   23273           0 :     return _wrap_BackendInfoVector_resize__SWIG_1(nargs, args, self);
   23274             :   }
   23275             :   
   23276             : fail:
   23277             :   Ruby_Format_OverloadedError( argc, 4, "BackendInfoVector.resize", 
   23278             :     "    void BackendInfoVector.resize(std::vector< kdb::tools::BackendInfo >::size_type new_size)\n"
   23279           0 :     "    void BackendInfoVector.resize(std::vector< kdb::tools::BackendInfo >::size_type new_size, std::vector< kdb::tools::BackendInfo >::value_type const &x)\n");
   23280             :   
   23281             :   return Qnil;
   23282             : }
   23283             : 
   23284             : 
   23285             : 
   23286             : /*
   23287             :   Document-method: Kdbtools::BackendInfoVector.reserve
   23288             : 
   23289             :   call-seq:
   23290             :     reserve(n)
   23291             : 
   23292             : Reserve memory in the BackendInfoVector for a number of elements.
   23293             : */
   23294             : SWIGINTERN VALUE
   23295           0 : _wrap_BackendInfoVector_reserve(int argc, VALUE *argv, VALUE self) {
   23296           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   23297             :   std::vector< kdb::tools::BackendInfo >::size_type arg2 ;
   23298           0 :   void *argp1 = 0 ;
   23299           0 :   int res1 = 0 ;
   23300             :   size_t val2 ;
   23301           0 :   int ecode2 = 0 ;
   23302             :   
   23303           0 :   if ((argc < 1) || (argc > 1)) {
   23304           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   23305             :   }
   23306           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   23307           0 :   if (!SWIG_IsOK(res1)) {
   23308           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > *","reserve", 1, self )); 
   23309             :   }
   23310           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   23311           0 :   ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
   23312           0 :   if (!SWIG_IsOK(ecode2)) {
   23313           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo >::size_type","reserve", 2, argv[0] ));
   23314             :   } 
   23315           0 :   arg2 = static_cast< std::vector< kdb::tools::BackendInfo >::size_type >(val2);
   23316           0 :   (arg1)->reserve(arg2);
   23317             :   return Qnil;
   23318             : fail:
   23319             :   return Qnil;
   23320             : }
   23321             : 
   23322             : 
   23323             : 
   23324             : /*
   23325             :   Document-method: Kdbtools::BackendInfoVector.capacity
   23326             : 
   23327             :   call-seq:
   23328             :     capacity -> std::vector< kdb::tools::BackendInfo >::size_type
   23329             : 
   23330             : Reserved capacity of the BackendInfoVector.
   23331             : */
   23332             : SWIGINTERN VALUE
   23333           0 : _wrap_BackendInfoVector_capacity(int argc, VALUE *argv, VALUE self) {
   23334           0 :   std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *) 0 ;
   23335           0 :   void *argp1 = 0 ;
   23336           0 :   int res1 = 0 ;
   23337             :   std::vector< kdb::tools::BackendInfo >::size_type result;
   23338           0 :   VALUE vresult = Qnil;
   23339             :   
   23340           0 :   if ((argc < 0) || (argc > 0)) {
   23341           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   23342             :   }
   23343           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0 |  0 );
   23344           0 :   if (!SWIG_IsOK(res1)) {
   23345           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< kdb::tools::BackendInfo > const *","capacity", 1, self )); 
   23346             :   }
   23347           0 :   arg1 = reinterpret_cast< std::vector< kdb::tools::BackendInfo > * >(argp1);
   23348           0 :   result = ((std::vector< kdb::tools::BackendInfo > const *)arg1)->capacity();
   23349           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
   23350             :   return vresult;
   23351             : fail:
   23352             :   return Qnil;
   23353             : }
   23354             : 
   23355             : 
   23356             : SWIGINTERN void
   23357           0 : free_std_vector_Sl_kdb_tools_BackendInfo_Sg_(void *self) {
   23358           0 :     std::vector< kdb::tools::BackendInfo > *arg1 = (std::vector< kdb::tools::BackendInfo > *)self;
   23359           0 :     delete arg1;
   23360           0 : }
   23361             : 
   23362             : 
   23363             : /*
   23364             :   Document-class: Kdbtools::BackendInfo
   23365             : 
   23366             :   Proxy of C++ Kdbtools::BackendInfo class
   23367             : 
   23368             : 
   23369             : */
   23370             : static swig_class SwigClassBackendInfo;
   23371             : 
   23372             : 
   23373             : /*
   23374             :   Document-method: Kdbtools::BackendInfo.name
   23375             : 
   23376             :   call-seq:
   23377             :     name -> std::string
   23378             : 
   23379             : Get value of attribute.
   23380             : 
   23381             : */
   23382             : 
   23383             : /*
   23384             :   Document-method: Kdbtools::BackendInfo.name=
   23385             : 
   23386             :   call-seq:
   23387             :     name=(x) -> std::string
   23388             : 
   23389             : Set new value for attribute.
   23390             : 
   23391             : */
   23392             : SWIGINTERN VALUE
   23393           0 : _wrap_BackendInfo_name_set(int argc, VALUE *argv, VALUE self) {
   23394           0 :   kdb::tools::BackendInfo *arg1 = (kdb::tools::BackendInfo *) 0 ;
   23395           0 :   std::string *arg2 = 0 ;
   23396           0 :   void *argp1 = 0 ;
   23397           0 :   int res1 = 0 ;
   23398           0 :   int res2 = SWIG_OLDOBJ ;
   23399             :   
   23400           0 :   if ((argc < 1) || (argc > 1)) {
   23401           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   23402             :   }
   23403           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendInfo, 0 |  0 );
   23404           0 :   if (!SWIG_IsOK(res1)) {
   23405           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendInfo *","name", 1, self )); 
   23406             :   }
   23407           0 :   arg1 = reinterpret_cast< kdb::tools::BackendInfo * >(argp1);
   23408             :   {
   23409           0 :     std::string *ptr = (std::string *)0;
   23410           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   23411           0 :     if (!SWIG_IsOK(res2)) {
   23412           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","name", 2, argv[0] )); 
   23413             :     }
   23414           0 :     if (!ptr) {
   23415           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","name", 2, argv[0])); 
   23416             :     }
   23417           0 :     arg2 = ptr;
   23418             :   }
   23419           0 :   if (arg1) (arg1)->name = *arg2;
   23420           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   23421             :   return Qnil;
   23422             : fail:
   23423             :   if (SWIG_IsNewObj(res2)) delete arg2;
   23424             :   return Qnil;
   23425             : }
   23426             : 
   23427             : 
   23428             : SWIGINTERN VALUE
   23429           0 : _wrap_BackendInfo_name_get(int argc, VALUE *argv, VALUE self) {
   23430           0 :   kdb::tools::BackendInfo *arg1 = (kdb::tools::BackendInfo *) 0 ;
   23431           0 :   void *argp1 = 0 ;
   23432           0 :   int res1 = 0 ;
   23433           0 :   std::string *result = 0 ;
   23434           0 :   VALUE vresult = Qnil;
   23435             :   
   23436           0 :   if ((argc < 0) || (argc > 0)) {
   23437           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   23438             :   }
   23439           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendInfo, 0 |  0 );
   23440           0 :   if (!SWIG_IsOK(res1)) {
   23441           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendInfo *","name", 1, self )); 
   23442             :   }
   23443           0 :   arg1 = reinterpret_cast< kdb::tools::BackendInfo * >(argp1);
   23444           0 :   result = (std::string *) & ((arg1)->name);
   23445           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   23446             :   return vresult;
   23447             : fail:
   23448             :   return Qnil;
   23449             : }
   23450             : 
   23451             : 
   23452             : 
   23453             : /*
   23454             :   Document-method: Kdbtools::BackendInfo.mountpoint
   23455             : 
   23456             :   call-seq:
   23457             :     mountpoint -> std::string
   23458             : 
   23459             : Get value of attribute.
   23460             : 
   23461             : */
   23462             : 
   23463             : /*
   23464             :   Document-method: Kdbtools::BackendInfo.mountpoint=
   23465             : 
   23466             :   call-seq:
   23467             :     mountpoint=(x) -> std::string
   23468             : 
   23469             : Set new value for attribute.
   23470             : 
   23471             : */
   23472             : SWIGINTERN VALUE
   23473           0 : _wrap_BackendInfo_mountpoint_set(int argc, VALUE *argv, VALUE self) {
   23474           0 :   kdb::tools::BackendInfo *arg1 = (kdb::tools::BackendInfo *) 0 ;
   23475           0 :   std::string *arg2 = 0 ;
   23476           0 :   void *argp1 = 0 ;
   23477           0 :   int res1 = 0 ;
   23478           0 :   int res2 = SWIG_OLDOBJ ;
   23479             :   
   23480           0 :   if ((argc < 1) || (argc > 1)) {
   23481           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   23482             :   }
   23483           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendInfo, 0 |  0 );
   23484           0 :   if (!SWIG_IsOK(res1)) {
   23485           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendInfo *","mountpoint", 1, self )); 
   23486             :   }
   23487           0 :   arg1 = reinterpret_cast< kdb::tools::BackendInfo * >(argp1);
   23488             :   {
   23489           0 :     std::string *ptr = (std::string *)0;
   23490           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   23491           0 :     if (!SWIG_IsOK(res2)) {
   23492           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","mountpoint", 2, argv[0] )); 
   23493             :     }
   23494           0 :     if (!ptr) {
   23495           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","mountpoint", 2, argv[0])); 
   23496             :     }
   23497           0 :     arg2 = ptr;
   23498             :   }
   23499           0 :   if (arg1) (arg1)->mountpoint = *arg2;
   23500           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   23501             :   return Qnil;
   23502             : fail:
   23503             :   if (SWIG_IsNewObj(res2)) delete arg2;
   23504             :   return Qnil;
   23505             : }
   23506             : 
   23507             : 
   23508             : SWIGINTERN VALUE
   23509           0 : _wrap_BackendInfo_mountpoint_get(int argc, VALUE *argv, VALUE self) {
   23510           0 :   kdb::tools::BackendInfo *arg1 = (kdb::tools::BackendInfo *) 0 ;
   23511           0 :   void *argp1 = 0 ;
   23512           0 :   int res1 = 0 ;
   23513           0 :   std::string *result = 0 ;
   23514           0 :   VALUE vresult = Qnil;
   23515             :   
   23516           0 :   if ((argc < 0) || (argc > 0)) {
   23517           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   23518             :   }
   23519           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendInfo, 0 |  0 );
   23520           0 :   if (!SWIG_IsOK(res1)) {
   23521           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendInfo *","mountpoint", 1, self )); 
   23522             :   }
   23523           0 :   arg1 = reinterpret_cast< kdb::tools::BackendInfo * >(argp1);
   23524           0 :   result = (std::string *) & ((arg1)->mountpoint);
   23525           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   23526             :   return vresult;
   23527             : fail:
   23528             :   return Qnil;
   23529             : }
   23530             : 
   23531             : 
   23532             : 
   23533             : /*
   23534             :   Document-method: Kdbtools::BackendInfo.path
   23535             : 
   23536             :   call-seq:
   23537             :     path -> std::string
   23538             : 
   23539             : Get value of attribute.
   23540             : 
   23541             : */
   23542             : 
   23543             : /*
   23544             :   Document-method: Kdbtools::BackendInfo.path=
   23545             : 
   23546             :   call-seq:
   23547             :     path=(x) -> std::string
   23548             : 
   23549             : Set new value for attribute.
   23550             : 
   23551             : */
   23552             : SWIGINTERN VALUE
   23553           0 : _wrap_BackendInfo_path_set(int argc, VALUE *argv, VALUE self) {
   23554           0 :   kdb::tools::BackendInfo *arg1 = (kdb::tools::BackendInfo *) 0 ;
   23555           0 :   std::string *arg2 = 0 ;
   23556           0 :   void *argp1 = 0 ;
   23557           0 :   int res1 = 0 ;
   23558           0 :   int res2 = SWIG_OLDOBJ ;
   23559             :   
   23560           0 :   if ((argc < 1) || (argc > 1)) {
   23561           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   23562             :   }
   23563           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendInfo, 0 |  0 );
   23564           0 :   if (!SWIG_IsOK(res1)) {
   23565           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendInfo *","path", 1, self )); 
   23566             :   }
   23567           0 :   arg1 = reinterpret_cast< kdb::tools::BackendInfo * >(argp1);
   23568             :   {
   23569           0 :     std::string *ptr = (std::string *)0;
   23570           0 :     res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
   23571           0 :     if (!SWIG_IsOK(res2)) {
   23572           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","path", 2, argv[0] )); 
   23573             :     }
   23574           0 :     if (!ptr) {
   23575           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","path", 2, argv[0])); 
   23576             :     }
   23577           0 :     arg2 = ptr;
   23578             :   }
   23579           0 :   if (arg1) (arg1)->path = *arg2;
   23580           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   23581             :   return Qnil;
   23582             : fail:
   23583             :   if (SWIG_IsNewObj(res2)) delete arg2;
   23584             :   return Qnil;
   23585             : }
   23586             : 
   23587             : 
   23588             : SWIGINTERN VALUE
   23589           0 : _wrap_BackendInfo_path_get(int argc, VALUE *argv, VALUE self) {
   23590           0 :   kdb::tools::BackendInfo *arg1 = (kdb::tools::BackendInfo *) 0 ;
   23591           0 :   void *argp1 = 0 ;
   23592           0 :   int res1 = 0 ;
   23593           0 :   std::string *result = 0 ;
   23594           0 :   VALUE vresult = Qnil;
   23595             :   
   23596           0 :   if ((argc < 0) || (argc > 0)) {
   23597           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   23598             :   }
   23599           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendInfo, 0 |  0 );
   23600           0 :   if (!SWIG_IsOK(res1)) {
   23601           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendInfo *","path", 1, self )); 
   23602             :   }
   23603           0 :   arg1 = reinterpret_cast< kdb::tools::BackendInfo * >(argp1);
   23604           0 :   result = (std::string *) & ((arg1)->path);
   23605           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   23606             :   return vresult;
   23607             : fail:
   23608             :   return Qnil;
   23609             : }
   23610             : 
   23611             : 
   23612             : SWIGINTERN VALUE
   23613             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   23614           0 : _wrap_BackendInfo_allocate(VALUE self)
   23615             : #else
   23616             : _wrap_BackendInfo_allocate(int argc, VALUE *argv, VALUE self)
   23617             : #endif
   23618             : {
   23619           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__BackendInfo);
   23620             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   23621             :   rb_obj_call_init(vresult, argc, argv);
   23622             : #endif
   23623           0 :   return vresult;
   23624             : }
   23625             : 
   23626             : 
   23627             : 
   23628             : /*
   23629             :   Document-method: Kdbtools::BackendInfo.new
   23630             : 
   23631             :   call-seq:
   23632             :     BackendInfo.new
   23633             : 
   23634             : Class constructor.
   23635             : 
   23636             : */
   23637             : SWIGINTERN VALUE
   23638           0 : _wrap_new_BackendInfo(int argc, VALUE *argv, VALUE self) {
   23639           0 :   kdb::tools::BackendInfo *result = 0 ;
   23640             :   
   23641           0 :   if ((argc < 0) || (argc > 0)) {
   23642           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   23643             :   }
   23644           0 :   result = (kdb::tools::BackendInfo *)new kdb::tools::BackendInfo();
   23645           0 :   DATA_PTR(self) = result;
   23646             :   return self;
   23647             : fail:
   23648             :   return Qnil;
   23649             : }
   23650             : 
   23651             : 
   23652             : SWIGINTERN void
   23653           0 : free_kdb_tools_BackendInfo(void *self) {
   23654           0 :     kdb::tools::BackendInfo *arg1 = (kdb::tools::BackendInfo *)self;
   23655           0 :     delete arg1;
   23656           0 : }
   23657             : 
   23658             : 
   23659             : /*
   23660             :   Document-class: Kdbtools::Backends
   23661             : 
   23662             :   Proxy of C++ Kdbtools::Backends class
   23663             : 
   23664             : 
   23665             : */
   23666             : static swig_class SwigClassBackends;
   23667             : 
   23668             : 
   23669             : /*
   23670             :   Document-method: Kdbtools::Backends.get_backend_info
   23671             : 
   23672             :   call-seq:
   23673             :     get_backend_info(KeySet mountConf) -> BackendInfoVector
   23674             : 
   23675             : A class method.
   23676             : 
   23677             : */
   23678             : SWIGINTERN VALUE
   23679           0 : _wrap_Backends_get_backend_info(int argc, VALUE *argv, VALUE self) {
   23680           0 :   kdb::KeySet arg1 ;
   23681             :   void *argp1 ;
   23682           0 :   int res1 = 0 ;
   23683           0 :   kdb::tools::Backends::BackendInfoVector result;
   23684           0 :   VALUE vresult = Qnil;
   23685             :   
   23686           0 :   if ((argc < 1) || (argc > 1)) {
   23687           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   23688             :   }
   23689             :   {
   23690           0 :     res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__KeySet,  0 );
   23691           0 :     if (!SWIG_IsOK(res1)) {
   23692           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::KeySet","kdb::tools::Backends::getBackendInfo", 1, argv[0] )); 
   23693             :     }  
   23694           0 :     if (!argp1) {
   23695           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet","kdb::tools::Backends::getBackendInfo", 1, argv[0]));
   23696             :     } else {
   23697           0 :       arg1 = *(reinterpret_cast< kdb::KeySet * >(argp1));
   23698             :     }
   23699             :   }
   23700           0 :   result = kdb::tools::Backends::getBackendInfo(arg1);
   23701           0 :   vresult = swig::from(static_cast< std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > >(result));
   23702             :   return vresult;
   23703             : fail:
   23704             :   return Qnil;
   23705             : }
   23706             : 
   23707             : 
   23708             : 
   23709             : /*
   23710             :   Document-method: Kdbtools::Backends.find_backend
   23711             : 
   23712             :   call-seq:
   23713             :     find_backend(std::string const & backend, KeySet mountConf, bool verbose=False) -> BackendInfo
   23714             :     find_backend(std::string const & backend, KeySet mountConf) -> BackendInfo
   23715             : 
   23716             : A class method.
   23717             : 
   23718             : */
   23719             : SWIGINTERN VALUE
   23720           0 : _wrap_Backends_find_backend__SWIG_0(int argc, VALUE *argv, VALUE self) {
   23721           0 :   std::string *arg1 = 0 ;
   23722           0 :   kdb::KeySet arg2 ;
   23723             :   bool arg3 ;
   23724           0 :   int res1 = SWIG_OLDOBJ ;
   23725             :   void *argp2 ;
   23726           0 :   int res2 = 0 ;
   23727             :   bool val3 ;
   23728           0 :   int ecode3 = 0 ;
   23729           0 :   kdb::tools::BackendInfo result;
   23730           0 :   VALUE vresult = Qnil;
   23731             :   
   23732           0 :   if ((argc < 3) || (argc > 3)) {
   23733           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   23734             :   }
   23735             :   {
   23736           0 :     std::string *ptr = (std::string *)0;
   23737           0 :     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
   23738           0 :     if (!SWIG_IsOK(res1)) {
   23739           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","kdb::tools::Backends::findBackend", 1, argv[0] )); 
   23740             :     }
   23741           0 :     if (!ptr) {
   23742           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","kdb::tools::Backends::findBackend", 1, argv[0])); 
   23743             :     }
   23744           0 :     arg1 = ptr;
   23745             :   }
   23746             :   {
   23747           0 :     res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   23748           0 :     if (!SWIG_IsOK(res2)) {
   23749           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet","kdb::tools::Backends::findBackend", 2, argv[1] )); 
   23750             :     }  
   23751           0 :     if (!argp2) {
   23752           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet","kdb::tools::Backends::findBackend", 2, argv[1]));
   23753             :     } else {
   23754           0 :       arg2 = *(reinterpret_cast< kdb::KeySet * >(argp2));
   23755             :     }
   23756             :   }
   23757           0 :   ecode3 = SWIG_AsVal_bool(argv[2], &val3);
   23758           0 :   if (!SWIG_IsOK(ecode3)) {
   23759           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","kdb::tools::Backends::findBackend", 3, argv[2] ));
   23760             :   } 
   23761           0 :   arg3 = static_cast< bool >(val3);
   23762           0 :   result = kdb::tools::Backends::findBackend((std::string const &)*arg1,arg2,arg3);
   23763           0 :   vresult = SWIG_NewPointerObj((new kdb::tools::BackendInfo(static_cast< const kdb::tools::BackendInfo& >(result))), SWIGTYPE_p_kdb__tools__BackendInfo, SWIG_POINTER_OWN |  0 );
   23764           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
   23765             :   return vresult;
   23766             : fail:
   23767             :   if (SWIG_IsNewObj(res1)) delete arg1;
   23768             :   return Qnil;
   23769             : }
   23770             : 
   23771             : 
   23772             : SWIGINTERN VALUE
   23773           0 : _wrap_Backends_find_backend__SWIG_1(int argc, VALUE *argv, VALUE self) {
   23774           0 :   std::string *arg1 = 0 ;
   23775           0 :   kdb::KeySet arg2 ;
   23776           0 :   int res1 = SWIG_OLDOBJ ;
   23777             :   void *argp2 ;
   23778           0 :   int res2 = 0 ;
   23779           0 :   kdb::tools::BackendInfo result;
   23780           0 :   VALUE vresult = Qnil;
   23781             :   
   23782           0 :   if ((argc < 2) || (argc > 2)) {
   23783           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   23784             :   }
   23785             :   {
   23786           0 :     std::string *ptr = (std::string *)0;
   23787           0 :     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
   23788           0 :     if (!SWIG_IsOK(res1)) {
   23789           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","kdb::tools::Backends::findBackend", 1, argv[0] )); 
   23790             :     }
   23791           0 :     if (!ptr) {
   23792           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","kdb::tools::Backends::findBackend", 1, argv[0])); 
   23793             :     }
   23794           0 :     arg1 = ptr;
   23795             :   }
   23796             :   {
   23797           0 :     res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   23798           0 :     if (!SWIG_IsOK(res2)) {
   23799           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet","kdb::tools::Backends::findBackend", 2, argv[1] )); 
   23800             :     }  
   23801           0 :     if (!argp2) {
   23802           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet","kdb::tools::Backends::findBackend", 2, argv[1]));
   23803             :     } else {
   23804           0 :       arg2 = *(reinterpret_cast< kdb::KeySet * >(argp2));
   23805             :     }
   23806             :   }
   23807           0 :   result = kdb::tools::Backends::findBackend((std::string const &)*arg1,arg2);
   23808           0 :   vresult = SWIG_NewPointerObj((new kdb::tools::BackendInfo(static_cast< const kdb::tools::BackendInfo& >(result))), SWIGTYPE_p_kdb__tools__BackendInfo, SWIG_POINTER_OWN |  0 );
   23809           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
   23810             :   return vresult;
   23811             : fail:
   23812             :   if (SWIG_IsNewObj(res1)) delete arg1;
   23813             :   return Qnil;
   23814             : }
   23815             : 
   23816             : 
   23817           0 : SWIGINTERN VALUE _wrap_Backends_find_backend(int nargs, VALUE *args, VALUE self) {
   23818             :   int argc;
   23819             :   VALUE argv[3];
   23820             :   int ii;
   23821             :   
   23822           0 :   argc = nargs;
   23823           0 :   if (argc > 3) SWIG_fail;
   23824             :   for (ii = 0; (ii < argc); ++ii) {
   23825             :     argv[ii] = args[ii];
   23826             :   }
   23827           0 :   if (argc == 2) {
   23828           0 :     return _wrap_Backends_find_backend__SWIG_1(nargs, args, self);
   23829             :   }
   23830           0 :   if (argc == 3) {
   23831           0 :     return _wrap_Backends_find_backend__SWIG_0(nargs, args, self);
   23832             :   }
   23833             :   
   23834             : fail:
   23835             :   Ruby_Format_OverloadedError( argc, 3, "Backends.find_backend", 
   23836             :     "    kdb::tools::BackendInfo Backends.find_backend(std::string const &backend, kdb::KeySet mountConf, bool verbose)\n"
   23837           0 :     "    kdb::tools::BackendInfo Backends.find_backend(std::string const &backend, kdb::KeySet mountConf)\n");
   23838             :   
   23839             :   return Qnil;
   23840             : }
   23841             : 
   23842             : 
   23843             : 
   23844             : /*
   23845             :   Document-method: Kdbtools::Backends.umount
   23846             : 
   23847             :   call-seq:
   23848             :     umount(std::string const & backend, KeySet mountConf) -> bool
   23849             : 
   23850             : A class method.
   23851             : 
   23852             : */
   23853             : SWIGINTERN VALUE
   23854           0 : _wrap_Backends_umount(int argc, VALUE *argv, VALUE self) {
   23855           0 :   std::string *arg1 = 0 ;
   23856           0 :   kdb::KeySet *arg2 = 0 ;
   23857           0 :   int res1 = SWIG_OLDOBJ ;
   23858           0 :   void *argp2 = 0 ;
   23859           0 :   int res2 = 0 ;
   23860             :   bool result;
   23861           0 :   VALUE vresult = Qnil;
   23862             :   
   23863           0 :   if ((argc < 2) || (argc > 2)) {
   23864           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   23865             :   }
   23866             :   {
   23867           0 :     std::string *ptr = (std::string *)0;
   23868           0 :     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
   23869           0 :     if (!SWIG_IsOK(res1)) {
   23870           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","kdb::tools::Backends::umount", 1, argv[0] )); 
   23871             :     }
   23872           0 :     if (!ptr) {
   23873           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","kdb::tools::Backends::umount", 1, argv[0])); 
   23874             :     }
   23875           0 :     arg1 = ptr;
   23876             :   }
   23877           0 :   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   23878           0 :   if (!SWIG_IsOK(res2)) {
   23879           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet &","kdb::tools::Backends::umount", 2, argv[1] )); 
   23880             :   }
   23881           0 :   if (!argp2) {
   23882           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","kdb::tools::Backends::umount", 2, argv[1])); 
   23883             :   }
   23884           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   23885           0 :   result = (bool)kdb::tools::Backends::umount((std::string const &)*arg1,*arg2);
   23886           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   23887           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
   23888             :   return vresult;
   23889             : fail:
   23890             :   if (SWIG_IsNewObj(res1)) delete arg1;
   23891             :   return Qnil;
   23892             : }
   23893             : 
   23894             : 
   23895             : 
   23896             : /*
   23897             :   Document-method: Kdbtools::Backends.get_base_path
   23898             : 
   23899             :   call-seq:
   23900             :     get_base_path(std::string name) -> std::string
   23901             : 
   23902             : A class method.
   23903             : 
   23904             : */
   23905             : SWIGINTERN VALUE
   23906           0 : _wrap_Backends_get_base_path(int argc, VALUE *argv, VALUE self) {
   23907           0 :   std::string arg1 ;
   23908           0 :   std::string result;
   23909           0 :   VALUE vresult = Qnil;
   23910             :   
   23911           0 :   if ((argc < 1) || (argc > 1)) {
   23912           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   23913             :   }
   23914             :   {
   23915           0 :     std::string *ptr = (std::string *)0;
   23916           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   23917           0 :     if (!SWIG_IsOK(res) || !ptr) {
   23918           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","kdb::tools::Backends::getBasePath", 1, argv[0] )); 
   23919             :     }
   23920           0 :     arg1 = *ptr;
   23921           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   23922             :   }
   23923           0 :   result = kdb::tools::Backends::getBasePath(arg1);
   23924           0 :   vresult = SWIG_From_std_string(static_cast< std::string >(result));
   23925           0 :   return vresult;
   23926             : fail:
   23927             :   return Qnil;
   23928             : }
   23929             : 
   23930             : 
   23931             : SWIGINTERN VALUE
   23932             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   23933           0 : _wrap_Backends_allocate(VALUE self)
   23934             : #else
   23935             : _wrap_Backends_allocate(int argc, VALUE *argv, VALUE self)
   23936             : #endif
   23937             : {
   23938           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__Backends);
   23939             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   23940             :   rb_obj_call_init(vresult, argc, argv);
   23941             : #endif
   23942           0 :   return vresult;
   23943             : }
   23944             : 
   23945             : 
   23946             : 
   23947             : /*
   23948             :   Document-method: Kdbtools::Backends.new
   23949             : 
   23950             :   call-seq:
   23951             :     Backends.new
   23952             : 
   23953             : Class constructor.
   23954             : 
   23955             : */
   23956             : SWIGINTERN VALUE
   23957           0 : _wrap_new_Backends(int argc, VALUE *argv, VALUE self) {
   23958           0 :   kdb::tools::Backends *result = 0 ;
   23959             :   
   23960           0 :   if ((argc < 0) || (argc > 0)) {
   23961           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   23962             :   }
   23963           0 :   result = (kdb::tools::Backends *)new kdb::tools::Backends();
   23964           0 :   DATA_PTR(self) = result;
   23965             :   return self;
   23966             : fail:
   23967             :   return Qnil;
   23968             : }
   23969             : 
   23970             : 
   23971             : SWIGINTERN void
   23972           0 : free_kdb_tools_Backends(void *self) {
   23973           0 :     kdb::tools::Backends *arg1 = (kdb::tools::Backends *)self;
   23974           0 :     delete arg1;
   23975           0 : }
   23976             : 
   23977             : 
   23978             : /*
   23979             :   Document-class: Kdbtools::BackendBuilder < Kdbtools::kdb::tools::BackendInterface
   23980             : 
   23981             :   Proxy of C++ Kdbtools::BackendBuilder class
   23982             : 
   23983             : 
   23984             : */
   23985             : static swig_class SwigClassBackendBuilder;
   23986             : 
   23987             : 
   23988             : /*
   23989             :   Document-method: Kdbtools::BackendBuilder.new
   23990             : 
   23991             :   call-seq:
   23992             :     BackendBuilder.new(kdb::tools::BackendBuilderInit const & bbi=kdb::tools::BackendBuilderInit())
   23993             :     BackendBuilder.new
   23994             : 
   23995             : Class constructor.
   23996             : 
   23997             : */
   23998             : SWIGINTERN VALUE
   23999           0 : _wrap_new_BackendBuilder__SWIG_0(int argc, VALUE *argv, VALUE self) {
   24000           0 :   kdb::tools::BackendBuilderInit *arg1 = 0 ;
   24001             :   void *argp1 ;
   24002           0 :   int res1 = 0 ;
   24003           0 :   kdb::tools::BackendBuilder *result = 0 ;
   24004             :   
   24005           0 :   if ((argc < 1) || (argc > 1)) {
   24006           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24007             :   }
   24008           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__tools__BackendBuilderInit,  0 );
   24009           0 :   if (!SWIG_IsOK(res1)) {
   24010           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilderInit const &","BackendBuilder", 1, argv[0] )); 
   24011             :   }
   24012           0 :   if (!argp1) {
   24013           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::BackendBuilderInit const &","BackendBuilder", 1, argv[0])); 
   24014             :   }
   24015           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilderInit * >(argp1);
   24016           0 :   result = (kdb::tools::BackendBuilder *)new kdb::tools::BackendBuilder((kdb::tools::BackendBuilderInit const &)*arg1);
   24017           0 :   DATA_PTR(self) = result;
   24018             :   return self;
   24019             : fail:
   24020             :   return Qnil;
   24021             : }
   24022             : 
   24023             : 
   24024             : SWIGINTERN VALUE
   24025             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   24026           1 : _wrap_BackendBuilder_allocate(VALUE self)
   24027             : #else
   24028             : _wrap_BackendBuilder_allocate(int argc, VALUE *argv, VALUE self)
   24029             : #endif
   24030             : {
   24031           1 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__BackendBuilder);
   24032             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   24033             :   rb_obj_call_init(vresult, argc, argv);
   24034             : #endif
   24035           1 :   return vresult;
   24036             : }
   24037             : 
   24038             : 
   24039             : SWIGINTERN VALUE
   24040           1 : _wrap_new_BackendBuilder__SWIG_1(int argc, VALUE *argv, VALUE self) {
   24041           1 :   kdb::tools::BackendBuilder *result = 0 ;
   24042             :   
   24043           1 :   if ((argc < 0) || (argc > 0)) {
   24044           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   24045             :   }
   24046           1 :   result = (kdb::tools::BackendBuilder *)new kdb::tools::BackendBuilder();
   24047           1 :   DATA_PTR(self) = result;
   24048             :   return self;
   24049             : fail:
   24050             :   return Qnil;
   24051             : }
   24052             : 
   24053             : 
   24054           1 : SWIGINTERN VALUE _wrap_new_BackendBuilder(int nargs, VALUE *args, VALUE self) {
   24055             :   int argc;
   24056             :   VALUE argv[1];
   24057             :   int ii;
   24058             :   
   24059           1 :   argc = nargs;
   24060           1 :   if (argc > 1) SWIG_fail;
   24061             :   for (ii = 0; (ii < argc); ++ii) {
   24062             :     argv[ii] = args[ii];
   24063             :   }
   24064           1 :   if (argc == 0) {
   24065           1 :     return _wrap_new_BackendBuilder__SWIG_1(nargs, args, self);
   24066             :   }
   24067           0 :   if (argc == 1) {
   24068           0 :     return _wrap_new_BackendBuilder__SWIG_0(nargs, args, self);
   24069             :   }
   24070             :   
   24071             : fail:
   24072             :   Ruby_Format_OverloadedError( argc, 1, "BackendBuilder.new", 
   24073             :     "    BackendBuilder.new(kdb::tools::BackendBuilderInit const &bbi)\n"
   24074           0 :     "    BackendBuilder.new()\n");
   24075             :   
   24076             :   return Qnil;
   24077             : }
   24078             : 
   24079             : 
   24080             : 
   24081             : /*
   24082             :   Document-method: Kdbtools::BackendBuilder.get_plugin_database
   24083             : 
   24084             :   call-seq:
   24085             :     get_plugin_database -> kdb::tools::PluginDatabasePtr const &
   24086             : 
   24087             : An instance method.
   24088             : 
   24089             : */
   24090             : SWIGINTERN VALUE
   24091           1 : _wrap_BackendBuilder_get_plugin_database(int argc, VALUE *argv, VALUE self) {
   24092           1 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24093           1 :   void *argp1 = 0 ;
   24094           1 :   int res1 = 0 ;
   24095           1 :   kdb::tools::PluginDatabasePtr *result = 0 ;
   24096           1 :   VALUE vresult = Qnil;
   24097             :   
   24098           1 :   if ((argc < 0) || (argc > 0)) {
   24099           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   24100             :   }
   24101           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24102           1 :   if (!SWIG_IsOK(res1)) {
   24103           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder const *","getPluginDatabase", 1, self )); 
   24104             :   }
   24105           1 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24106           1 :   result = (kdb::tools::PluginDatabasePtr *) &((kdb::tools::BackendBuilder const *)arg1)->getPluginDatabase();
   24107             :   {
   24108           2 :     std::shared_ptr<  kdb::tools::PluginDatabase > *smartresult = *result ? new std::shared_ptr<  kdb::tools::PluginDatabase >(*result) : 0;
   24109           1 :     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, SWIG_POINTER_OWN);
   24110             :   }
   24111             :   return vresult;
   24112             : fail:
   24113             :   return Qnil;
   24114             : }
   24115             : 
   24116             : 
   24117             : 
   24118             : /*
   24119             :   Document-method: Kdbtools::BackendBuilder.get_backend_factory
   24120             : 
   24121             :   call-seq:
   24122             :     get_backend_factory -> BackendFactory
   24123             : 
   24124             : An instance method.
   24125             : 
   24126             : */
   24127             : SWIGINTERN VALUE
   24128           0 : _wrap_BackendBuilder_get_backend_factory(int argc, VALUE *argv, VALUE self) {
   24129           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24130           0 :   void *argp1 = 0 ;
   24131           0 :   int res1 = 0 ;
   24132           0 :   kdb::tools::BackendFactory *result = 0 ;
   24133           0 :   VALUE vresult = Qnil;
   24134             :   
   24135           0 :   if ((argc < 0) || (argc > 0)) {
   24136           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   24137             :   }
   24138           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24139           0 :   if (!SWIG_IsOK(res1)) {
   24140           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder const *","getBackendFactory", 1, self )); 
   24141             :   }
   24142           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24143           0 :   result = (kdb::tools::BackendFactory *) &((kdb::tools::BackendBuilder const *)arg1)->getBackendFactory();
   24144           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__tools__BackendFactory, 0 |  0 );
   24145             :   return vresult;
   24146             : fail:
   24147             :   return Qnil;
   24148             : }
   24149             : 
   24150             : 
   24151             : SWIGINTERN void
   24152           1 : free_kdb_tools_BackendBuilder(void *self) {
   24153           1 :     kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *)self;
   24154           1 :     delete arg1;
   24155           1 : }
   24156             : 
   24157             : 
   24158             : /*
   24159             :   Document-method: Kdbtools::BackendBuilder.add_plugins
   24160             : 
   24161             :   call-seq:
   24162             :     add_plugins(PluginSpecVector plugins)
   24163             : 
   24164             : An instance method.
   24165             : 
   24166             : */
   24167             : SWIGINTERN VALUE
   24168           0 : _wrap_BackendBuilder_add_plugins(int argc, VALUE *argv, VALUE self) {
   24169           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24170           0 :   kdb::tools::PluginSpecVector *arg2 = 0 ;
   24171           0 :   void *argp1 = 0 ;
   24172           0 :   int res1 = 0 ;
   24173           0 :   int res2 = SWIG_OLDOBJ ;
   24174             :   
   24175           0 :   if ((argc < 1) || (argc > 1)) {
   24176           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24177             :   }
   24178           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24179           0 :   if (!SWIG_IsOK(res1)) {
   24180           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder *","addPlugins", 1, self )); 
   24181             :   }
   24182           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24183             :   {
   24184           0 :     std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *ptr = (std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *)0;
   24185           0 :     res2 = swig::asptr(argv[0], &ptr);
   24186           0 :     if (!SWIG_IsOK(res2)) {
   24187           0 :       SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpecVector const &","addPlugins", 2, argv[0] )); 
   24188             :     }
   24189           0 :     if (!ptr) {
   24190           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpecVector const &","addPlugins", 2, argv[0])); 
   24191             :     }
   24192           0 :     arg2 = ptr;
   24193             :   }
   24194             :   try {
   24195           0 :     (arg1)->addPlugins((kdb::tools::PluginSpecVector const &)*arg2);
   24196             :   }
   24197           0 :   catch(kdb::tools::NoPlugin &_e) {
   24198           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__NoPlugin, SWIG_NewPointerObj((new kdb::tools::NoPlugin(static_cast< const kdb::tools::NoPlugin& >(_e))),SWIGTYPE_p_kdb__tools__NoPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   24199             :   }
   24200           0 :   catch(kdb::tools::CyclicOrderingViolation &_e) {
   24201           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__CyclicOrderingViolation, SWIG_NewPointerObj((new kdb::tools::CyclicOrderingViolation(static_cast< const kdb::tools::CyclicOrderingViolation& >(_e))),SWIGTYPE_p_kdb__tools__CyclicOrderingViolation,SWIG_POINTER_OWN))); SWIG_fail;
   24202             :   }
   24203           0 :   catch(kdb::tools::PluginAlreadyInserted &_e) {
   24204           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginAlreadyInserted, SWIG_NewPointerObj((new kdb::tools::PluginAlreadyInserted(static_cast< const kdb::tools::PluginAlreadyInserted& >(_e))),SWIGTYPE_p_kdb__tools__PluginAlreadyInserted,SWIG_POINTER_OWN))); SWIG_fail;
   24205             :   }
   24206           0 :   catch(kdb::tools::PluginConfigInvalid &_e) {
   24207           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginConfigInvalid, SWIG_NewPointerObj((new kdb::tools::PluginConfigInvalid(static_cast< const kdb::tools::PluginConfigInvalid& >(_e))),SWIGTYPE_p_kdb__tools__PluginConfigInvalid,SWIG_POINTER_OWN))); SWIG_fail;
   24208             :   }
   24209           0 :   catch(kdb::tools::BackendCheckException &_e) {
   24210           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BackendCheckException, SWIG_NewPointerObj((new kdb::tools::BackendCheckException(static_cast< const kdb::tools::BackendCheckException& >(_e))),SWIGTYPE_p_kdb__tools__BackendCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   24211             :   }
   24212           0 :   catch(kdb::tools::ToolException &_e) {
   24213           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   24214             :   }
   24215             :   
   24216           0 :   if (SWIG_IsNewObj(res2)) delete arg2;
   24217             :   return Qnil;
   24218             : fail:
   24219             :   if (SWIG_IsNewObj(res2)) delete arg2;
   24220             :   return Qnil;
   24221             : }
   24222             : 
   24223             : 
   24224             : 
   24225             : /*
   24226             :   Document-method: Kdbtools::BackendBuilder.rem_plugin
   24227             : 
   24228             :   call-seq:
   24229             :     rem_plugin(PluginSpec plugin)
   24230             : 
   24231             : An instance method.
   24232             : 
   24233             : */
   24234             : SWIGINTERN VALUE
   24235           0 : _wrap_BackendBuilder_rem_plugin(int argc, VALUE *argv, VALUE self) {
   24236           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24237           0 :   kdb::tools::PluginSpec *arg2 = 0 ;
   24238           0 :   void *argp1 = 0 ;
   24239           0 :   int res1 = 0 ;
   24240             :   void *argp2 ;
   24241           0 :   int res2 = 0 ;
   24242             :   
   24243           0 :   if ((argc < 1) || (argc > 1)) {
   24244           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24245             :   }
   24246           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24247           0 :   if (!SWIG_IsOK(res1)) {
   24248           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder *","remPlugin", 1, self )); 
   24249             :   }
   24250           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24251           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__PluginSpec,  0 );
   24252           0 :   if (!SWIG_IsOK(res2)) {
   24253           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::PluginSpec const &","remPlugin", 2, argv[0] )); 
   24254             :   }
   24255           0 :   if (!argp2) {
   24256           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::PluginSpec const &","remPlugin", 2, argv[0])); 
   24257             :   }
   24258           0 :   arg2 = reinterpret_cast< kdb::tools::PluginSpec * >(argp2);
   24259           0 :   (arg1)->remPlugin((kdb::tools::PluginSpec const &)*arg2);
   24260             :   return Qnil;
   24261             : fail:
   24262             :   return Qnil;
   24263             : }
   24264             : 
   24265             : 
   24266             : 
   24267             : /*
   24268             :   Document-method: Kdbtools::BackendBuilder.need_metadata
   24269             : 
   24270             :   call-seq:
   24271             :     need_metadata(std::string metadata)
   24272             : 
   24273             : An instance method.
   24274             : 
   24275             : */
   24276             : SWIGINTERN VALUE
   24277           0 : _wrap_BackendBuilder_need_metadata(int argc, VALUE *argv, VALUE self) {
   24278           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24279           0 :   std::string arg2 ;
   24280           0 :   void *argp1 = 0 ;
   24281           0 :   int res1 = 0 ;
   24282             :   
   24283           0 :   if ((argc < 1) || (argc > 1)) {
   24284           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24285             :   }
   24286           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24287           0 :   if (!SWIG_IsOK(res1)) {
   24288           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder *","needMetadata", 1, self )); 
   24289             :   }
   24290           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24291             :   {
   24292           0 :     std::string *ptr = (std::string *)0;
   24293           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   24294           0 :     if (!SWIG_IsOK(res) || !ptr) {
   24295           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","needMetadata", 2, argv[0] )); 
   24296             :     }
   24297           0 :     arg2 = *ptr;
   24298           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   24299             :   }
   24300           0 :   (arg1)->needMetadata(arg2);
   24301           0 :   return Qnil;
   24302             : fail:
   24303             :   return Qnil;
   24304             : }
   24305             : 
   24306             : 
   24307             : 
   24308             : /*
   24309             :   Document-method: Kdbtools::BackendBuilder.need_plugin
   24310             : 
   24311             :   call-seq:
   24312             :     need_plugin(std::string provider)
   24313             : 
   24314             : An instance method.
   24315             : 
   24316             : */
   24317             : SWIGINTERN VALUE
   24318           0 : _wrap_BackendBuilder_need_plugin(int argc, VALUE *argv, VALUE self) {
   24319           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24320           0 :   std::string arg2 ;
   24321           0 :   void *argp1 = 0 ;
   24322           0 :   int res1 = 0 ;
   24323             :   
   24324           0 :   if ((argc < 1) || (argc > 1)) {
   24325           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24326             :   }
   24327           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24328           0 :   if (!SWIG_IsOK(res1)) {
   24329           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder *","needPlugin", 1, self )); 
   24330             :   }
   24331           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24332             :   {
   24333           0 :     std::string *ptr = (std::string *)0;
   24334           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   24335           0 :     if (!SWIG_IsOK(res) || !ptr) {
   24336           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","needPlugin", 2, argv[0] )); 
   24337             :     }
   24338           0 :     arg2 = *ptr;
   24339           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   24340             :   }
   24341           0 :   (arg1)->needPlugin(arg2);
   24342           0 :   return Qnil;
   24343             : fail:
   24344             :   return Qnil;
   24345             : }
   24346             : 
   24347             : 
   24348             : 
   24349             : /*
   24350             :   Document-method: Kdbtools::BackendBuilder.resolve_needs
   24351             : 
   24352             :   call-seq:
   24353             :     resolve_needs(bool addRecommends=True) -> VectorStr
   24354             :     resolve_needs -> VectorStr
   24355             : 
   24356             : An instance method.
   24357             : 
   24358             : */
   24359             : SWIGINTERN VALUE
   24360           0 : _wrap_BackendBuilder_resolve_needs__SWIG_0(int argc, VALUE *argv, VALUE self) {
   24361           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24362             :   bool arg2 ;
   24363           0 :   void *argp1 = 0 ;
   24364           0 :   int res1 = 0 ;
   24365             :   bool val2 ;
   24366           0 :   int ecode2 = 0 ;
   24367           0 :   std::vector< std::string,std::allocator< std::string > > result;
   24368           0 :   VALUE vresult = Qnil;
   24369             :   
   24370           0 :   if ((argc < 1) || (argc > 1)) {
   24371           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24372             :   }
   24373           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24374           0 :   if (!SWIG_IsOK(res1)) {
   24375           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder *","resolveNeeds", 1, self )); 
   24376             :   }
   24377           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24378           0 :   ecode2 = SWIG_AsVal_bool(argv[0], &val2);
   24379           0 :   if (!SWIG_IsOK(ecode2)) {
   24380           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","resolveNeeds", 2, argv[0] ));
   24381             :   } 
   24382           0 :   arg2 = static_cast< bool >(val2);
   24383             :   try {
   24384           0 :     result = (arg1)->resolveNeeds(arg2);
   24385             :   }
   24386           0 :   catch(kdb::tools::NoPlugin &_e) {
   24387           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__NoPlugin, SWIG_NewPointerObj((new kdb::tools::NoPlugin(static_cast< const kdb::tools::NoPlugin& >(_e))),SWIGTYPE_p_kdb__tools__NoPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   24388             :   }
   24389           0 :   catch(kdb::tools::CyclicOrderingViolation &_e) {
   24390           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__CyclicOrderingViolation, SWIG_NewPointerObj((new kdb::tools::CyclicOrderingViolation(static_cast< const kdb::tools::CyclicOrderingViolation& >(_e))),SWIGTYPE_p_kdb__tools__CyclicOrderingViolation,SWIG_POINTER_OWN))); SWIG_fail;
   24391             :   }
   24392           0 :   catch(kdb::tools::PluginAlreadyInserted &_e) {
   24393           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginAlreadyInserted, SWIG_NewPointerObj((new kdb::tools::PluginAlreadyInserted(static_cast< const kdb::tools::PluginAlreadyInserted& >(_e))),SWIGTYPE_p_kdb__tools__PluginAlreadyInserted,SWIG_POINTER_OWN))); SWIG_fail;
   24394             :   }
   24395           0 :   catch(kdb::tools::PluginConfigInvalid &_e) {
   24396           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginConfigInvalid, SWIG_NewPointerObj((new kdb::tools::PluginConfigInvalid(static_cast< const kdb::tools::PluginConfigInvalid& >(_e))),SWIGTYPE_p_kdb__tools__PluginConfigInvalid,SWIG_POINTER_OWN))); SWIG_fail;
   24397             :   }
   24398           0 :   catch(kdb::tools::BackendCheckException &_e) {
   24399           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BackendCheckException, SWIG_NewPointerObj((new kdb::tools::BackendCheckException(static_cast< const kdb::tools::BackendCheckException& >(_e))),SWIGTYPE_p_kdb__tools__BackendCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   24400             :   }
   24401           0 :   catch(kdb::tools::ToolException &_e) {
   24402           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   24403             :   }
   24404           0 :   catch(...) {
   24405           0 :     SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
   24406             :   }
   24407             :   
   24408           0 :   vresult = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
   24409             :   return vresult;
   24410             : fail:
   24411             :   return Qnil;
   24412             : }
   24413             : 
   24414             : 
   24415             : SWIGINTERN VALUE
   24416           0 : _wrap_BackendBuilder_resolve_needs__SWIG_1(int argc, VALUE *argv, VALUE self) {
   24417           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24418           0 :   void *argp1 = 0 ;
   24419           0 :   int res1 = 0 ;
   24420           0 :   std::vector< std::string,std::allocator< std::string > > result;
   24421           0 :   VALUE vresult = Qnil;
   24422             :   
   24423           0 :   if ((argc < 0) || (argc > 0)) {
   24424           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   24425             :   }
   24426           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24427           0 :   if (!SWIG_IsOK(res1)) {
   24428           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder *","resolveNeeds", 1, self )); 
   24429             :   }
   24430           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24431             :   try {
   24432           0 :     result = (arg1)->resolveNeeds();
   24433             :   }
   24434           0 :   catch(kdb::tools::NoPlugin &_e) {
   24435           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__NoPlugin, SWIG_NewPointerObj((new kdb::tools::NoPlugin(static_cast< const kdb::tools::NoPlugin& >(_e))),SWIGTYPE_p_kdb__tools__NoPlugin,SWIG_POINTER_OWN))); SWIG_fail;
   24436             :   }
   24437           0 :   catch(kdb::tools::CyclicOrderingViolation &_e) {
   24438           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__CyclicOrderingViolation, SWIG_NewPointerObj((new kdb::tools::CyclicOrderingViolation(static_cast< const kdb::tools::CyclicOrderingViolation& >(_e))),SWIGTYPE_p_kdb__tools__CyclicOrderingViolation,SWIG_POINTER_OWN))); SWIG_fail;
   24439             :   }
   24440           0 :   catch(kdb::tools::PluginAlreadyInserted &_e) {
   24441           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginAlreadyInserted, SWIG_NewPointerObj((new kdb::tools::PluginAlreadyInserted(static_cast< const kdb::tools::PluginAlreadyInserted& >(_e))),SWIGTYPE_p_kdb__tools__PluginAlreadyInserted,SWIG_POINTER_OWN))); SWIG_fail;
   24442             :   }
   24443           0 :   catch(kdb::tools::PluginConfigInvalid &_e) {
   24444           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__PluginConfigInvalid, SWIG_NewPointerObj((new kdb::tools::PluginConfigInvalid(static_cast< const kdb::tools::PluginConfigInvalid& >(_e))),SWIGTYPE_p_kdb__tools__PluginConfigInvalid,SWIG_POINTER_OWN))); SWIG_fail;
   24445             :   }
   24446           0 :   catch(kdb::tools::BackendCheckException &_e) {
   24447           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__BackendCheckException, SWIG_NewPointerObj((new kdb::tools::BackendCheckException(static_cast< const kdb::tools::BackendCheckException& >(_e))),SWIGTYPE_p_kdb__tools__BackendCheckException,SWIG_POINTER_OWN))); SWIG_fail;
   24448             :   }
   24449           0 :   catch(kdb::tools::ToolException &_e) {
   24450           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   24451             :   }
   24452           0 :   catch(...) {
   24453           0 :     SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
   24454             :   }
   24455             :   
   24456           0 :   vresult = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
   24457             :   return vresult;
   24458             : fail:
   24459             :   return Qnil;
   24460             : }
   24461             : 
   24462             : 
   24463           0 : SWIGINTERN VALUE _wrap_BackendBuilder_resolve_needs(int nargs, VALUE *args, VALUE self) {
   24464             :   int argc;
   24465             :   VALUE argv[3];
   24466             :   int ii;
   24467             :   
   24468           0 :   argc = nargs + 1;
   24469             :   argv[0] = self;
   24470           0 :   if (argc > 3) SWIG_fail;
   24471             :   for (ii = 1; (ii < argc); ++ii) {
   24472             :     argv[ii] = args[ii-1];
   24473             :   }
   24474           0 :   if (argc == 1) {
   24475           0 :     return _wrap_BackendBuilder_resolve_needs__SWIG_1(nargs, args, self);
   24476             :   }
   24477           0 :   if (argc == 2) {
   24478           0 :     return _wrap_BackendBuilder_resolve_needs__SWIG_0(nargs, args, self);
   24479             :   }
   24480             :   
   24481             : fail:
   24482             :   Ruby_Format_OverloadedError( argc, 3, "BackendBuilder.resolve_needs", 
   24483             :     "    std::vector< std::string,std::allocator< std::string > > BackendBuilder.resolve_needs(bool addRecommends)\n"
   24484           0 :     "    std::vector< std::string,std::allocator< std::string > > BackendBuilder.resolve_needs()\n");
   24485             :   
   24486             :   return Qnil;
   24487             : }
   24488             : 
   24489             : 
   24490             : 
   24491             : /*
   24492             :   Document-method: Kdbtools::BackendBuilder.recommend_plugin
   24493             : 
   24494             :   call-seq:
   24495             :     recommend_plugin(std::string provider)
   24496             : 
   24497             : An instance method.
   24498             : 
   24499             : */
   24500             : SWIGINTERN VALUE
   24501           0 : _wrap_BackendBuilder_recommend_plugin(int argc, VALUE *argv, VALUE self) {
   24502           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24503           0 :   std::string arg2 ;
   24504           0 :   void *argp1 = 0 ;
   24505           0 :   int res1 = 0 ;
   24506             :   
   24507           0 :   if ((argc < 1) || (argc > 1)) {
   24508           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24509             :   }
   24510           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24511           0 :   if (!SWIG_IsOK(res1)) {
   24512           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder *","recommendPlugin", 1, self )); 
   24513             :   }
   24514           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24515             :   {
   24516           0 :     std::string *ptr = (std::string *)0;
   24517           0 :     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
   24518           0 :     if (!SWIG_IsOK(res) || !ptr) {
   24519           0 :       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","recommendPlugin", 2, argv[0] )); 
   24520             :     }
   24521           0 :     arg2 = *ptr;
   24522           0 :     if (SWIG_IsNewObj(res)) delete ptr;
   24523             :   }
   24524           0 :   (arg1)->recommendPlugin(arg2);
   24525           0 :   return Qnil;
   24526             : fail:
   24527             :   return Qnil;
   24528             : }
   24529             : 
   24530             : 
   24531             : 
   24532             : /*
   24533             :   Document-method: Kdbtools::BackendBuilder.fill_plugins
   24534             : 
   24535             :   call-seq:
   24536             :     fill_plugins(BackendInterface b)
   24537             : 
   24538             : An instance method.
   24539             : 
   24540             : */
   24541             : SWIGINTERN VALUE
   24542           0 : _wrap_BackendBuilder_fill_plugins(int argc, VALUE *argv, VALUE self) {
   24543           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24544           0 :   kdb::tools::BackendInterface *arg2 = 0 ;
   24545           0 :   void *argp1 = 0 ;
   24546           0 :   int res1 = 0 ;
   24547           0 :   void *argp2 = 0 ;
   24548           0 :   int res2 = 0 ;
   24549             :   
   24550           0 :   if ((argc < 1) || (argc > 1)) {
   24551           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24552             :   }
   24553           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24554           0 :   if (!SWIG_IsOK(res1)) {
   24555           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder const *","fillPlugins", 1, self )); 
   24556             :   }
   24557           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24558           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__tools__BackendInterface,  0 );
   24559           0 :   if (!SWIG_IsOK(res2)) {
   24560           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::tools::BackendInterface &","fillPlugins", 2, argv[0] )); 
   24561             :   }
   24562           0 :   if (!argp2) {
   24563           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::BackendInterface &","fillPlugins", 2, argv[0])); 
   24564             :   }
   24565           0 :   arg2 = reinterpret_cast< kdb::tools::BackendInterface * >(argp2);
   24566             :   try {
   24567           0 :     ((kdb::tools::BackendBuilder const *)arg1)->fillPlugins(*arg2);
   24568             :   }
   24569           0 :   catch(kdb::tools::ToolException &_e) {
   24570           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   24571             :   }
   24572           0 :   catch(...) {
   24573           0 :     SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
   24574             :   }
   24575             :   
   24576             :   return Qnil;
   24577             : fail:
   24578             :   return Qnil;
   24579             : }
   24580             : 
   24581             : 
   24582             : 
   24583             : /*
   24584             :   Document-method: Kdbtools::BackendBuilder.backend_config=
   24585             : 
   24586             :   call-seq:
   24587             :     backend_config=(KeySet ks)
   24588             : 
   24589             : An instance method.
   24590             : 
   24591             : */
   24592             : SWIGINTERN VALUE
   24593           0 : _wrap_BackendBuilder_backend_confige___(int argc, VALUE *argv, VALUE self) {
   24594           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24595           0 :   kdb::KeySet *arg2 = 0 ;
   24596           0 :   void *argp1 = 0 ;
   24597           0 :   int res1 = 0 ;
   24598             :   void *argp2 ;
   24599           0 :   int res2 = 0 ;
   24600             :   
   24601           0 :   if ((argc < 1) || (argc > 1)) {
   24602           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24603             :   }
   24604           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24605           0 :   if (!SWIG_IsOK(res1)) {
   24606           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder *","setBackendConfig", 1, self )); 
   24607             :   }
   24608           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24609           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   24610           0 :   if (!SWIG_IsOK(res2)) {
   24611           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet const &","setBackendConfig", 2, argv[0] )); 
   24612             :   }
   24613           0 :   if (!argp2) {
   24614           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet const &","setBackendConfig", 2, argv[0])); 
   24615             :   }
   24616           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   24617           0 :   (arg1)->setBackendConfig((kdb::KeySet const &)*arg2);
   24618             :   return Qnil;
   24619             : fail:
   24620             :   return Qnil;
   24621             : }
   24622             : 
   24623             : 
   24624             : 
   24625             : /*
   24626             :   Document-method: Kdbtools::BackendBuilder.backend_config
   24627             : 
   24628             :   call-seq:
   24629             :     backend_config -> KeySet
   24630             : 
   24631             : An instance method.
   24632             : 
   24633             : */
   24634             : SWIGINTERN VALUE
   24635           0 : _wrap_BackendBuilder_backend_config(int argc, VALUE *argv, VALUE self) {
   24636           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24637           0 :   void *argp1 = 0 ;
   24638           0 :   int res1 = 0 ;
   24639           0 :   kdb::KeySet result;
   24640           0 :   VALUE vresult = Qnil;
   24641             :   
   24642           0 :   if ((argc < 0) || (argc > 0)) {
   24643           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   24644             :   }
   24645           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24646           0 :   if (!SWIG_IsOK(res1)) {
   24647           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder *","getBackendConfig", 1, self )); 
   24648             :   }
   24649           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24650           0 :   result = (arg1)->getBackendConfig();
   24651           0 :   vresult = SWIG_NewPointerObj((new kdb::KeySet(static_cast< const kdb::KeySet& >(result))), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_OWN |  0 );
   24652           0 :   return vresult;
   24653             : fail:
   24654             :   return Qnil;
   24655             : }
   24656             : 
   24657             : 
   24658             : 
   24659             : /*
   24660             :   Document-method: Kdbtools::BackendBuilder.to_add
   24661             : 
   24662             :   call-seq:
   24663             :     to_add -> PluginSpecVector
   24664             : 
   24665             : An instance method.
   24666             : 
   24667             : */
   24668             : SWIGINTERN VALUE
   24669           0 : _wrap_BackendBuilder_to_add(int argc, VALUE *argv, VALUE self) {
   24670           0 :   kdb::tools::BackendBuilder *arg1 = (kdb::tools::BackendBuilder *) 0 ;
   24671           0 :   void *argp1 = 0 ;
   24672           0 :   int res1 = 0 ;
   24673           0 :   kdb::tools::PluginSpecVector result;
   24674           0 :   VALUE vresult = Qnil;
   24675             :   
   24676           0 :   if ((argc < 0) || (argc > 0)) {
   24677           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   24678             :   }
   24679           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__BackendBuilder, 0 |  0 );
   24680           0 :   if (!SWIG_IsOK(res1)) {
   24681           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilder *","to_add", 1, self )); 
   24682             :   }
   24683           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilder * >(argp1);
   24684           0 :   result = kdb_tools_BackendBuilder_to_add(arg1);
   24685           0 :   vresult = swig::from(static_cast< std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > >(result));
   24686             :   return vresult;
   24687             : fail:
   24688             :   return Qnil;
   24689             : }
   24690             : 
   24691             : 
   24692             : 
   24693             : /*
   24694             :   Document-class: Kdbtools::GlobalPluginsBuilder < Kdbtools::kdb::tools::BackendBuilder
   24695             : 
   24696             :   Proxy of C++ Kdbtools::GlobalPluginsBuilder class
   24697             : 
   24698             : 
   24699             : */
   24700             : static swig_class SwigClassGlobalPluginsBuilder;
   24701             : 
   24702             : 
   24703             : /*
   24704             :   Document-method: Kdbtools::GlobalPluginsBuilder.new
   24705             : 
   24706             :   call-seq:
   24707             :     GlobalPluginsBuilder.new(kdb::tools::BackendBuilderInit const & bbi=kdb::tools::BackendBuilderInit())
   24708             :     GlobalPluginsBuilder.new
   24709             : 
   24710             : Class constructor.
   24711             : 
   24712             : */
   24713             : SWIGINTERN VALUE
   24714           0 : _wrap_new_GlobalPluginsBuilder__SWIG_0(int argc, VALUE *argv, VALUE self) {
   24715           0 :   kdb::tools::BackendBuilderInit *arg1 = 0 ;
   24716             :   void *argp1 ;
   24717           0 :   int res1 = 0 ;
   24718           0 :   kdb::tools::GlobalPluginsBuilder *result = 0 ;
   24719             :   
   24720           0 :   if ((argc < 1) || (argc > 1)) {
   24721           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24722             :   }
   24723           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__tools__BackendBuilderInit,  0 );
   24724           0 :   if (!SWIG_IsOK(res1)) {
   24725           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilderInit const &","GlobalPluginsBuilder", 1, argv[0] )); 
   24726             :   }
   24727           0 :   if (!argp1) {
   24728           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::BackendBuilderInit const &","GlobalPluginsBuilder", 1, argv[0])); 
   24729             :   }
   24730           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilderInit * >(argp1);
   24731           0 :   result = (kdb::tools::GlobalPluginsBuilder *)new kdb::tools::GlobalPluginsBuilder((kdb::tools::BackendBuilderInit const &)*arg1);
   24732           0 :   DATA_PTR(self) = result;
   24733             :   return self;
   24734             : fail:
   24735             :   return Qnil;
   24736             : }
   24737             : 
   24738             : 
   24739             : SWIGINTERN VALUE
   24740             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   24741           0 : _wrap_GlobalPluginsBuilder_allocate(VALUE self)
   24742             : #else
   24743             : _wrap_GlobalPluginsBuilder_allocate(int argc, VALUE *argv, VALUE self)
   24744             : #endif
   24745             : {
   24746           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__GlobalPluginsBuilder);
   24747             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   24748             :   rb_obj_call_init(vresult, argc, argv);
   24749             : #endif
   24750           0 :   return vresult;
   24751             : }
   24752             : 
   24753             : 
   24754             : SWIGINTERN VALUE
   24755           0 : _wrap_new_GlobalPluginsBuilder__SWIG_1(int argc, VALUE *argv, VALUE self) {
   24756           0 :   kdb::tools::GlobalPluginsBuilder *result = 0 ;
   24757             :   
   24758           0 :   if ((argc < 0) || (argc > 0)) {
   24759           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   24760             :   }
   24761           0 :   result = (kdb::tools::GlobalPluginsBuilder *)new kdb::tools::GlobalPluginsBuilder();
   24762           0 :   DATA_PTR(self) = result;
   24763             :   return self;
   24764             : fail:
   24765             :   return Qnil;
   24766             : }
   24767             : 
   24768             : 
   24769           0 : SWIGINTERN VALUE _wrap_new_GlobalPluginsBuilder(int nargs, VALUE *args, VALUE self) {
   24770             :   int argc;
   24771             :   VALUE argv[1];
   24772             :   int ii;
   24773             :   
   24774           0 :   argc = nargs;
   24775           0 :   if (argc > 1) SWIG_fail;
   24776             :   for (ii = 0; (ii < argc); ++ii) {
   24777             :     argv[ii] = args[ii];
   24778             :   }
   24779           0 :   if (argc == 0) {
   24780           0 :     return _wrap_new_GlobalPluginsBuilder__SWIG_1(nargs, args, self);
   24781             :   }
   24782           0 :   if (argc == 1) {
   24783           0 :     return _wrap_new_GlobalPluginsBuilder__SWIG_0(nargs, args, self);
   24784             :   }
   24785             :   
   24786             : fail:
   24787             :   Ruby_Format_OverloadedError( argc, 1, "GlobalPluginsBuilder.new", 
   24788             :     "    GlobalPluginsBuilder.new(kdb::tools::BackendBuilderInit const &bbi)\n"
   24789           0 :     "    GlobalPluginsBuilder.new()\n");
   24790             :   
   24791             :   return Qnil;
   24792             : }
   24793             : 
   24794             : 
   24795             : 
   24796             : /*
   24797             :   Document-method: Kdbtools::GlobalPluginsBuilder.serialize
   24798             : 
   24799             :   call-seq:
   24800             :     serialize(KeySet ret)
   24801             : 
   24802             : An instance method.
   24803             : 
   24804             : */
   24805             : SWIGINTERN VALUE
   24806           0 : _wrap_GlobalPluginsBuilder_serialize(int argc, VALUE *argv, VALUE self) {
   24807           0 :   kdb::tools::GlobalPluginsBuilder *arg1 = (kdb::tools::GlobalPluginsBuilder *) 0 ;
   24808           0 :   kdb::KeySet *arg2 = 0 ;
   24809           0 :   void *argp1 = 0 ;
   24810           0 :   int res1 = 0 ;
   24811           0 :   void *argp2 = 0 ;
   24812           0 :   int res2 = 0 ;
   24813             :   
   24814           0 :   if ((argc < 1) || (argc > 1)) {
   24815           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24816             :   }
   24817           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__GlobalPluginsBuilder, 0 |  0 );
   24818           0 :   if (!SWIG_IsOK(res1)) {
   24819           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::GlobalPluginsBuilder *","serialize", 1, self )); 
   24820             :   }
   24821           0 :   arg1 = reinterpret_cast< kdb::tools::GlobalPluginsBuilder * >(argp1);
   24822           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   24823           0 :   if (!SWIG_IsOK(res2)) {
   24824           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet &","serialize", 2, argv[0] )); 
   24825             :   }
   24826           0 :   if (!argp2) {
   24827           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet &","serialize", 2, argv[0])); 
   24828             :   }
   24829           0 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   24830             :   try {
   24831           0 :     (arg1)->serialize(*arg2);
   24832             :   }
   24833           0 :   catch(kdb::tools::TooManyPlugins &_e) {
   24834           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__TooManyPlugins, SWIG_NewPointerObj((new kdb::tools::TooManyPlugins(static_cast< const kdb::tools::TooManyPlugins& >(_e))),SWIGTYPE_p_kdb__tools__TooManyPlugins,SWIG_POINTER_OWN))); SWIG_fail;
   24835             :   }
   24836           0 :   catch(kdb::tools::OrderingViolation &_e) {
   24837           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__OrderingViolation, SWIG_NewPointerObj((new kdb::tools::OrderingViolation(static_cast< const kdb::tools::OrderingViolation& >(_e))),SWIGTYPE_p_kdb__tools__OrderingViolation,SWIG_POINTER_OWN))); SWIG_fail;
   24838             :   }
   24839           0 :   catch(kdb::tools::ToolException &_e) {
   24840           0 :     rb_exc_raise(SWIG_Ruby_ExceptionType(SWIGTYPE_p_kdb__tools__ToolException, SWIG_NewPointerObj((new kdb::tools::ToolException(static_cast< const kdb::tools::ToolException& >(_e))),SWIGTYPE_p_kdb__tools__ToolException,SWIG_POINTER_OWN))); SWIG_fail;
   24841             :   }
   24842           0 :   catch(...) {
   24843           0 :     SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
   24844             :   }
   24845             :   
   24846             :   return Qnil;
   24847             : fail:
   24848             :   return Qnil;
   24849             : }
   24850             : 
   24851             : 
   24852             : SWIGINTERN void
   24853           0 : free_kdb_tools_GlobalPluginsBuilder(void *self) {
   24854           0 :     kdb::tools::GlobalPluginsBuilder *arg1 = (kdb::tools::GlobalPluginsBuilder *)self;
   24855           0 :     delete arg1;
   24856           0 : }
   24857             : 
   24858             : 
   24859             : /*
   24860             :   Document-class: Kdbtools::MountBackendBuilder < Kdbtools::kdb::tools::MountBackendInterface, Kdbtools::kdb::tools::BackendBuilder
   24861             : 
   24862             :   Proxy of C++ Kdbtools::MountBackendBuilder class
   24863             : 
   24864             : 
   24865             : */
   24866             : static swig_class SwigClassMountBackendBuilder;
   24867             : 
   24868             : 
   24869             : /*
   24870             :   Document-method: Kdbtools::MountBackendBuilder.new
   24871             : 
   24872             :   call-seq:
   24873             :     MountBackendBuilder.new(kdb::tools::BackendBuilderInit const & bbi=kdb::tools::BackendBuilderInit())
   24874             :     MountBackendBuilder.new
   24875             : 
   24876             : Class constructor.
   24877             : 
   24878             : */
   24879             : SWIGINTERN VALUE
   24880           0 : _wrap_new_MountBackendBuilder__SWIG_0(int argc, VALUE *argv, VALUE self) {
   24881           0 :   kdb::tools::BackendBuilderInit *arg1 = 0 ;
   24882             :   void *argp1 ;
   24883           0 :   int res1 = 0 ;
   24884           0 :   kdb::tools::MountBackendBuilder *result = 0 ;
   24885             :   
   24886           0 :   if ((argc < 1) || (argc > 1)) {
   24887           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24888             :   }
   24889           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__tools__BackendBuilderInit,  0 );
   24890           0 :   if (!SWIG_IsOK(res1)) {
   24891           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilderInit const &","MountBackendBuilder", 1, argv[0] )); 
   24892             :   }
   24893           0 :   if (!argp1) {
   24894           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::BackendBuilderInit const &","MountBackendBuilder", 1, argv[0])); 
   24895             :   }
   24896           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilderInit * >(argp1);
   24897           0 :   result = (kdb::tools::MountBackendBuilder *)new kdb::tools::MountBackendBuilder((kdb::tools::BackendBuilderInit const &)*arg1);
   24898           0 :   DATA_PTR(self) = result;
   24899             :   return self;
   24900             : fail:
   24901             :   return Qnil;
   24902             : }
   24903             : 
   24904             : 
   24905             : SWIGINTERN VALUE
   24906             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   24907           0 : _wrap_MountBackendBuilder_allocate(VALUE self)
   24908             : #else
   24909             : _wrap_MountBackendBuilder_allocate(int argc, VALUE *argv, VALUE self)
   24910             : #endif
   24911             : {
   24912           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__MountBackendBuilder);
   24913             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   24914             :   rb_obj_call_init(vresult, argc, argv);
   24915             : #endif
   24916           0 :   return vresult;
   24917             : }
   24918             : 
   24919             : 
   24920             : SWIGINTERN VALUE
   24921           0 : _wrap_new_MountBackendBuilder__SWIG_1(int argc, VALUE *argv, VALUE self) {
   24922           0 :   kdb::tools::MountBackendBuilder *result = 0 ;
   24923             :   
   24924           0 :   if ((argc < 0) || (argc > 0)) {
   24925           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   24926             :   }
   24927           0 :   result = (kdb::tools::MountBackendBuilder *)new kdb::tools::MountBackendBuilder();
   24928           0 :   DATA_PTR(self) = result;
   24929             :   return self;
   24930             : fail:
   24931             :   return Qnil;
   24932             : }
   24933             : 
   24934             : 
   24935           0 : SWIGINTERN VALUE _wrap_new_MountBackendBuilder(int nargs, VALUE *args, VALUE self) {
   24936             :   int argc;
   24937             :   VALUE argv[1];
   24938             :   int ii;
   24939             :   
   24940           0 :   argc = nargs;
   24941           0 :   if (argc > 1) SWIG_fail;
   24942             :   for (ii = 0; (ii < argc); ++ii) {
   24943             :     argv[ii] = args[ii];
   24944             :   }
   24945           0 :   if (argc == 0) {
   24946           0 :     return _wrap_new_MountBackendBuilder__SWIG_1(nargs, args, self);
   24947             :   }
   24948           0 :   if (argc == 1) {
   24949           0 :     return _wrap_new_MountBackendBuilder__SWIG_0(nargs, args, self);
   24950             :   }
   24951             :   
   24952             : fail:
   24953             :   Ruby_Format_OverloadedError( argc, 1, "MountBackendBuilder.new", 
   24954             :     "    MountBackendBuilder.new(kdb::tools::BackendBuilderInit const &bbi)\n"
   24955           0 :     "    MountBackendBuilder.new()\n");
   24956             :   
   24957             :   return Qnil;
   24958             : }
   24959             : 
   24960             : 
   24961             : SWIGINTERN void
   24962           0 : free_kdb_tools_MountBackendBuilder(void *self) {
   24963           0 :     kdb::tools::MountBackendBuilder *arg1 = (kdb::tools::MountBackendBuilder *)self;
   24964           0 :     delete arg1;
   24965           0 : }
   24966             : 
   24967             : 
   24968             : /*
   24969             :   Document-class: Kdbtools::SpecBackendBuilderMap
   24970             : 
   24971             :   Proxy of C++ Kdbtools::SpecBackendBuilderMap class
   24972             : 
   24973             : 
   24974             : */
   24975             : static swig_class SwigClassSpecBackendBuilderMap;
   24976             : 
   24977             : 
   24978             : /*
   24979             :   Document-method: Kdbtools::SpecBackendBuilderMap.new
   24980             : 
   24981             :   call-seq:
   24982             :     SpecBackendBuilderMap.new(std::less< kdb::Key > const & arg2)
   24983             :     SpecBackendBuilderMap.new
   24984             :     SpecBackendBuilderMap.new(SpecBackendBuilderMap arg2)
   24985             : 
   24986             : Class constructor.
   24987             : 
   24988             : */
   24989             : SWIGINTERN VALUE
   24990           0 : _wrap_new_SpecBackendBuilderMap__SWIG_0(int argc, VALUE *argv, VALUE self) {
   24991           0 :   std::less< kdb::Key > *arg1 = 0 ;
   24992             :   void *argp1 ;
   24993           0 :   int res1 = 0 ;
   24994           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *result = 0 ;
   24995             :   
   24996           0 :   if ((argc < 1) || (argc > 1)) {
   24997           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   24998             :   }
   24999           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__lessT_kdb__Key_t,  0 );
   25000           0 :   if (!SWIG_IsOK(res1)) {
   25001           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::less< kdb::Key > const &","map<(kdb::Key,kdb::tools::SpecBackendBuilder)>", 1, argv[0] )); 
   25002             :   }
   25003           0 :   if (!argp1) {
   25004           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::less< kdb::Key > const &","map<(kdb::Key,kdb::tools::SpecBackendBuilder)>", 1, argv[0])); 
   25005             :   }
   25006           0 :   arg1 = reinterpret_cast< std::less< kdb::Key > * >(argp1);
   25007           0 :   result = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *)new std::map< kdb::Key,kdb::tools::SpecBackendBuilder >((std::less< kdb::Key > const &)*arg1);
   25008           0 :   DATA_PTR(self) = result;
   25009             :   return self;
   25010             : fail:
   25011             :   return Qnil;
   25012             : }
   25013             : 
   25014             : 
   25015             : 
   25016             : /*
   25017             :   Document-method: Kdbtools::SpecBackendBuilderMap.dup
   25018             : 
   25019             :   call-seq:
   25020             :     dup -> SpecBackendBuilderMap
   25021             : 
   25022             : Create a duplicate of the class and unfreeze it if needed.
   25023             : */
   25024             : SWIGINTERN VALUE
   25025           0 : _wrap_SpecBackendBuilderMap_dup(int argc, VALUE *argv, VALUE self) {
   25026           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25027           0 :   void *argp1 = 0 ;
   25028           0 :   int res1 = 0 ;
   25029           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *result = 0 ;
   25030           0 :   VALUE vresult = Qnil;
   25031             :   
   25032           0 :   if ((argc < 0) || (argc > 0)) {
   25033           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25034             :   }
   25035           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25036           0 :   if (!SWIG_IsOK(res1)) {
   25037           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","dup", 1, self )); 
   25038             :   }
   25039           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25040           0 :   result = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__dup(arg1);
   25041           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, SWIG_POINTER_OWN |  0 );
   25042             :   return vresult;
   25043             : fail:
   25044             :   return Qnil;
   25045             : }
   25046             : 
   25047             : 
   25048             : 
   25049             : /*
   25050             :   Document-method: Kdbtools::SpecBackendBuilderMap.__delete__
   25051             : 
   25052             :   call-seq:
   25053             :     __delete__(key) -> VALUE
   25054             : 
   25055             : Delete a matching element.
   25056             : */
   25057             : SWIGINTERN VALUE
   25058           0 : _wrap_SpecBackendBuilderMap___delete__(int argc, VALUE *argv, VALUE self) {
   25059           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25060           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type *arg2 = 0 ;
   25061           0 :   void *argp1 = 0 ;
   25062           0 :   int res1 = 0 ;
   25063             :   void *argp2 ;
   25064           0 :   int res2 = 0 ;
   25065             :   VALUE result;
   25066           0 :   VALUE vresult = Qnil;
   25067             :   
   25068           0 :   if ((argc < 1) || (argc > 1)) {
   25069           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   25070             :   }
   25071           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25072           0 :   if (!SWIG_IsOK(res1)) {
   25073           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","__delete__", 1, self )); 
   25074             :   }
   25075           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25076           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   25077           0 :   if (!SWIG_IsOK(res2)) {
   25078           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","__delete__", 2, argv[0] )); 
   25079             :   }
   25080           0 :   if (!argp2) {
   25081           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","__delete__", 2, argv[0])); 
   25082             :   }
   25083           0 :   arg2 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type * >(argp2);
   25084           0 :   result = (VALUE)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg____delete__(arg1,(kdb::Key const &)*arg2);
   25085           0 :   vresult = result;
   25086             :   return vresult;
   25087             : fail:
   25088             :   return Qnil;
   25089             : }
   25090             : 
   25091             : 
   25092             : 
   25093             : /*
   25094             :   Document-method: Kdbtools::SpecBackendBuilderMap.has_key
   25095             : 
   25096             :   call-seq:
   25097             :     has_key(Key key) -> bool
   25098             : 
   25099             : An instance method.
   25100             : 
   25101             : */
   25102             : SWIGINTERN VALUE
   25103           0 : _wrap_SpecBackendBuilderMap_has_key(int argc, VALUE *argv, VALUE self) {
   25104           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25105           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type *arg2 = 0 ;
   25106           0 :   void *argp1 = 0 ;
   25107           0 :   int res1 = 0 ;
   25108             :   void *argp2 ;
   25109           0 :   int res2 = 0 ;
   25110             :   bool result;
   25111           0 :   VALUE vresult = Qnil;
   25112             :   
   25113           0 :   if ((argc < 1) || (argc > 1)) {
   25114           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   25115             :   }
   25116           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25117           0 :   if (!SWIG_IsOK(res1)) {
   25118           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *","has_key", 1, self )); 
   25119             :   }
   25120           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25121           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   25122           0 :   if (!SWIG_IsOK(res2)) {
   25123           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","has_key", 2, argv[0] )); 
   25124             :   }
   25125           0 :   if (!argp2) {
   25126           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","has_key", 2, argv[0])); 
   25127             :   }
   25128           0 :   arg2 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type * >(argp2);
   25129           0 :   result = (bool)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__has_key((std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *)arg1,(kdb::Key const &)*arg2);
   25130           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   25131             :   return vresult;
   25132             : fail:
   25133             :   return Qnil;
   25134             : }
   25135             : 
   25136             : 
   25137             : 
   25138             : /*
   25139             :   Document-method: Kdbtools::SpecBackendBuilderMap.keys
   25140             : 
   25141             :   call-seq:
   25142             :     keys -> VALUE
   25143             : 
   25144             : Return an Array of key elements.
   25145             : */
   25146             : SWIGINTERN VALUE
   25147           0 : _wrap_SpecBackendBuilderMap_keys(int argc, VALUE *argv, VALUE self) {
   25148           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25149           0 :   void *argp1 = 0 ;
   25150           0 :   int res1 = 0 ;
   25151             :   VALUE result;
   25152           0 :   VALUE vresult = Qnil;
   25153             :   
   25154           0 :   if ((argc < 0) || (argc > 0)) {
   25155           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25156             :   }
   25157           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25158           0 :   if (!SWIG_IsOK(res1)) {
   25159           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","keys", 1, self )); 
   25160             :   }
   25161           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25162           0 :   result = (VALUE)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__keys(arg1);
   25163           0 :   vresult = result;
   25164             :   return vresult;
   25165             : fail:
   25166             :   return Qnil;
   25167             : }
   25168             : 
   25169             : 
   25170             : 
   25171             : /*
   25172             :   Document-method: Kdbtools::SpecBackendBuilderMap.each
   25173             : 
   25174             :   call-seq:
   25175             :     each -> SpecBackendBuilderMap
   25176             : 
   25177             : Iterate thru each element in the SpecBackendBuilderMap.  A block must be provided.
   25178             : */
   25179             : SWIGINTERN VALUE
   25180           0 : _wrap_SpecBackendBuilderMap_each(int argc, VALUE *argv, VALUE self) {
   25181           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25182           0 :   void *argp1 = 0 ;
   25183           0 :   int res1 = 0 ;
   25184           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *result = 0 ;
   25185           0 :   VALUE vresult = Qnil;
   25186             :   
   25187           0 :   if ((argc < 0) || (argc > 0)) {
   25188           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25189             :   }
   25190           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25191           0 :   if (!SWIG_IsOK(res1)) {
   25192           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","each", 1, self )); 
   25193             :   }
   25194           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25195           0 :   result = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__each(arg1);
   25196           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25197             :   return vresult;
   25198             : fail:
   25199             :   return Qnil;
   25200             : }
   25201             : 
   25202             : 
   25203             : 
   25204             : /*
   25205             :   Document-method: Kdbtools::SpecBackendBuilderMap.select
   25206             : 
   25207             :   call-seq:
   25208             :     select -> SpecBackendBuilderMap
   25209             : 
   25210             : Iterate thru each element in the SpecBackendBuilderMap and select those that match a condition.  A block must be provided.
   25211             : */
   25212             : SWIGINTERN VALUE
   25213           0 : _wrap_SpecBackendBuilderMap_select(int argc, VALUE *argv, VALUE self) {
   25214           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25215           0 :   void *argp1 = 0 ;
   25216           0 :   int res1 = 0 ;
   25217           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *result = 0 ;
   25218           0 :   VALUE vresult = Qnil;
   25219             :   
   25220           0 :   if ((argc < 0) || (argc > 0)) {
   25221           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25222             :   }
   25223           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25224           0 :   if (!SWIG_IsOK(res1)) {
   25225           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","select", 1, self )); 
   25226             :   }
   25227           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25228           0 :   result = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__select(arg1);
   25229           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, SWIG_POINTER_OWN |  0 );
   25230             :   return vresult;
   25231             : fail:
   25232             :   return Qnil;
   25233             : }
   25234             : 
   25235             : 
   25236             : 
   25237             : /*
   25238             :   Document-method: Kdbtools::SpecBackendBuilderMap.values_at
   25239             : 
   25240             :   call-seq:
   25241             :     values_at(argc) -> VALUE
   25242             : 
   25243             : Return an Array of value elements matching the conditions.
   25244             : */
   25245             : SWIGINTERN VALUE
   25246           0 : _wrap_SpecBackendBuilderMap_values_at(int argc, VALUE *argv, VALUE self) {
   25247           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25248             :   int arg2 ;
   25249           0 :   VALUE *arg3 = (VALUE *) 0 ;
   25250           0 :   void *arg4 = 0 ;
   25251           0 :   void *argp1 = 0 ;
   25252           0 :   int res1 = 0 ;
   25253             :   VALUE result;
   25254           0 :   VALUE vresult = Qnil;
   25255             :   
   25256           0 :   if (argc < 1) {
   25257           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   25258             :   }
   25259           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25260           0 :   if (!SWIG_IsOK(res1)) {
   25261           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","values_at", 1, self )); 
   25262             :   }
   25263           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25264             :   {
   25265           0 :     arg2 = argc;
   25266           0 :     arg3 = argv;
   25267             :   }
   25268           0 :   result = (VALUE)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__values_at(arg1,arg2,arg3,arg4);
   25269           0 :   vresult = result;
   25270             :   return vresult;
   25271             : fail:
   25272             :   return Qnil;
   25273             : }
   25274             : 
   25275             : 
   25276             : 
   25277             : /*
   25278             :   Document-method: Kdbtools::SpecBackendBuilderMap.each_key
   25279             : 
   25280             :   call-seq:
   25281             :     each_key -> SpecBackendBuilderMap
   25282             : 
   25283             : Iterate thru each key element in the SpecBackendBuilderMap.  A block must be provided.
   25284             : */
   25285             : SWIGINTERN VALUE
   25286           0 : _wrap_SpecBackendBuilderMap_each_key(int argc, VALUE *argv, VALUE self) {
   25287           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25288           0 :   void *argp1 = 0 ;
   25289           0 :   int res1 = 0 ;
   25290           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *result = 0 ;
   25291           0 :   VALUE vresult = Qnil;
   25292             :   
   25293           0 :   if ((argc < 0) || (argc > 0)) {
   25294           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25295             :   }
   25296           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25297           0 :   if (!SWIG_IsOK(res1)) {
   25298           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","each_key", 1, self )); 
   25299             :   }
   25300           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25301           0 :   result = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__each_key(arg1);
   25302           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25303             :   return vresult;
   25304             : fail:
   25305             :   return Qnil;
   25306             : }
   25307             : 
   25308             : 
   25309             : 
   25310             : /*
   25311             :   Document-method: Kdbtools::SpecBackendBuilderMap.values
   25312             : 
   25313             :   call-seq:
   25314             :     values -> VALUE
   25315             : 
   25316             : Return an Array of value elements.
   25317             : */
   25318             : SWIGINTERN VALUE
   25319           0 : _wrap_SpecBackendBuilderMap_values(int argc, VALUE *argv, VALUE self) {
   25320           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25321           0 :   void *argp1 = 0 ;
   25322           0 :   int res1 = 0 ;
   25323             :   VALUE result;
   25324           0 :   VALUE vresult = Qnil;
   25325             :   
   25326           0 :   if ((argc < 0) || (argc > 0)) {
   25327           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25328             :   }
   25329           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25330           0 :   if (!SWIG_IsOK(res1)) {
   25331           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","values", 1, self )); 
   25332             :   }
   25333           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25334           0 :   result = (VALUE)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__values(arg1);
   25335           0 :   vresult = result;
   25336             :   return vresult;
   25337             : fail:
   25338             :   return Qnil;
   25339             : }
   25340             : 
   25341             : 
   25342             : 
   25343             : /*
   25344             :   Document-method: Kdbtools::SpecBackendBuilderMap.each_value
   25345             : 
   25346             :   call-seq:
   25347             :     each_value -> SpecBackendBuilderMap
   25348             : 
   25349             : Iterate thru each key element in the SpecBackendBuilderMap.  A block must be provided.
   25350             : */
   25351             : SWIGINTERN VALUE
   25352           0 : _wrap_SpecBackendBuilderMap_each_value(int argc, VALUE *argv, VALUE self) {
   25353           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25354           0 :   void *argp1 = 0 ;
   25355           0 :   int res1 = 0 ;
   25356           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *result = 0 ;
   25357           0 :   VALUE vresult = Qnil;
   25358             :   
   25359           0 :   if ((argc < 0) || (argc > 0)) {
   25360           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25361             :   }
   25362           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25363           0 :   if (!SWIG_IsOK(res1)) {
   25364           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","each_value", 1, self )); 
   25365             :   }
   25366           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25367           0 :   result = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__each_value(arg1);
   25368           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25369             :   return vresult;
   25370             : fail:
   25371             :   return Qnil;
   25372             : }
   25373             : 
   25374             : 
   25375             : 
   25376             : /*
   25377             :   Document-method: Kdbtools::SpecBackendBuilderMap.entries
   25378             : 
   25379             :   call-seq:
   25380             :     entries -> VALUE
   25381             : 
   25382             : An instance method.
   25383             : 
   25384             : */
   25385             : SWIGINTERN VALUE
   25386           0 : _wrap_SpecBackendBuilderMap_entries(int argc, VALUE *argv, VALUE self) {
   25387           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25388           0 :   void *argp1 = 0 ;
   25389           0 :   int res1 = 0 ;
   25390             :   VALUE result;
   25391           0 :   VALUE vresult = Qnil;
   25392             :   
   25393           0 :   if ((argc < 0) || (argc > 0)) {
   25394           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25395             :   }
   25396           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25397           0 :   if (!SWIG_IsOK(res1)) {
   25398           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","entries", 1, self )); 
   25399             :   }
   25400           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25401           0 :   result = (VALUE)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__entries(arg1);
   25402           0 :   vresult = result;
   25403             :   return vresult;
   25404             : fail:
   25405             :   return Qnil;
   25406             : }
   25407             : 
   25408             : 
   25409             : 
   25410             : /*
   25411             :   Document-method: Kdbtools::SpecBackendBuilderMap.__contains__
   25412             : 
   25413             :   call-seq:
   25414             :     __contains__(Key key) -> bool
   25415             : 
   25416             : An instance method.
   25417             : 
   25418             : */
   25419             : SWIGINTERN VALUE
   25420           0 : _wrap_SpecBackendBuilderMap___contains__(int argc, VALUE *argv, VALUE self) {
   25421           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25422           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type *arg2 = 0 ;
   25423           0 :   void *argp1 = 0 ;
   25424           0 :   int res1 = 0 ;
   25425             :   void *argp2 ;
   25426           0 :   int res2 = 0 ;
   25427             :   bool result;
   25428           0 :   VALUE vresult = Qnil;
   25429             :   
   25430           0 :   if ((argc < 1) || (argc > 1)) {
   25431           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   25432             :   }
   25433           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25434           0 :   if (!SWIG_IsOK(res1)) {
   25435           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","__contains__", 1, self )); 
   25436             :   }
   25437           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25438           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   25439           0 :   if (!SWIG_IsOK(res2)) {
   25440           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","__contains__", 2, argv[0] )); 
   25441             :   }
   25442           0 :   if (!argp2) {
   25443           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","__contains__", 2, argv[0])); 
   25444             :   }
   25445           0 :   arg2 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type * >(argp2);
   25446           0 :   result = (bool)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg____contains__(arg1,(kdb::Key const &)*arg2);
   25447           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   25448             :   return vresult;
   25449             : fail:
   25450             :   return Qnil;
   25451             : }
   25452             : 
   25453             : 
   25454             : 
   25455             : /*
   25456             :   Document-method: Kdbtools::SpecBackendBuilderMap.key_iterator
   25457             : 
   25458             :   call-seq:
   25459             :     key_iterator -> ConstIterator
   25460             : 
   25461             : An instance method.
   25462             : 
   25463             : */
   25464             : SWIGINTERN VALUE
   25465           0 : _wrap_SpecBackendBuilderMap_key_iterator(int argc, VALUE *argv, VALUE self) {
   25466           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25467           0 :   VALUE *arg2 = (VALUE *) 0 ;
   25468           0 :   void *argp1 = 0 ;
   25469           0 :   int res1 = 0 ;
   25470           0 :   swig::ConstIterator *result = 0 ;
   25471           0 :   VALUE vresult = Qnil;
   25472             :   
   25473           0 :   arg2 = &self;
   25474           0 :   if ((argc < 0) || (argc > 0)) {
   25475           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25476             :   }
   25477           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25478           0 :   if (!SWIG_IsOK(res1)) {
   25479           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","key_iterator", 1, self )); 
   25480             :   }
   25481           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25482           0 :   result = (swig::ConstIterator *)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__key_iterator(arg1,arg2);
   25483           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
   25484             :   return vresult;
   25485             : fail:
   25486             :   return Qnil;
   25487             : }
   25488             : 
   25489             : 
   25490             : 
   25491             : /*
   25492             :   Document-method: Kdbtools::SpecBackendBuilderMap.value_iterator
   25493             : 
   25494             :   call-seq:
   25495             :     value_iterator -> ConstIterator
   25496             : 
   25497             : An instance method.
   25498             : 
   25499             : */
   25500             : SWIGINTERN VALUE
   25501           0 : _wrap_SpecBackendBuilderMap_value_iterator(int argc, VALUE *argv, VALUE self) {
   25502           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25503           0 :   VALUE *arg2 = (VALUE *) 0 ;
   25504           0 :   void *argp1 = 0 ;
   25505           0 :   int res1 = 0 ;
   25506           0 :   swig::ConstIterator *result = 0 ;
   25507           0 :   VALUE vresult = Qnil;
   25508             :   
   25509           0 :   arg2 = &self;
   25510           0 :   if ((argc < 0) || (argc > 0)) {
   25511           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25512             :   }
   25513           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25514           0 :   if (!SWIG_IsOK(res1)) {
   25515           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","value_iterator", 1, self )); 
   25516             :   }
   25517           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25518           0 :   result = (swig::ConstIterator *)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__value_iterator(arg1,arg2);
   25519           0 :   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
   25520             :   return vresult;
   25521             : fail:
   25522             :   return Qnil;
   25523             : }
   25524             : 
   25525             : 
   25526             : 
   25527             : /*
   25528             :   Document-method: Kdbtools::SpecBackendBuilderMap.[]
   25529             : 
   25530             :   call-seq:
   25531             :     [](key) -> VALUE
   25532             : 
   25533             : Element accessor/slicing.
   25534             : */
   25535             : SWIGINTERN VALUE
   25536           1 : _wrap_SpecBackendBuilderMap___getitem__(int argc, VALUE *argv, VALUE self) {
   25537           1 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25538           1 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type *arg2 = 0 ;
   25539           1 :   void *argp1 = 0 ;
   25540           1 :   int res1 = 0 ;
   25541             :   void *argp2 ;
   25542           1 :   int res2 = 0 ;
   25543             :   VALUE result;
   25544           1 :   VALUE vresult = Qnil;
   25545             :   
   25546           1 :   if ((argc < 1) || (argc > 1)) {
   25547           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   25548             :   }
   25549           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25550           1 :   if (!SWIG_IsOK(res1)) {
   25551           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *","__getitem__", 1, self )); 
   25552             :   }
   25553           1 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25554           1 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   25555           1 :   if (!SWIG_IsOK(res2)) {
   25556           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","__getitem__", 2, argv[0] )); 
   25557             :   }
   25558           1 :   if (!argp2) {
   25559           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","__getitem__", 2, argv[0])); 
   25560             :   }
   25561           1 :   arg2 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type * >(argp2);
   25562           1 :   result = (VALUE)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg____getitem__((std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *)arg1,(kdb::Key const &)*arg2);
   25563           1 :   vresult = result;
   25564             :   return vresult;
   25565             : fail:
   25566             :   return Qnil;
   25567             : }
   25568             : 
   25569             : 
   25570             : 
   25571             : /*
   25572             :   Document-method: Kdbtools::SpecBackendBuilderMap.[]=
   25573             : 
   25574             :   call-seq:
   25575             :     []=(key, x)
   25576             : 
   25577             : Element setter/slicing.
   25578             : */
   25579             : SWIGINTERN VALUE
   25580           0 : _wrap_SpecBackendBuilderMap___setitem__(int argc, VALUE *argv, VALUE self) {
   25581           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25582           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type *arg2 = 0 ;
   25583           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::mapped_type *arg3 = 0 ;
   25584           0 :   void *argp1 = 0 ;
   25585           0 :   int res1 = 0 ;
   25586             :   void *argp2 ;
   25587           0 :   int res2 = 0 ;
   25588             :   void *argp3 ;
   25589           0 :   int res3 = 0 ;
   25590             :   
   25591           0 :   if ((argc < 2) || (argc > 2)) {
   25592           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   25593             :   }
   25594           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25595           0 :   if (!SWIG_IsOK(res1)) {
   25596           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","__setitem__", 1, self )); 
   25597             :   }
   25598           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25599           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   25600           0 :   if (!SWIG_IsOK(res2)) {
   25601           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","__setitem__", 2, argv[0] )); 
   25602             :   }
   25603           0 :   if (!argp2) {
   25604           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","__setitem__", 2, argv[0])); 
   25605             :   }
   25606           0 :   arg2 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type * >(argp2);
   25607           0 :   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_kdb__tools__SpecBackendBuilder,  0 );
   25608           0 :   if (!SWIG_IsOK(res3)) {
   25609           0 :     SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::mapped_type const &","__setitem__", 3, argv[1] )); 
   25610             :   }
   25611           0 :   if (!argp3) {
   25612           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::mapped_type const &","__setitem__", 3, argv[1])); 
   25613             :   }
   25614           0 :   arg3 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::mapped_type * >(argp3);
   25615             :   try {
   25616           0 :     std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg____setitem__(arg1,(kdb::Key const &)*arg2,(kdb::tools::SpecBackendBuilder const &)*arg3);
   25617             :   }
   25618           0 :   catch(std::out_of_range &_e) {
   25619           0 :     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   25620             :   }
   25621             :   
   25622             :   return Qnil;
   25623             : fail:
   25624             :   return Qnil;
   25625             : }
   25626             : 
   25627             : 
   25628             : 
   25629             : /*
   25630             :   Document-method: Kdbtools::SpecBackendBuilderMap.inspect
   25631             : 
   25632             :   call-seq:
   25633             :     inspect -> VALUE
   25634             : 
   25635             : Inspect class and its contents.
   25636             : */
   25637             : SWIGINTERN VALUE
   25638           0 : _wrap_SpecBackendBuilderMap_inspect(int argc, VALUE *argv, VALUE self) {
   25639           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25640           0 :   void *argp1 = 0 ;
   25641           0 :   int res1 = 0 ;
   25642             :   VALUE result;
   25643           0 :   VALUE vresult = Qnil;
   25644             :   
   25645           0 :   if ((argc < 0) || (argc > 0)) {
   25646           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25647             :   }
   25648           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25649           0 :   if (!SWIG_IsOK(res1)) {
   25650           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","inspect", 1, self )); 
   25651             :   }
   25652           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25653           0 :   result = (VALUE)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__inspect(arg1);
   25654           0 :   vresult = result;
   25655             :   return vresult;
   25656             : fail:
   25657             :   return Qnil;
   25658             : }
   25659             : 
   25660             : 
   25661             : 
   25662             : /*
   25663             :   Document-method: Kdbtools::SpecBackendBuilderMap.to_a
   25664             : 
   25665             :   call-seq:
   25666             :     to_a -> VALUE
   25667             : 
   25668             : Convert SpecBackendBuilderMap to an Array.
   25669             : */
   25670             : SWIGINTERN VALUE
   25671           0 : _wrap_SpecBackendBuilderMap_to_a(int argc, VALUE *argv, VALUE self) {
   25672           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25673           0 :   void *argp1 = 0 ;
   25674           0 :   int res1 = 0 ;
   25675             :   VALUE result;
   25676           0 :   VALUE vresult = Qnil;
   25677             :   
   25678           0 :   if ((argc < 0) || (argc > 0)) {
   25679           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25680             :   }
   25681           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25682           0 :   if (!SWIG_IsOK(res1)) {
   25683           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","to_a", 1, self )); 
   25684             :   }
   25685           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25686           0 :   result = (VALUE)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__to_a(arg1);
   25687           0 :   vresult = result;
   25688             :   return vresult;
   25689             : fail:
   25690             :   return Qnil;
   25691             : }
   25692             : 
   25693             : 
   25694             : 
   25695             : /*
   25696             :   Document-method: Kdbtools::SpecBackendBuilderMap.to_s
   25697             : 
   25698             :   call-seq:
   25699             :     to_s -> VALUE
   25700             : 
   25701             : Convert class to a String representation.
   25702             : */
   25703             : SWIGINTERN VALUE
   25704           0 : _wrap_SpecBackendBuilderMap_to_s(int argc, VALUE *argv, VALUE self) {
   25705           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25706           0 :   void *argp1 = 0 ;
   25707           0 :   int res1 = 0 ;
   25708             :   VALUE result;
   25709           0 :   VALUE vresult = Qnil;
   25710             :   
   25711           0 :   if ((argc < 0) || (argc > 0)) {
   25712           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25713             :   }
   25714           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25715           0 :   if (!SWIG_IsOK(res1)) {
   25716           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","to_s", 1, self )); 
   25717             :   }
   25718           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25719           0 :   result = (VALUE)std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg__to_s(arg1);
   25720           0 :   vresult = result;
   25721             :   return vresult;
   25722             : fail:
   25723             :   return Qnil;
   25724             : }
   25725             : 
   25726             : 
   25727             : 
   25728             : /*
   25729             :   Document-method: Kdbtools::SpecBackendBuilderMap.new
   25730             : 
   25731             :   call-seq:
   25732             :     SpecBackendBuilderMap.new(std::less< kdb::Key > const & arg2)
   25733             :     SpecBackendBuilderMap.new
   25734             :     SpecBackendBuilderMap.new(SpecBackendBuilderMap arg2)
   25735             : 
   25736             : Class constructor.
   25737             : 
   25738             : */
   25739             : SWIGINTERN VALUE
   25740           0 : _wrap_new_SpecBackendBuilderMap__SWIG_1(int argc, VALUE *argv, VALUE self) {
   25741           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *result = 0 ;
   25742             :   
   25743           0 :   if ((argc < 0) || (argc > 0)) {
   25744           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25745             :   }
   25746           0 :   result = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *)new std::map< kdb::Key,kdb::tools::SpecBackendBuilder >();
   25747           0 :   DATA_PTR(self) = result;
   25748             :   return self;
   25749             : fail:
   25750             :   return Qnil;
   25751             : }
   25752             : 
   25753             : 
   25754             : SWIGINTERN VALUE
   25755             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   25756           0 : _wrap_SpecBackendBuilderMap_allocate(VALUE self)
   25757             : #else
   25758             : _wrap_SpecBackendBuilderMap_allocate(int argc, VALUE *argv, VALUE self)
   25759             : #endif
   25760             : {
   25761           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t);
   25762             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   25763             :   rb_obj_call_init(vresult, argc, argv);
   25764             : #endif
   25765           0 :   return vresult;
   25766             : }
   25767             : 
   25768             : 
   25769             : SWIGINTERN VALUE
   25770           0 : _wrap_new_SpecBackendBuilderMap__SWIG_2(int argc, VALUE *argv, VALUE self) {
   25771           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = 0 ;
   25772           0 :   int res1 = SWIG_OLDOBJ ;
   25773           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *result = 0 ;
   25774             :   
   25775           0 :   if ((argc < 1) || (argc > 1)) {
   25776           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   25777             :   }
   25778             :   {
   25779           0 :     std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *ptr = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *)0;
   25780           0 :     res1 = swig::asptr(argv[0], &ptr);
   25781           0 :     if (!SWIG_IsOK(res1)) {
   25782           0 :       SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const &","map<(kdb::Key,kdb::tools::SpecBackendBuilder)>", 1, argv[0] )); 
   25783             :     }
   25784           0 :     if (!ptr) {
   25785           0 :       SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const &","map<(kdb::Key,kdb::tools::SpecBackendBuilder)>", 1, argv[0])); 
   25786             :     }
   25787           0 :     arg1 = ptr;
   25788             :   }
   25789           0 :   result = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *)new std::map< kdb::Key,kdb::tools::SpecBackendBuilder >((std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const &)*arg1);
   25790           0 :   DATA_PTR(self) = result;
   25791           0 :   if (SWIG_IsNewObj(res1)) delete arg1;
   25792             :   return self;
   25793             : fail:
   25794             :   if (SWIG_IsNewObj(res1)) delete arg1;
   25795             :   return Qnil;
   25796             : }
   25797             : 
   25798             : 
   25799           0 : SWIGINTERN VALUE _wrap_new_SpecBackendBuilderMap(int nargs, VALUE *args, VALUE self) {
   25800             :   int argc;
   25801             :   VALUE argv[1];
   25802             :   int ii;
   25803             :   
   25804           0 :   argc = nargs;
   25805           0 :   if (argc > 1) SWIG_fail;
   25806           0 :   for (ii = 0; (ii < argc); ++ii) {
   25807           0 :     argv[ii] = args[ii];
   25808             :   }
   25809           0 :   if (argc == 0) {
   25810           0 :     return _wrap_new_SpecBackendBuilderMap__SWIG_1(nargs, args, self);
   25811             :   }
   25812           0 :   if (argc == 1) {
   25813           0 :     int _v = 0;
   25814             :     {
   25815           0 :       void *vptr = 0;
   25816           0 :       int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__lessT_kdb__Key_t, 0);
   25817           0 :       _v = SWIG_CheckState(res);
   25818             :     }
   25819           0 :     if (!_v) goto check_2;
   25820           0 :     return _wrap_new_SpecBackendBuilderMap__SWIG_0(nargs, args, self);
   25821             :   }
   25822             : check_2:
   25823             :   
   25824           0 :   if (argc == 1) {
   25825           0 :     return _wrap_new_SpecBackendBuilderMap__SWIG_2(nargs, args, self);
   25826             :   }
   25827             :   
   25828             : fail:
   25829             :   Ruby_Format_OverloadedError( argc, 1, "SpecBackendBuilderMap.new", 
   25830             :     "    SpecBackendBuilderMap.new(std::less< kdb::Key > const &)\n"
   25831             :     "    SpecBackendBuilderMap.new()\n"
   25832           0 :     "    SpecBackendBuilderMap.new(std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const &)\n");
   25833             :   
   25834             :   return Qnil;
   25835             : }
   25836             : 
   25837             : 
   25838             : 
   25839             : /*
   25840             :   Document-method: Kdbtools::SpecBackendBuilderMap.empty
   25841             : 
   25842             :   call-seq:
   25843             :     empty -> bool
   25844             : 
   25845             : Check if the SpecBackendBuilderMap is empty or not.
   25846             : */
   25847             : SWIGINTERN VALUE
   25848           0 : _wrap_SpecBackendBuilderMap_empty(int argc, VALUE *argv, VALUE self) {
   25849           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25850           0 :   void *argp1 = 0 ;
   25851           0 :   int res1 = 0 ;
   25852             :   bool result;
   25853           0 :   VALUE vresult = Qnil;
   25854             :   
   25855           0 :   if ((argc < 0) || (argc > 0)) {
   25856           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25857             :   }
   25858           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25859           0 :   if (!SWIG_IsOK(res1)) {
   25860           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *","empty", 1, self )); 
   25861             :   }
   25862           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25863           0 :   result = (bool)((std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *)arg1)->empty();
   25864           0 :   vresult = SWIG_From_bool(static_cast< bool >(result));
   25865             :   return vresult;
   25866             : fail:
   25867             :   return Qnil;
   25868             : }
   25869             : 
   25870             : 
   25871             : 
   25872             : /*
   25873             :   Document-method: Kdbtools::SpecBackendBuilderMap.size
   25874             : 
   25875             :   call-seq:
   25876             :     size -> std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::size_type
   25877             : 
   25878             : Size or Length of the SpecBackendBuilderMap.
   25879             : */
   25880             : SWIGINTERN VALUE
   25881           1 : _wrap_SpecBackendBuilderMap_size(int argc, VALUE *argv, VALUE self) {
   25882           1 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25883           1 :   void *argp1 = 0 ;
   25884           1 :   int res1 = 0 ;
   25885             :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::size_type result;
   25886           1 :   VALUE vresult = Qnil;
   25887             :   
   25888           1 :   if ((argc < 0) || (argc > 0)) {
   25889           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25890             :   }
   25891           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25892           1 :   if (!SWIG_IsOK(res1)) {
   25893           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *","size", 1, self )); 
   25894             :   }
   25895           1 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25896           1 :   result = ((std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *)arg1)->size();
   25897           1 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
   25898             :   return vresult;
   25899             : fail:
   25900             :   return Qnil;
   25901             : }
   25902             : 
   25903             : 
   25904             : 
   25905             : /*
   25906             :   Document-method: Kdbtools::SpecBackendBuilderMap.swap
   25907             : 
   25908             :   call-seq:
   25909             :     swap(SpecBackendBuilderMap v)
   25910             : 
   25911             : An instance method.
   25912             : 
   25913             : */
   25914             : SWIGINTERN VALUE
   25915           0 : _wrap_SpecBackendBuilderMap_swap(int argc, VALUE *argv, VALUE self) {
   25916           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25917           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg2 = 0 ;
   25918           0 :   void *argp1 = 0 ;
   25919           0 :   int res1 = 0 ;
   25920           0 :   void *argp2 = 0 ;
   25921           0 :   int res2 = 0 ;
   25922             :   
   25923           0 :   if ((argc < 1) || (argc > 1)) {
   25924           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   25925             :   }
   25926           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25927           0 :   if (!SWIG_IsOK(res1)) {
   25928           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","swap", 1, self )); 
   25929             :   }
   25930           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25931           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t,  0 );
   25932           0 :   if (!SWIG_IsOK(res2)) {
   25933           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > &","swap", 2, argv[0] )); 
   25934             :   }
   25935           0 :   if (!argp2) {
   25936           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > &","swap", 2, argv[0])); 
   25937             :   }
   25938           0 :   arg2 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp2);
   25939           0 :   (arg1)->swap(*arg2);
   25940             :   return Qnil;
   25941             : fail:
   25942             :   return Qnil;
   25943             : }
   25944             : 
   25945             : 
   25946             : 
   25947             : /*
   25948             :   Document-method: Kdbtools::SpecBackendBuilderMap.clear
   25949             : 
   25950             :   call-seq:
   25951             :     clear
   25952             : 
   25953             : Clear SpecBackendBuilderMap contents.
   25954             : */
   25955             : SWIGINTERN VALUE
   25956           0 : _wrap_SpecBackendBuilderMap_clear(int argc, VALUE *argv, VALUE self) {
   25957           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25958           0 :   void *argp1 = 0 ;
   25959           0 :   int res1 = 0 ;
   25960             :   
   25961           0 :   if ((argc < 0) || (argc > 0)) {
   25962           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25963             :   }
   25964           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25965           0 :   if (!SWIG_IsOK(res1)) {
   25966           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","clear", 1, self )); 
   25967             :   }
   25968           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   25969           0 :   (arg1)->clear();
   25970             :   return Qnil;
   25971             : fail:
   25972             :   return Qnil;
   25973             : }
   25974             : 
   25975             : 
   25976             : 
   25977             : /*
   25978             :   Document-method: Kdbtools::SpecBackendBuilderMap.get_allocator
   25979             : 
   25980             :   call-seq:
   25981             :     get_allocator -> std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::allocator_type
   25982             : 
   25983             : An instance method.
   25984             : 
   25985             : */
   25986             : SWIGINTERN VALUE
   25987           0 : _wrap_SpecBackendBuilderMap_get_allocator(int argc, VALUE *argv, VALUE self) {
   25988           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   25989           0 :   void *argp1 = 0 ;
   25990           0 :   int res1 = 0 ;
   25991           0 :   SwigValueWrapper< std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > result;
   25992           0 :   VALUE vresult = Qnil;
   25993             :   
   25994           0 :   if ((argc < 0) || (argc > 0)) {
   25995           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   25996             :   }
   25997           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   25998           0 :   if (!SWIG_IsOK(res1)) {
   25999           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *","get_allocator", 1, self )); 
   26000             :   }
   26001           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   26002           0 :   result = ((std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *)arg1)->get_allocator();
   26003           0 :   vresult = SWIG_NewPointerObj((new std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::allocator_type(static_cast< const std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t, SWIG_POINTER_OWN |  0 );
   26004           0 :   return vresult;
   26005             : fail:
   26006             :   return Qnil;
   26007             : }
   26008             : 
   26009             : 
   26010             : 
   26011             : /*
   26012             :   Document-method: Kdbtools::SpecBackendBuilderMap.erase
   26013             : 
   26014             :   call-seq:
   26015             :     erase(x) -> std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::size_type
   26016             : 
   26017             : Delete a portion of the SpecBackendBuilderMap.
   26018             : */
   26019             : SWIGINTERN VALUE
   26020           0 : _wrap_SpecBackendBuilderMap_erase(int argc, VALUE *argv, VALUE self) {
   26021           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   26022           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type *arg2 = 0 ;
   26023           0 :   void *argp1 = 0 ;
   26024           0 :   int res1 = 0 ;
   26025             :   void *argp2 ;
   26026           0 :   int res2 = 0 ;
   26027             :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::size_type result;
   26028           0 :   VALUE vresult = Qnil;
   26029             :   
   26030           0 :   if ((argc < 1) || (argc > 1)) {
   26031           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   26032             :   }
   26033           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   26034           0 :   if (!SWIG_IsOK(res1)) {
   26035           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *","erase", 1, self )); 
   26036             :   }
   26037           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   26038           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   26039           0 :   if (!SWIG_IsOK(res2)) {
   26040           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","erase", 2, argv[0] )); 
   26041             :   }
   26042           0 :   if (!argp2) {
   26043           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","erase", 2, argv[0])); 
   26044             :   }
   26045           0 :   arg2 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type * >(argp2);
   26046           0 :   result = (arg1)->erase((std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &)*arg2);
   26047           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
   26048             :   return vresult;
   26049             : fail:
   26050             :   return Qnil;
   26051             : }
   26052             : 
   26053             : 
   26054             : 
   26055             : /*
   26056             :   Document-method: Kdbtools::SpecBackendBuilderMap.count
   26057             : 
   26058             :   call-seq:
   26059             :     count(Key x) -> std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::size_type
   26060             : 
   26061             : An instance method.
   26062             : 
   26063             : */
   26064             : SWIGINTERN VALUE
   26065           0 : _wrap_SpecBackendBuilderMap_count(int argc, VALUE *argv, VALUE self) {
   26066           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *) 0 ;
   26067           0 :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type *arg2 = 0 ;
   26068           0 :   void *argp1 = 0 ;
   26069           0 :   int res1 = 0 ;
   26070             :   void *argp2 ;
   26071           0 :   int res2 = 0 ;
   26072             :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::size_type result;
   26073           0 :   VALUE vresult = Qnil;
   26074             :   
   26075           0 :   if ((argc < 1) || (argc > 1)) {
   26076           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   26077             :   }
   26078           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0 |  0 );
   26079           0 :   if (!SWIG_IsOK(res1)) {
   26080           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *","count", 1, self )); 
   26081             :   }
   26082           0 :   arg1 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder > * >(argp1);
   26083           0 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__Key,  0 );
   26084           0 :   if (!SWIG_IsOK(res2)) {
   26085           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","count", 2, argv[0] )); 
   26086             :   }
   26087           0 :   if (!argp2) {
   26088           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &","count", 2, argv[0])); 
   26089             :   }
   26090           0 :   arg2 = reinterpret_cast< std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type * >(argp2);
   26091           0 :   result = ((std::map< kdb::Key,kdb::tools::SpecBackendBuilder > const *)arg1)->count((std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type const &)*arg2);
   26092           0 :   vresult = SWIG_From_size_t(static_cast< size_t >(result));
   26093             :   return vresult;
   26094             : fail:
   26095             :   return Qnil;
   26096             : }
   26097             : 
   26098             : 
   26099             : SWIGINTERN void
   26100           1 : free_std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg_(void *self) {
   26101           1 :     std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *arg1 = (std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *)self;
   26102           2 :     delete arg1;
   26103           1 : }
   26104             : 
   26105             : 
   26106             : /*
   26107             :   Document-class: Kdbtools::SpecBackendBuilder < Kdbtools::kdb::tools::MountBackendBuilder
   26108             : 
   26109             :   Proxy of C++ Kdbtools::SpecBackendBuilder class
   26110             : 
   26111             : 
   26112             : */
   26113             : static swig_class SwigClassSpecBackendBuilder;
   26114             : 
   26115             : 
   26116             : /*
   26117             :   Document-method: Kdbtools::SpecBackendBuilder.new
   26118             : 
   26119             :   call-seq:
   26120             :     SpecBackendBuilder.new(kdb::tools::BackendBuilderInit const & bbi=kdb::tools::BackendBuilderInit())
   26121             :     SpecBackendBuilder.new
   26122             : 
   26123             : Class constructor.
   26124             : 
   26125             : */
   26126             : SWIGINTERN VALUE
   26127           0 : _wrap_new_SpecBackendBuilder__SWIG_0(int argc, VALUE *argv, VALUE self) {
   26128           0 :   kdb::tools::BackendBuilderInit *arg1 = 0 ;
   26129             :   void *argp1 ;
   26130           0 :   int res1 = 0 ;
   26131           0 :   kdb::tools::SpecBackendBuilder *result = 0 ;
   26132             :   
   26133           0 :   if ((argc < 1) || (argc > 1)) {
   26134           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   26135             :   }
   26136           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__tools__BackendBuilderInit,  0 );
   26137           0 :   if (!SWIG_IsOK(res1)) {
   26138           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilderInit const &","SpecBackendBuilder", 1, argv[0] )); 
   26139             :   }
   26140           0 :   if (!argp1) {
   26141           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::BackendBuilderInit const &","SpecBackendBuilder", 1, argv[0])); 
   26142             :   }
   26143           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilderInit * >(argp1);
   26144           0 :   result = (kdb::tools::SpecBackendBuilder *)new kdb::tools::SpecBackendBuilder((kdb::tools::BackendBuilderInit const &)*arg1);
   26145           0 :   DATA_PTR(self) = result;
   26146             :   return self;
   26147             : fail:
   26148             :   return Qnil;
   26149             : }
   26150             : 
   26151             : 
   26152             : SWIGINTERN VALUE
   26153             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   26154           0 : _wrap_SpecBackendBuilder_allocate(VALUE self)
   26155             : #else
   26156             : _wrap_SpecBackendBuilder_allocate(int argc, VALUE *argv, VALUE self)
   26157             : #endif
   26158             : {
   26159           0 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__SpecBackendBuilder);
   26160             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   26161             :   rb_obj_call_init(vresult, argc, argv);
   26162             : #endif
   26163           0 :   return vresult;
   26164             : }
   26165             : 
   26166             : 
   26167             : SWIGINTERN VALUE
   26168           0 : _wrap_new_SpecBackendBuilder__SWIG_1(int argc, VALUE *argv, VALUE self) {
   26169           0 :   kdb::tools::SpecBackendBuilder *result = 0 ;
   26170             :   
   26171           0 :   if ((argc < 0) || (argc > 0)) {
   26172           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   26173             :   }
   26174           0 :   result = (kdb::tools::SpecBackendBuilder *)new kdb::tools::SpecBackendBuilder();
   26175           0 :   DATA_PTR(self) = result;
   26176             :   return self;
   26177             : fail:
   26178             :   return Qnil;
   26179             : }
   26180             : 
   26181             : 
   26182           0 : SWIGINTERN VALUE _wrap_new_SpecBackendBuilder(int nargs, VALUE *args, VALUE self) {
   26183             :   int argc;
   26184             :   VALUE argv[1];
   26185             :   int ii;
   26186             :   
   26187           0 :   argc = nargs;
   26188           0 :   if (argc > 1) SWIG_fail;
   26189             :   for (ii = 0; (ii < argc); ++ii) {
   26190             :     argv[ii] = args[ii];
   26191             :   }
   26192           0 :   if (argc == 0) {
   26193           0 :     return _wrap_new_SpecBackendBuilder__SWIG_1(nargs, args, self);
   26194             :   }
   26195           0 :   if (argc == 1) {
   26196           0 :     return _wrap_new_SpecBackendBuilder__SWIG_0(nargs, args, self);
   26197             :   }
   26198             :   
   26199             : fail:
   26200             :   Ruby_Format_OverloadedError( argc, 1, "SpecBackendBuilder.new", 
   26201             :     "    SpecBackendBuilder.new(kdb::tools::BackendBuilderInit const &bbi)\n"
   26202           0 :     "    SpecBackendBuilder.new()\n");
   26203             :   
   26204             :   return Qnil;
   26205             : }
   26206             : 
   26207             : 
   26208             : 
   26209             : /*
   26210             :   Document-method: Kdbtools::SpecBackendBuilder.nodes
   26211             : 
   26212             :   call-seq:
   26213             :     nodes -> int
   26214             : 
   26215             : Get value of attribute.
   26216             : 
   26217             : */
   26218             : 
   26219             : /*
   26220             :   Document-method: Kdbtools::SpecBackendBuilder.nodes=
   26221             : 
   26222             :   call-seq:
   26223             :     nodes=(x) -> int
   26224             : 
   26225             : Set new value for attribute.
   26226             : 
   26227             : */
   26228             : SWIGINTERN VALUE
   26229           0 : _wrap_SpecBackendBuilder_nodes_set(int argc, VALUE *argv, VALUE self) {
   26230           0 :   kdb::tools::SpecBackendBuilder *arg1 = (kdb::tools::SpecBackendBuilder *) 0 ;
   26231             :   int arg2 ;
   26232           0 :   void *argp1 = 0 ;
   26233           0 :   int res1 = 0 ;
   26234             :   int val2 ;
   26235           0 :   int ecode2 = 0 ;
   26236             :   
   26237           0 :   if ((argc < 1) || (argc > 1)) {
   26238           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   26239             :   }
   26240           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SpecBackendBuilder, 0 |  0 );
   26241           0 :   if (!SWIG_IsOK(res1)) {
   26242           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SpecBackendBuilder *","nodes", 1, self )); 
   26243             :   }
   26244           0 :   arg1 = reinterpret_cast< kdb::tools::SpecBackendBuilder * >(argp1);
   26245           0 :   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   26246           0 :   if (!SWIG_IsOK(ecode2)) {
   26247           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","nodes", 2, argv[0] ));
   26248             :   } 
   26249           0 :   arg2 = static_cast< int >(val2);
   26250           0 :   if (arg1) (arg1)->nodes = arg2;
   26251             :   return Qnil;
   26252             : fail:
   26253             :   return Qnil;
   26254             : }
   26255             : 
   26256             : 
   26257             : SWIGINTERN VALUE
   26258           0 : _wrap_SpecBackendBuilder_nodes_get(int argc, VALUE *argv, VALUE self) {
   26259           0 :   kdb::tools::SpecBackendBuilder *arg1 = (kdb::tools::SpecBackendBuilder *) 0 ;
   26260           0 :   void *argp1 = 0 ;
   26261           0 :   int res1 = 0 ;
   26262             :   int result;
   26263           0 :   VALUE vresult = Qnil;
   26264             :   
   26265           0 :   if ((argc < 0) || (argc > 0)) {
   26266           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   26267             :   }
   26268           0 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SpecBackendBuilder, 0 |  0 );
   26269           0 :   if (!SWIG_IsOK(res1)) {
   26270           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SpecBackendBuilder *","nodes", 1, self )); 
   26271             :   }
   26272           0 :   arg1 = reinterpret_cast< kdb::tools::SpecBackendBuilder * >(argp1);
   26273           0 :   result = (int) ((arg1)->nodes);
   26274           0 :   vresult = SWIG_From_int(static_cast< int >(result));
   26275             :   return vresult;
   26276             : fail:
   26277             :   return Qnil;
   26278             : }
   26279             : 
   26280             : 
   26281             : SWIGINTERN void
   26282           1 : free_kdb_tools_SpecBackendBuilder(void *self) {
   26283           1 :     kdb::tools::SpecBackendBuilder *arg1 = (kdb::tools::SpecBackendBuilder *)self;
   26284           1 :     delete arg1;
   26285           1 : }
   26286             : 
   26287             : 
   26288             : /*
   26289             :   Document-class: Kdbtools::SpecReader
   26290             : 
   26291             :   Proxy of C++ Kdbtools::SpecReader class
   26292             : 
   26293             : 
   26294             : */
   26295             : static swig_class SwigClassSpecReader;
   26296             : 
   26297             : 
   26298             : /*
   26299             :   Document-method: Kdbtools::SpecReader.new
   26300             : 
   26301             :   call-seq:
   26302             :     SpecReader.new(kdb::tools::BackendBuilderInit const & bbi=kdb::tools::BackendBuilderInit())
   26303             :     SpecReader.new
   26304             : 
   26305             : Class constructor.
   26306             : 
   26307             : */
   26308             : SWIGINTERN VALUE
   26309           0 : _wrap_new_SpecReader__SWIG_0(int argc, VALUE *argv, VALUE self) {
   26310           0 :   kdb::tools::BackendBuilderInit *arg1 = 0 ;
   26311             :   void *argp1 ;
   26312           0 :   int res1 = 0 ;
   26313           0 :   kdb::tools::SpecReader *result = 0 ;
   26314             :   
   26315           0 :   if ((argc < 1) || (argc > 1)) {
   26316           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   26317             :   }
   26318           0 :   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_kdb__tools__BackendBuilderInit,  0 );
   26319           0 :   if (!SWIG_IsOK(res1)) {
   26320           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::BackendBuilderInit const &","SpecReader", 1, argv[0] )); 
   26321             :   }
   26322           0 :   if (!argp1) {
   26323           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::tools::BackendBuilderInit const &","SpecReader", 1, argv[0])); 
   26324             :   }
   26325           0 :   arg1 = reinterpret_cast< kdb::tools::BackendBuilderInit * >(argp1);
   26326           0 :   result = (kdb::tools::SpecReader *)new kdb::tools::SpecReader((kdb::tools::BackendBuilderInit const &)*arg1);
   26327           0 :   DATA_PTR(self) = result;
   26328             :   return self;
   26329             : fail:
   26330             :   return Qnil;
   26331             : }
   26332             : 
   26333             : 
   26334             : SWIGINTERN VALUE
   26335             : #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
   26336           1 : _wrap_SpecReader_allocate(VALUE self)
   26337             : #else
   26338             : _wrap_SpecReader_allocate(int argc, VALUE *argv, VALUE self)
   26339             : #endif
   26340             : {
   26341           1 :   VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_kdb__tools__SpecReader);
   26342             : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
   26343             :   rb_obj_call_init(vresult, argc, argv);
   26344             : #endif
   26345           1 :   return vresult;
   26346             : }
   26347             : 
   26348             : 
   26349             : SWIGINTERN VALUE
   26350           1 : _wrap_new_SpecReader__SWIG_1(int argc, VALUE *argv, VALUE self) {
   26351           1 :   kdb::tools::SpecReader *result = 0 ;
   26352             :   
   26353           1 :   if ((argc < 0) || (argc > 0)) {
   26354           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   26355             :   }
   26356           1 :   result = (kdb::tools::SpecReader *)new kdb::tools::SpecReader();
   26357           1 :   DATA_PTR(self) = result;
   26358             :   return self;
   26359             : fail:
   26360             :   return Qnil;
   26361             : }
   26362             : 
   26363             : 
   26364           1 : SWIGINTERN VALUE _wrap_new_SpecReader(int nargs, VALUE *args, VALUE self) {
   26365             :   int argc;
   26366             :   VALUE argv[1];
   26367             :   int ii;
   26368             :   
   26369           1 :   argc = nargs;
   26370           1 :   if (argc > 1) SWIG_fail;
   26371             :   for (ii = 0; (ii < argc); ++ii) {
   26372             :     argv[ii] = args[ii];
   26373             :   }
   26374           1 :   if (argc == 0) {
   26375           1 :     return _wrap_new_SpecReader__SWIG_1(nargs, args, self);
   26376             :   }
   26377           0 :   if (argc == 1) {
   26378           0 :     return _wrap_new_SpecReader__SWIG_0(nargs, args, self);
   26379             :   }
   26380             :   
   26381             : fail:
   26382             :   Ruby_Format_OverloadedError( argc, 1, "SpecReader.new", 
   26383             :     "    SpecReader.new(kdb::tools::BackendBuilderInit const &bbi)\n"
   26384           0 :     "    SpecReader.new()\n");
   26385             :   
   26386             :   return Qnil;
   26387             : }
   26388             : 
   26389             : 
   26390             : SWIGINTERN void
   26391           1 : free_kdb_tools_SpecReader(void *self) {
   26392           1 :     kdb::tools::SpecReader *arg1 = (kdb::tools::SpecReader *)self;
   26393           1 :     delete arg1;
   26394           1 : }
   26395             : 
   26396             : 
   26397             : /*
   26398             :   Document-method: Kdbtools::SpecReader.get_backends
   26399             : 
   26400             :   call-seq:
   26401             :     get_backends -> kdb::tools::SpecReader::Backends
   26402             : 
   26403             : An instance method.
   26404             : 
   26405             : */
   26406             : SWIGINTERN VALUE
   26407           1 : _wrap_SpecReader_get_backends(int argc, VALUE *argv, VALUE self) {
   26408           1 :   kdb::tools::SpecReader *arg1 = (kdb::tools::SpecReader *) 0 ;
   26409           1 :   void *argp1 = 0 ;
   26410           1 :   int res1 = 0 ;
   26411             :   std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *tmp_backends ;
   26412           2 :   SwigValueWrapper< std::unordered_map< kdb::Key,kdb::tools::SpecBackendBuilder > > result;
   26413           1 :   VALUE vresult = Qnil;
   26414             :   
   26415           1 :   if ((argc < 0) || (argc > 0)) {
   26416           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   26417             :   }
   26418           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SpecReader, 0 |  0 );
   26419           1 :   if (!SWIG_IsOK(res1)) {
   26420           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SpecReader *","getBackends", 1, self )); 
   26421             :   }
   26422           1 :   arg1 = reinterpret_cast< kdb::tools::SpecReader * >(argp1);
   26423           2 :   result = (arg1)->getBackends();
   26424             :   {
   26425             :     // Backends-typemap
   26426           1 :     tmp_backends = new std::map<kdb::Key, kdb::tools::SpecBackendBuilder>(
   26427           4 :       (&result)->begin(), (&result)->end());
   26428           1 :     vresult = SWIG_NewPointerObj(tmp_backends,
   26429             :       SWIG_TypeQuery("std::map< kdb::Key, kdb::tools::SpecBackendBuilder > *"),
   26430             :       1)
   26431             :     
   26432           1 :     ;
   26433             :   }
   26434           1 :   return vresult;
   26435             : fail:
   26436             :   return Qnil;
   26437             : }
   26438             : 
   26439             : 
   26440             : 
   26441             : /*
   26442             :   Document-method: Kdbtools::SpecReader.read_specification
   26443             : 
   26444             :   call-seq:
   26445             :     read_specification(KeySet ks)
   26446             : 
   26447             : An instance method.
   26448             : 
   26449             : */
   26450             : SWIGINTERN VALUE
   26451           1 : _wrap_SpecReader_read_specification(int argc, VALUE *argv, VALUE self) {
   26452           1 :   kdb::tools::SpecReader *arg1 = (kdb::tools::SpecReader *) 0 ;
   26453           1 :   kdb::KeySet *arg2 = 0 ;
   26454           1 :   void *argp1 = 0 ;
   26455           1 :   int res1 = 0 ;
   26456             :   void *argp2 ;
   26457           1 :   int res2 = 0 ;
   26458             :   
   26459           1 :   if ((argc < 1) || (argc > 1)) {
   26460           0 :     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   26461             :   }
   26462           1 :   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_kdb__tools__SpecReader, 0 |  0 );
   26463           1 :   if (!SWIG_IsOK(res1)) {
   26464           0 :     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "kdb::tools::SpecReader *","readSpecification", 1, self )); 
   26465             :   }
   26466           1 :   arg1 = reinterpret_cast< kdb::tools::SpecReader * >(argp1);
   26467           1 :   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_kdb__KeySet,  0 );
   26468           1 :   if (!SWIG_IsOK(res2)) {
   26469           0 :     SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "kdb::KeySet const &","readSpecification", 2, argv[0] )); 
   26470             :   }
   26471           1 :   if (!argp2) {
   26472           0 :     SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "kdb::KeySet const &","readSpecification", 2, argv[0])); 
   26473             :   }
   26474           1 :   arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
   26475           1 :   (arg1)->readSpecification((kdb::KeySet const &)*arg2);
   26476             :   return Qnil;
   26477             : fail:
   26478             :   return Qnil;
   26479             : }
   26480             : 
   26481             : 
   26482             : 
   26483             : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
   26484             : 
   26485           0 : static void *_p_swig__IteratorTo_p_swig__ConstIterator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26486           0 :     return (void *)((swig::ConstIterator *)  ((swig::Iterator *) x));
   26487             : }
   26488           0 : static void *_p_kdb__tools__PluginVariantDatabaseTo_p_kdb__tools__ModulesPluginDatabase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26489           0 :     return (void *)((kdb::tools::ModulesPluginDatabase *)  ((kdb::tools::PluginVariantDatabase *) x));
   26490             : }
   26491           0 : static void *_p_kdb__tools__MockPluginDatabaseTo_p_kdb__tools__ModulesPluginDatabase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26492           0 :     return (void *)((kdb::tools::ModulesPluginDatabase *)  ((kdb::tools::MockPluginDatabase *) x));
   26493             : }
   26494           0 : static void *_p_kdb__tools__ModulesPluginDatabaseTo_p_kdb__tools__PluginDatabase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26495           0 :     return (void *)((kdb::tools::PluginDatabase *)  ((kdb::tools::ModulesPluginDatabase *) x));
   26496             : }
   26497           0 : static void *_p_kdb__tools__PluginVariantDatabaseTo_p_kdb__tools__PluginDatabase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26498           0 :     return (void *)((kdb::tools::PluginDatabase *) (kdb::tools::ModulesPluginDatabase *) ((kdb::tools::PluginVariantDatabase *) x));
   26499             : }
   26500           0 : static void *_p_kdb__tools__MockPluginDatabaseTo_p_kdb__tools__PluginDatabase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26501           0 :     return (void *)((kdb::tools::PluginDatabase *) (kdb::tools::ModulesPluginDatabase *) ((kdb::tools::MockPluginDatabase *) x));
   26502             : }
   26503           6 : static void *_p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_tTo_p_std__shared_ptrT_kdb__tools__PluginDatabase_t(void *x, int *newmemory) {
   26504           6 :     *newmemory = SWIG_CAST_NEW_MEMORY;
   26505          12 :     return (void *) new std::shared_ptr< kdb::tools::PluginDatabase >(*(std::shared_ptr< kdb::tools::ModulesPluginDatabase > *)x);
   26506             : }
   26507           0 : static void *_p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_tTo_p_std__shared_ptrT_kdb__tools__PluginDatabase_t(void *x, int *newmemory) {
   26508           0 :     *newmemory = SWIG_CAST_NEW_MEMORY;
   26509           0 :     return (void *) new std::shared_ptr< kdb::tools::PluginDatabase >(*(std::shared_ptr< kdb::tools::PluginVariantDatabase > *)x);
   26510             : }
   26511           0 : static void *_p_std__shared_ptrT_kdb__tools__MockPluginDatabase_tTo_p_std__shared_ptrT_kdb__tools__PluginDatabase_t(void *x, int *newmemory) {
   26512           0 :     *newmemory = SWIG_CAST_NEW_MEMORY;
   26513           0 :     return (void *) new std::shared_ptr< kdb::tools::PluginDatabase >(*(std::shared_ptr< kdb::tools::MockPluginDatabase > *)x);
   26514             : }
   26515           0 : static void *_p_kdb__tools__CyclicOrderingViolationTo_p_kdb__tools__OrderingViolation(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26516           0 :     return (void *)((kdb::tools::OrderingViolation *)  ((kdb::tools::CyclicOrderingViolation *) x));
   26517             : }
   26518           0 : static void *_p_kdb__tools__PluginConfigInvalidTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26519           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::PluginConfigInvalid *) x));
   26520             : }
   26521           0 : static void *_p_kdb__tools__PluginNoContractTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26522           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::PluginNoContract *) x));
   26523             : }
   26524           0 : static void *_p_kdb__tools__PluginNoInfoTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26525           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::PluginNoInfo *) x));
   26526             : }
   26527           0 : static void *_p_kdb__tools__ConflictViolationTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26528           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::ConflictViolation *) x));
   26529             : }
   26530           0 : static void *_p_kdb__tools__CyclicOrderingViolationTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26531           0 :     return (void *)((kdb::tools::PluginCheckException *) (kdb::tools::OrderingViolation *) ((kdb::tools::CyclicOrderingViolation *) x));
   26532             : }
   26533           0 : static void *_p_kdb__tools__OrderingViolationTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26534           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::OrderingViolation *) x));
   26535             : }
   26536           0 : static void *_p_kdb__tools__TooManyPluginsTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26537           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::TooManyPlugins *) x));
   26538             : }
   26539           0 : static void *_p_kdb__tools__MissingNeededTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26540           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::MissingNeeded *) x));
   26541             : }
   26542           0 : static void *_p_kdb__tools__ReferenceNotFoundTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26543           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::ReferenceNotFound *) x));
   26544             : }
   26545           0 : static void *_p_kdb__tools__SymbolDuplicateTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26546           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::SymbolDuplicate *) x));
   26547             : }
   26548           0 : static void *_p_kdb__tools__NoPluginTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26549           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::NoPlugin *) x));
   26550             : }
   26551           0 : static void *_p_kdb__tools__StoragePluginTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26552           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::StoragePlugin *) x));
   26553             : }
   26554           0 : static void *_p_kdb__tools__PluginAlreadyInsertedTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26555           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::PluginAlreadyInserted *) x));
   26556             : }
   26557           0 : static void *_p_kdb__tools__NoGlobalPluginTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26558           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::NoGlobalPlugin *) x));
   26559             : }
   26560           0 : static void *_p_kdb__tools__WrongStatusTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26561           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::WrongStatus *) x));
   26562             : }
   26563           0 : static void *_p_kdb__tools__BadPluginNameTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26564           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::BadPluginName *) x));
   26565             : }
   26566           0 : static void *_p_kdb__tools__ResolverPluginTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26567           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::ResolverPlugin *) x));
   26568             : }
   26569           0 : static void *_p_kdb__tools__SymbolMismatchTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26570           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::SymbolMismatch *) x));
   26571             : }
   26572           0 : static void *_p_kdb__tools__MissingSymbolTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26573           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::MissingSymbol *) x));
   26574             : }
   26575           0 : static void *_p_kdb__tools__VersionInfoMismatchTo_p_kdb__tools__PluginCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26576           0 :     return (void *)((kdb::tools::PluginCheckException *)  ((kdb::tools::VersionInfoMismatch *) x));
   26577             : }
   26578           0 : static void *_p_kdb__tools__FileNotValidExceptionTo_p_kdb__tools__BackendCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26579           0 :     return (void *)((kdb::tools::BackendCheckException *)  ((kdb::tools::FileNotValidException *) x));
   26580             : }
   26581           0 : static void *_p_kdb__tools__MountpointInvalidExceptionTo_p_kdb__tools__BackendCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26582           0 :     return (void *)((kdb::tools::BackendCheckException *)  ((kdb::tools::MountpointInvalidException *) x));
   26583             : }
   26584           0 : static void *_p_kdb__tools__MountpointAlreadyInUseExceptionTo_p_kdb__tools__BackendCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26585           0 :     return (void *)((kdb::tools::BackendCheckException *)  ((kdb::tools::MountpointAlreadyInUseException *) x));
   26586             : }
   26587           0 : static void *_p_kdb__tools__NoSuchBackendTo_p_kdb__tools__BackendCheckException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26588           0 :     return (void *)((kdb::tools::BackendCheckException *)  ((kdb::tools::NoSuchBackend *) x));
   26589             : }
   26590           0 : static void *_p_kdb__tools__PluginConfigInvalidTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26591           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::PluginConfigInvalid *) x));
   26592             : }
   26593           0 : static void *_p_kdb__tools__PluginNoContractTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26594           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::PluginNoContract *) x));
   26595             : }
   26596           0 : static void *_p_kdb__tools__PluginNoInfoTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26597           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::PluginNoInfo *) x));
   26598             : }
   26599           0 : static void *_p_kdb__tools__ConflictViolationTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26600           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::ConflictViolation *) x));
   26601             : }
   26602           0 : static void *_p_kdb__tools__CyclicOrderingViolationTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26603           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *)(kdb::tools::OrderingViolation *) ((kdb::tools::CyclicOrderingViolation *) x));
   26604             : }
   26605           0 : static void *_p_kdb__tools__OrderingViolationTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26606           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::OrderingViolation *) x));
   26607             : }
   26608           0 : static void *_p_kdb__tools__TooManyPluginsTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26609           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::TooManyPlugins *) x));
   26610             : }
   26611           0 : static void *_p_kdb__tools__NoSuchBackendTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26612           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::BackendCheckException *) ((kdb::tools::NoSuchBackend *) x));
   26613             : }
   26614           0 : static void *_p_kdb__tools__ReferenceNotFoundTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26615           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::ReferenceNotFound *) x));
   26616             : }
   26617           0 : static void *_p_kdb__tools__MissingNeededTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26618           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::MissingNeeded *) x));
   26619             : }
   26620           0 : static void *_p_kdb__tools__MountpointAlreadyInUseExceptionTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26621           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::BackendCheckException *) ((kdb::tools::MountpointAlreadyInUseException *) x));
   26622             : }
   26623           0 : static void *_p_kdb__tools__MountpointInvalidExceptionTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26624           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::BackendCheckException *) ((kdb::tools::MountpointInvalidException *) x));
   26625             : }
   26626           0 : static void *_p_kdb__tools__FileNotValidExceptionTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26627           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::BackendCheckException *) ((kdb::tools::FileNotValidException *) x));
   26628             : }
   26629           0 : static void *_p_kdb__tools__BackendCheckExceptionTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26630           0 :     return (void *)((kdb::tools::ToolException *)  ((kdb::tools::BackendCheckException *) x));
   26631             : }
   26632           0 : static void *_p_kdb__tools__PluginCheckExceptionTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26633           0 :     return (void *)((kdb::tools::ToolException *)  ((kdb::tools::PluginCheckException *) x));
   26634             : }
   26635           0 : static void *_p_kdb__tools__ParseExceptionTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26636           0 :     return (void *)((kdb::tools::ToolException *)  ((kdb::tools::ParseException *) x));
   26637             : }
   26638           0 : static void *_p_kdb__tools__SymbolDuplicateTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26639           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::SymbolDuplicate *) x));
   26640             : }
   26641           0 : static void *_p_kdb__tools__NoPluginTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26642           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::NoPlugin *) x));
   26643             : }
   26644           0 : static void *_p_kdb__tools__StoragePluginTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26645           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::StoragePlugin *) x));
   26646             : }
   26647           0 : static void *_p_kdb__tools__PluginAlreadyInsertedTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26648           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::PluginAlreadyInserted *) x));
   26649             : }
   26650           0 : static void *_p_kdb__tools__BadPluginNameTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26651           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::BadPluginName *) x));
   26652             : }
   26653           0 : static void *_p_kdb__tools__WrongStatusTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26654           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::WrongStatus *) x));
   26655             : }
   26656           0 : static void *_p_kdb__tools__NoGlobalPluginTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26657           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::NoGlobalPlugin *) x));
   26658             : }
   26659           0 : static void *_p_kdb__tools__ResolverPluginTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26660           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::ResolverPlugin *) x));
   26661             : }
   26662           0 : static void *_p_kdb__tools__MissingSymbolTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26663           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::MissingSymbol *) x));
   26664             : }
   26665           0 : static void *_p_kdb__tools__SymbolMismatchTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26666           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::SymbolMismatch *) x));
   26667             : }
   26668           0 : static void *_p_kdb__tools__VersionInfoMismatchTo_p_kdb__tools__ToolException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26669           0 :     return (void *)((kdb::tools::ToolException *) (kdb::tools::PluginCheckException *) ((kdb::tools::VersionInfoMismatch *) x));
   26670             : }
   26671           0 : static void *_p_kdb__tools__PluginConfigInvalidTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26672           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::PluginConfigInvalid *) x));
   26673             : }
   26674           0 : static void *_p_kdb__tools__PluginNoContractTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26675           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::PluginNoContract *) x));
   26676             : }
   26677           0 : static void *_p_kdb__tools__PluginNoInfoTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26678           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::PluginNoInfo *) x));
   26679             : }
   26680           0 : static void *_p_kdb__tools__CyclicOrderingViolationTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26681           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *)(kdb::tools::OrderingViolation *) ((kdb::tools::CyclicOrderingViolation *) x));
   26682             : }
   26683           0 : static void *_p_kdb__tools__OrderingViolationTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26684           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::OrderingViolation *) x));
   26685             : }
   26686           0 : static void *_p_kdb__tools__ConflictViolationTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26687           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::ConflictViolation *) x));
   26688             : }
   26689           0 : static void *_p_kdb__tools__TooManyPluginsTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26690           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::TooManyPlugins *) x));
   26691             : }
   26692           0 : static void *_p_kdb__tools__NoSuchBackendTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26693           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::BackendCheckException *) ((kdb::tools::NoSuchBackend *) x));
   26694             : }
   26695           0 : static void *_p_kdb__tools__ReferenceNotFoundTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26696           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::ReferenceNotFound *) x));
   26697             : }
   26698           0 : static void *_p_kdb__tools__MissingNeededTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26699           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::MissingNeeded *) x));
   26700             : }
   26701           0 : static void *_p_kdb__tools__MountpointAlreadyInUseExceptionTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26702           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::BackendCheckException *) ((kdb::tools::MountpointAlreadyInUseException *) x));
   26703             : }
   26704           0 : static void *_p_kdb__tools__MountpointInvalidExceptionTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26705           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::BackendCheckException *) ((kdb::tools::MountpointInvalidException *) x));
   26706             : }
   26707           0 : static void *_p_kdb__tools__FileNotValidExceptionTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26708           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::BackendCheckException *) ((kdb::tools::FileNotValidException *) x));
   26709             : }
   26710           0 : static void *_p_kdb__tools__BackendCheckExceptionTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26711           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *) ((kdb::tools::BackendCheckException *) x));
   26712             : }
   26713           0 : static void *_p_kdb__tools__PluginCheckExceptionTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26714           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *) ((kdb::tools::PluginCheckException *) x));
   26715             : }
   26716           0 : static void *_p_kdb__tools__ParseExceptionTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26717           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *) ((kdb::tools::ParseException *) x));
   26718             : }
   26719           0 : static void *_p_kdb__tools__ToolExceptionTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26720           0 :     return (void *)((std::runtime_error *)  ((kdb::tools::ToolException *) x));
   26721             : }
   26722           0 : static void *_p_kdb__tools__SymbolDuplicateTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26723           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::SymbolDuplicate *) x));
   26724             : }
   26725           0 : static void *_p_kdb__tools__NoPluginTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26726           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::NoPlugin *) x));
   26727             : }
   26728           0 : static void *_p_kdb__tools__StoragePluginTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26729           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::StoragePlugin *) x));
   26730             : }
   26731           0 : static void *_p_kdb__tools__PluginAlreadyInsertedTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26732           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::PluginAlreadyInserted *) x));
   26733             : }
   26734           0 : static void *_p_kdb__tools__BadPluginNameTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26735           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::BadPluginName *) x));
   26736             : }
   26737           0 : static void *_p_kdb__tools__WrongStatusTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26738           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::WrongStatus *) x));
   26739             : }
   26740           0 : static void *_p_kdb__tools__NoGlobalPluginTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26741           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::NoGlobalPlugin *) x));
   26742             : }
   26743           0 : static void *_p_kdb__tools__ResolverPluginTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26744           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::ResolverPlugin *) x));
   26745             : }
   26746           0 : static void *_p_kdb__tools__MissingSymbolTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26747           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::MissingSymbol *) x));
   26748             : }
   26749           0 : static void *_p_kdb__tools__SymbolMismatchTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26750           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::SymbolMismatch *) x));
   26751             : }
   26752           0 : static void *_p_kdb__tools__VersionInfoMismatchTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26753           0 :     return (void *)((std::runtime_error *) (kdb::tools::ToolException *)(kdb::tools::PluginCheckException *) ((kdb::tools::VersionInfoMismatch *) x));
   26754             : }
   26755           0 : static void *_p_kdb__tools__ImportExportBackendTo_p_kdb__tools__PluginAdder(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26756           0 :     return (void *)((kdb::tools::PluginAdder *)  ((kdb::tools::ImportExportBackend *) x));
   26757             : }
   26758           0 : static void *_p_kdb__tools__GlobalPluginsTo_p_kdb__tools__PluginAdder(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26759           0 :     return (void *)((kdb::tools::PluginAdder *)  ((kdb::tools::GlobalPlugins *) x));
   26760             : }
   26761           0 : static void *_p_kdb__tools__GlobalPluginsBuilderTo_p_kdb__tools__BackendBuilder(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26762           0 :     return (void *)((kdb::tools::BackendBuilder *)  ((kdb::tools::GlobalPluginsBuilder *) x));
   26763             : }
   26764           0 : static void *_p_kdb__tools__MountBackendBuilderTo_p_kdb__tools__BackendBuilder(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26765           0 :     return (void *)((kdb::tools::BackendBuilder *)  ((kdb::tools::MountBackendBuilder *) x));
   26766             : }
   26767           0 : static void *_p_kdb__tools__SpecBackendBuilderTo_p_kdb__tools__BackendBuilder(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26768           0 :     return (void *)((kdb::tools::BackendBuilder *) (kdb::tools::MountBackendBuilder *) ((kdb::tools::SpecBackendBuilder *) x));
   26769             : }
   26770           0 : static void *_p_kdb__tools__SpecBackendBuilderTo_p_kdb__tools__MountBackendBuilder(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26771           0 :     return (void *)((kdb::tools::MountBackendBuilder *)  ((kdb::tools::SpecBackendBuilder *) x));
   26772             : }
   26773           0 : static void *_p_kdb__tools__GetPluginsTo_p_kdb__tools__Plugins(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26774           0 :     return (void *)((kdb::tools::Plugins *)  ((kdb::tools::GetPlugins *) x));
   26775             : }
   26776           0 : static void *_p_kdb__tools__SetPluginsTo_p_kdb__tools__Plugins(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26777           0 :     return (void *)((kdb::tools::Plugins *)  ((kdb::tools::SetPlugins *) x));
   26778             : }
   26779           0 : static void *_p_kdb__tools__ErrorPluginsTo_p_kdb__tools__Plugins(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26780           0 :     return (void *)((kdb::tools::Plugins *)  ((kdb::tools::ErrorPlugins *) x));
   26781             : }
   26782           0 : static void *_p_kdb__tools__MountBackendBuilderTo_p_kdb__tools__MountBackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26783           0 :     return (void *)((kdb::tools::MountBackendInterface *)  ((kdb::tools::MountBackendBuilder *) x));
   26784             : }
   26785           0 : static void *_p_kdb__tools__SpecBackendBuilderTo_p_kdb__tools__MountBackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26786           0 :     return (void *)((kdb::tools::MountBackendInterface *) (kdb::tools::MountBackendBuilder *) ((kdb::tools::SpecBackendBuilder *) x));
   26787             : }
   26788           0 : static void *_p_kdb__tools__BackendTo_p_kdb__tools__MountBackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26789           0 :     return (void *)((kdb::tools::MountBackendInterface *)  ((kdb::tools::Backend *) x));
   26790             : }
   26791           0 : static void *_p_kdb__tools__MountBackendInterfaceTo_p_kdb__tools__SerializeInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26792           0 :     return (void *)((kdb::tools::SerializeInterface *)  ((kdb::tools::MountBackendInterface *) x));
   26793             : }
   26794           0 : static void *_p_kdb__tools__MountBackendBuilderTo_p_kdb__tools__SerializeInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26795           0 :     return (void *)((kdb::tools::SerializeInterface *) (kdb::tools::MountBackendInterface *) ((kdb::tools::MountBackendBuilder *) x));
   26796             : }
   26797           0 : static void *_p_kdb__tools__SpecBackendBuilderTo_p_kdb__tools__SerializeInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26798           0 :     return (void *)((kdb::tools::SerializeInterface *) (kdb::tools::MountBackendInterface *)(kdb::tools::MountBackendBuilder *) ((kdb::tools::SpecBackendBuilder *) x));
   26799             : }
   26800           0 : static void *_p_kdb__tools__BackendTo_p_kdb__tools__SerializeInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26801           0 :     return (void *)((kdb::tools::SerializeInterface *) (kdb::tools::MountBackendInterface *) ((kdb::tools::Backend *) x));
   26802             : }
   26803           0 : static void *_p_kdb__tools__GlobalPluginsTo_p_kdb__tools__SerializeInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26804           0 :     return (void *)((kdb::tools::SerializeInterface *)  ((kdb::tools::GlobalPlugins *) x));
   26805             : }
   26806           0 : static void *_p_kdb__tools__MountBackendInterfaceTo_p_kdb__tools__BackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26807           0 :     return (void *)((kdb::tools::BackendInterface *)  ((kdb::tools::MountBackendInterface *) x));
   26808             : }
   26809           0 : static void *_p_kdb__tools__PluginAdderTo_p_kdb__tools__BackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26810           0 :     return (void *)((kdb::tools::BackendInterface *)  ((kdb::tools::PluginAdder *) x));
   26811             : }
   26812           0 : static void *_p_kdb__tools__BackendBuilderTo_p_kdb__tools__BackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26813           0 :     return (void *)((kdb::tools::BackendInterface *)  ((kdb::tools::BackendBuilder *) x));
   26814             : }
   26815           0 : static void *_p_kdb__tools__GlobalPluginsBuilderTo_p_kdb__tools__BackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26816           0 :     return (void *)((kdb::tools::BackendInterface *) (kdb::tools::BackendBuilder *) ((kdb::tools::GlobalPluginsBuilder *) x));
   26817             : }
   26818           0 : static void *_p_kdb__tools__MountBackendBuilderTo_p_kdb__tools__BackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26819           0 :     return (void *)((kdb::tools::BackendInterface *) (kdb::tools::MountBackendInterface *) ((kdb::tools::MountBackendBuilder *) x));
   26820             : }
   26821           0 : static void *_p_kdb__tools__SpecBackendBuilderTo_p_kdb__tools__BackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26822           0 :     return (void *)((kdb::tools::BackendInterface *) (kdb::tools::MountBackendInterface *)(kdb::tools::MountBackendBuilder *) ((kdb::tools::SpecBackendBuilder *) x));
   26823             : }
   26824           0 : static void *_p_kdb__tools__BackendTo_p_kdb__tools__BackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26825           0 :     return (void *)((kdb::tools::BackendInterface *) (kdb::tools::MountBackendInterface *) ((kdb::tools::Backend *) x));
   26826             : }
   26827           0 : static void *_p_kdb__tools__ImportExportBackendTo_p_kdb__tools__BackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26828           0 :     return (void *)((kdb::tools::BackendInterface *) (kdb::tools::PluginAdder *) ((kdb::tools::ImportExportBackend *) x));
   26829             : }
   26830           0 : static void *_p_kdb__tools__GlobalPluginsTo_p_kdb__tools__BackendInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
   26831           0 :     return (void *)((kdb::tools::BackendInterface *) (kdb::tools::PluginAdder *) ((kdb::tools::GlobalPlugins *) x));
   26832             : }
   26833           0 : static void *_p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_tTo_p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t(void *x, int *newmemory) {
   26834           0 :     *newmemory = SWIG_CAST_NEW_MEMORY;
   26835           0 :     return (void *) new std::shared_ptr< kdb::tools::ModulesPluginDatabase >(*(std::shared_ptr< kdb::tools::PluginVariantDatabase > *)x);
   26836             : }
   26837           0 : static void *_p_std__shared_ptrT_kdb__tools__MockPluginDatabase_tTo_p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t(void *x, int *newmemory) {
   26838           0 :     *newmemory = SWIG_CAST_NEW_MEMORY;
   26839           0 :     return (void *) new std::shared_ptr< kdb::tools::ModulesPluginDatabase >(*(std::shared_ptr< kdb::tools::MockPluginDatabase > *)x);
   26840             : }
   26841             : static swig_type_info _swigt__p_BackendInfoVector = {"_p_BackendInfoVector", "BackendInfoVector *", 0, 0, (void*)0, 0};
   26842             : static swig_type_info _swigt__p_Backends = {"_p_Backends", "Backends *", 0, 0, (void*)0, 0};
   26843             : static swig_type_info _swigt__p__Plugin = {"_p__Plugin", "_Plugin *|ckdb::Plugin *", 0, 0, (void*)0, 0};
   26844             : static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
   26845             : static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
   26846             : static swig_type_info _swigt__p_const_iterator = {"_p_const_iterator", "const_iterator *", 0, 0, (void*)0, 0};
   26847             : static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
   26848             : static swig_type_info _swigt__p_f_p__Key_p__KeySet__int = {"_p_f_p__Key_p__KeySet__int", "kdb::tools::MockPluginDatabase::checkConfPtr|int (*)(_Key *,_KeySet *)", 0, 0, (void*)0, 0};
   26849             : 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};
   26850             : static swig_type_info _swigt__p_kdb__Key = {"_p_kdb__Key", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::key_type *|kdb::Key *", 0, 0, (void*)0, 0};
   26851             : static swig_type_info _swigt__p_kdb__KeySet = {"_p_kdb__KeySet", "kdb::KeySet *", 0, 0, (void*)0, 0};
   26852             : static swig_type_info _swigt__p_kdb__tools__Backend = {"_p_kdb__tools__Backend", "kdb::tools::Backend *", 0, 0, (void*)0, 0};
   26853             : static swig_type_info _swigt__p_kdb__tools__BackendBuilder = {"_p_kdb__tools__BackendBuilder", "kdb::tools::BackendBuilder *", 0, 0, (void*)0, 0};
   26854             : static swig_type_info _swigt__p_kdb__tools__BackendBuilderInit = {"_p_kdb__tools__BackendBuilderInit", "kdb::tools::BackendBuilderInit *", 0, 0, (void*)0, 0};
   26855             : static swig_type_info _swigt__p_kdb__tools__BackendCheckException = {"_p_kdb__tools__BackendCheckException", "kdb::tools::BackendCheckException *", 0, 0, (void*)0, 0};
   26856             : static swig_type_info _swigt__p_kdb__tools__BackendFactory = {"_p_kdb__tools__BackendFactory", "kdb::tools::BackendFactory *", 0, 0, (void*)0, 0};
   26857             : static swig_type_info _swigt__p_kdb__tools__BackendInfo = {"_p_kdb__tools__BackendInfo", "kdb::tools::BackendInfo *|std::vector< kdb::tools::BackendInfo >::value_type *", 0, 0, (void*)0, 0};
   26858             : static swig_type_info _swigt__p_kdb__tools__BackendInterface = {"_p_kdb__tools__BackendInterface", "kdb::tools::BackendInterface *", 0, 0, (void*)0, 0};
   26859             : static swig_type_info _swigt__p_kdb__tools__Backends = {"_p_kdb__tools__Backends", "kdb::tools::Backends *", 0, 0, (void*)0, 0};
   26860             : static swig_type_info _swigt__p_kdb__tools__BadPluginName = {"_p_kdb__tools__BadPluginName", "kdb::tools::BadPluginName *", 0, 0, (void*)0, 0};
   26861             : static swig_type_info _swigt__p_kdb__tools__ConflictViolation = {"_p_kdb__tools__ConflictViolation", "kdb::tools::ConflictViolation *", 0, 0, (void*)0, 0};
   26862             : static swig_type_info _swigt__p_kdb__tools__CyclicOrderingViolation = {"_p_kdb__tools__CyclicOrderingViolation", "kdb::tools::CyclicOrderingViolation *", 0, 0, (void*)0, 0};
   26863             : static swig_type_info _swigt__p_kdb__tools__ErrorPlugins = {"_p_kdb__tools__ErrorPlugins", "kdb::tools::ErrorPlugins *", 0, 0, (void*)0, 0};
   26864             : static swig_type_info _swigt__p_kdb__tools__FileNotValidException = {"_p_kdb__tools__FileNotValidException", "kdb::tools::FileNotValidException *", 0, 0, (void*)0, 0};
   26865             : static swig_type_info _swigt__p_kdb__tools__GetPlugins = {"_p_kdb__tools__GetPlugins", "kdb::tools::GetPlugins *", 0, 0, (void*)0, 0};
   26866             : static swig_type_info _swigt__p_kdb__tools__GlobalPlugins = {"_p_kdb__tools__GlobalPlugins", "kdb::tools::GlobalPlugins *", 0, 0, (void*)0, 0};
   26867             : static swig_type_info _swigt__p_kdb__tools__GlobalPluginsBuilder = {"_p_kdb__tools__GlobalPluginsBuilder", "kdb::tools::GlobalPluginsBuilder *", 0, 0, (void*)0, 0};
   26868             : static swig_type_info _swigt__p_kdb__tools__ImportExportBackend = {"_p_kdb__tools__ImportExportBackend", "kdb::tools::ImportExportBackend *", 0, 0, (void*)0, 0};
   26869             : static swig_type_info _swigt__p_kdb__tools__MissingNeeded = {"_p_kdb__tools__MissingNeeded", "kdb::tools::MissingNeeded *", 0, 0, (void*)0, 0};
   26870             : static swig_type_info _swigt__p_kdb__tools__MissingSymbol = {"_p_kdb__tools__MissingSymbol", "kdb::tools::MissingSymbol *", 0, 0, (void*)0, 0};
   26871             : static swig_type_info _swigt__p_kdb__tools__MockPluginDatabase = {"_p_kdb__tools__MockPluginDatabase", "kdb::tools::MockPluginDatabase *", 0, 0, (void*)0, 0};
   26872             : static swig_type_info _swigt__p_kdb__tools__Modules = {"_p_kdb__tools__Modules", "kdb::tools::Modules *", 0, 0, (void*)0, 0};
   26873             : static swig_type_info _swigt__p_kdb__tools__ModulesPluginDatabase = {"_p_kdb__tools__ModulesPluginDatabase", "kdb::tools::ModulesPluginDatabase *", 0, 0, (void*)0, 0};
   26874             : static swig_type_info _swigt__p_kdb__tools__MountBackendBuilder = {"_p_kdb__tools__MountBackendBuilder", "kdb::tools::MountBackendBuilder *", 0, 0, (void*)0, 0};
   26875             : static swig_type_info _swigt__p_kdb__tools__MountBackendInterface = {"_p_kdb__tools__MountBackendInterface", "kdb::tools::MountBackendInterface *", 0, 0, (void*)0, 0};
   26876             : static swig_type_info _swigt__p_kdb__tools__MountpointAlreadyInUseException = {"_p_kdb__tools__MountpointAlreadyInUseException", "kdb::tools::MountpointAlreadyInUseException *", 0, 0, (void*)0, 0};
   26877             : static swig_type_info _swigt__p_kdb__tools__MountpointInvalidException = {"_p_kdb__tools__MountpointInvalidException", "kdb::tools::MountpointInvalidException *", 0, 0, (void*)0, 0};
   26878             : static swig_type_info _swigt__p_kdb__tools__NoGlobalPlugin = {"_p_kdb__tools__NoGlobalPlugin", "kdb::tools::NoGlobalPlugin *", 0, 0, (void*)0, 0};
   26879             : static swig_type_info _swigt__p_kdb__tools__NoPlugin = {"_p_kdb__tools__NoPlugin", "kdb::tools::NoPlugin *", 0, 0, (void*)0, 0};
   26880             : static swig_type_info _swigt__p_kdb__tools__NoSuchBackend = {"_p_kdb__tools__NoSuchBackend", "kdb::tools::NoSuchBackend *", 0, 0, (void*)0, 0};
   26881             : static swig_type_info _swigt__p_kdb__tools__OrderingViolation = {"_p_kdb__tools__OrderingViolation", "kdb::tools::OrderingViolation *", 0, 0, (void*)0, 0};
   26882             : static swig_type_info _swigt__p_kdb__tools__ParseException = {"_p_kdb__tools__ParseException", "kdb::tools::ParseException *", 0, 0, (void*)0, 0};
   26883             : static swig_type_info _swigt__p_kdb__tools__Place = {"_p_kdb__tools__Place", "kdb::tools::Place *", 0, 0, (void*)0, 0};
   26884             : static swig_type_info _swigt__p_kdb__tools__Plugin = {"_p_kdb__tools__Plugin", "kdb::tools::Plugin *", 0, 0, (void*)0, 0};
   26885             : static swig_type_info _swigt__p_kdb__tools__PluginAdder = {"_p_kdb__tools__PluginAdder", "kdb::tools::PluginAdder *", 0, 0, (void*)0, 0};
   26886             : static swig_type_info _swigt__p_kdb__tools__PluginAlreadyInserted = {"_p_kdb__tools__PluginAlreadyInserted", "kdb::tools::PluginAlreadyInserted *", 0, 0, (void*)0, 0};
   26887             : static swig_type_info _swigt__p_kdb__tools__PluginCheckException = {"_p_kdb__tools__PluginCheckException", "kdb::tools::PluginCheckException *", 0, 0, (void*)0, 0};
   26888             : static swig_type_info _swigt__p_kdb__tools__PluginConfigInvalid = {"_p_kdb__tools__PluginConfigInvalid", "kdb::tools::PluginConfigInvalid *", 0, 0, (void*)0, 0};
   26889             : static swig_type_info _swigt__p_kdb__tools__PluginDatabase = {"_p_kdb__tools__PluginDatabase", "kdb::tools::PluginDatabase *", 0, 0, (void*)0, 0};
   26890             : static swig_type_info _swigt__p_kdb__tools__PluginNoContract = {"_p_kdb__tools__PluginNoContract", "kdb::tools::PluginNoContract *", 0, 0, (void*)0, 0};
   26891             : static swig_type_info _swigt__p_kdb__tools__PluginNoInfo = {"_p_kdb__tools__PluginNoInfo", "kdb::tools::PluginNoInfo *", 0, 0, (void*)0, 0};
   26892             : static swig_type_info _swigt__p_kdb__tools__PluginSpec = {"_p_kdb__tools__PluginSpec", "kdb::tools::PluginSpec *|std::vector< kdb::tools::PluginSpec >::value_type *|std::map< int,kdb::tools::PluginSpec >::mapped_type *", 0, 0, (void*)0, 0};
   26893             : static swig_type_info _swigt__p_kdb__tools__PluginSpecFullName = {"_p_kdb__tools__PluginSpecFullName", "kdb::tools::PluginSpecFullName *", 0, 0, (void*)0, 0};
   26894             : static swig_type_info _swigt__p_kdb__tools__PluginSpecHash = {"_p_kdb__tools__PluginSpecHash", "kdb::tools::PluginSpecHash *", 0, 0, (void*)0, 0};
   26895             : static swig_type_info _swigt__p_kdb__tools__PluginSpecName = {"_p_kdb__tools__PluginSpecName", "kdb::tools::PluginSpecName *", 0, 0, (void*)0, 0};
   26896             : static swig_type_info _swigt__p_kdb__tools__PluginSpecRefName = {"_p_kdb__tools__PluginSpecRefName", "kdb::tools::PluginSpecRefName *", 0, 0, (void*)0, 0};
   26897             : static swig_type_info _swigt__p_kdb__tools__PluginVariantDatabase = {"_p_kdb__tools__PluginVariantDatabase", "kdb::tools::PluginVariantDatabase *", 0, 0, (void*)0, 0};
   26898             : static swig_type_info _swigt__p_kdb__tools__Plugins = {"_p_kdb__tools__Plugins", "kdb::tools::Plugins *", 0, 0, (void*)0, 0};
   26899             : static swig_type_info _swigt__p_kdb__tools__ReferenceNotFound = {"_p_kdb__tools__ReferenceNotFound", "kdb::tools::ReferenceNotFound *", 0, 0, (void*)0, 0};
   26900             : static swig_type_info _swigt__p_kdb__tools__ResolverPlugin = {"_p_kdb__tools__ResolverPlugin", "kdb::tools::ResolverPlugin *", 0, 0, (void*)0, 0};
   26901             : static swig_type_info _swigt__p_kdb__tools__SerializeInterface = {"_p_kdb__tools__SerializeInterface", "kdb::tools::SerializeInterface *", 0, 0, (void*)0, 0};
   26902             : static swig_type_info _swigt__p_kdb__tools__SetPlugins = {"_p_kdb__tools__SetPlugins", "kdb::tools::SetPlugins *", 0, 0, (void*)0, 0};
   26903             : static swig_type_info _swigt__p_kdb__tools__SpecBackendBuilder = {"_p_kdb__tools__SpecBackendBuilder", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::mapped_type *|kdb::tools::SpecBackendBuilder *", 0, 0, (void*)0, 0};
   26904             : static swig_type_info _swigt__p_kdb__tools__SpecReader = {"_p_kdb__tools__SpecReader", "kdb::tools::SpecReader *", 0, 0, (void*)0, 0};
   26905             : static swig_type_info _swigt__p_kdb__tools__StoragePlugin = {"_p_kdb__tools__StoragePlugin", "kdb::tools::StoragePlugin *", 0, 0, (void*)0, 0};
   26906             : static swig_type_info _swigt__p_kdb__tools__SymbolDuplicate = {"_p_kdb__tools__SymbolDuplicate", "kdb::tools::SymbolDuplicate *", 0, 0, (void*)0, 0};
   26907             : static swig_type_info _swigt__p_kdb__tools__SymbolMismatch = {"_p_kdb__tools__SymbolMismatch", "kdb::tools::SymbolMismatch *", 0, 0, (void*)0, 0};
   26908             : static swig_type_info _swigt__p_kdb__tools__TooManyPlugins = {"_p_kdb__tools__TooManyPlugins", "kdb::tools::TooManyPlugins *", 0, 0, (void*)0, 0};
   26909             : static swig_type_info _swigt__p_kdb__tools__ToolException = {"_p_kdb__tools__ToolException", "kdb::tools::ToolException *", 0, 0, (void*)0, 0};
   26910             : static swig_type_info _swigt__p_kdb__tools__VersionInfoMismatch = {"_p_kdb__tools__VersionInfoMismatch", "kdb::tools::VersionInfoMismatch *", 0, 0, (void*)0, 0};
   26911             : static swig_type_info _swigt__p_kdb__tools__WrongStatus = {"_p_kdb__tools__WrongStatus", "kdb::tools::WrongStatus *", 0, 0, (void*)0, 0};
   26912             : static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
   26913             : 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};
   26914             : static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
   26915             : static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **|VALUE *", 0, 0, (void*)0, 0};
   26916             : static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
   26917             : 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};
   26918             : static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
   26919             : static swig_type_info _swigt__p_std__allocatorT_kdb__tools__BackendInfo_t = {"_p_std__allocatorT_kdb__tools__BackendInfo_t", "std::vector< kdb::tools::BackendInfo >::allocator_type *|std::allocator< kdb::tools::BackendInfo > *", 0, 0, (void*)0, 0};
   26920             : static swig_type_info _swigt__p_std__allocatorT_kdb__tools__PluginSpec_t = {"_p_std__allocatorT_kdb__tools__PluginSpec_t", "std::allocator< kdb::tools::PluginSpec > *|std::vector< kdb::tools::PluginSpec >::allocator_type *", 0, 0, (void*)0, 0};
   26921             : static swig_type_info _swigt__p_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t = {"_p_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t", "std::map< int,kdb::tools::PluginSpec >::allocator_type *|std::allocator< std::pair< int const,kdb::tools::PluginSpec > > *", 0, 0, (void*)0, 0};
   26922             : static swig_type_info _swigt__p_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t = {"_p_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder >::allocator_type *|std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > *", 0, 0, (void*)0, 0};
   26923             : static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__allocatorT_std__string_t", "std::vector< std::string >::allocator_type *|std::allocator< std::string > *", 0, 0, (void*)0, 0};
   26924             : static swig_type_info _swigt__p_std__lessT_int_t = {"_p_std__lessT_int_t", "std::less< int > *", 0, 0, (void*)0, 0};
   26925             : static swig_type_info _swigt__p_std__lessT_kdb__Key_t = {"_p_std__lessT_kdb__Key_t", "std::less< kdb::Key > *", 0, 0, (void*)0, 0};
   26926             : static swig_type_info _swigt__p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t = {"_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t", "std::map< int,kdb::tools::PluginSpec,std::less< int >,std::allocator< std::pair< int const,kdb::tools::PluginSpec > > > *|std::map< int,kdb::tools::PluginSpec > *", 0, 0, (void*)0, 0};
   26927             : static swig_type_info _swigt__p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t = {"_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t", "std::map< kdb::Key,kdb::tools::SpecBackendBuilder > *|std::map< kdb::Key,kdb::tools::SpecBackendBuilder,std::less< kdb::Key >,std::allocator< std::pair< kdb::Key const,kdb::tools::SpecBackendBuilder > > > *", 0, 0, (void*)0, 0};
   26928             : static swig_type_info _swigt__p_std__mapT_std__string_int_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_int_t_t_t = {"_p_std__mapT_std__string_int_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_int_t_t_t", "std::map< std::string,int,std::less< std::string >,std::allocator< std::pair< std::string const,int > > > *", 0, 0, (void*)0, 0};
   26929             : static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
   26930             : static swig_type_info _swigt__p_std__runtime_error = {"_p_std__runtime_error", "std::runtime_error *", 0, 0, (void*)0, 0};
   26931             : static swig_type_info _swigt__p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t = {"_p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t", "std::shared_ptr< kdb::tools::MockPluginDatabase > *", 0, 0, (void*)0, 0};
   26932             : static swig_type_info _swigt__p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t = {"_p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t", "std::shared_ptr< kdb::tools::ModulesPluginDatabase > *", 0, 0, (void*)0, 0};
   26933             : static swig_type_info _swigt__p_std__shared_ptrT_kdb__tools__PluginDatabase_t = {"_p_std__shared_ptrT_kdb__tools__PluginDatabase_t", "kdb::tools::PluginDatabasePtr *|std::shared_ptr< kdb::tools::PluginDatabase > *", 0, 0, (void*)0, 0};
   26934             : static swig_type_info _swigt__p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t = {"_p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t", "std::shared_ptr< kdb::tools::PluginVariantDatabase > *", 0, 0, (void*)0, 0};
   26935             : static swig_type_info _swigt__p_std__unique_ptrT_kdb__tools__BackendInterface_t = {"_p_std__unique_ptrT_kdb__tools__BackendInterface_t", "std::unique_ptr< kdb::tools::BackendInterface > *|kdb::tools::BackendInterfacePtr *", 0, 0, (void*)0, 0};
   26936             : static swig_type_info _swigt__p_std__unique_ptrT_kdb__tools__MountBackendInterface_t = {"_p_std__unique_ptrT_kdb__tools__MountBackendInterface_t", "std::unique_ptr< kdb::tools::MountBackendInterface > *|kdb::tools::MountBackendInterfacePtr *", 0, 0, (void*)0, 0};
   26937             : static swig_type_info _swigt__p_std__unique_ptrT_kdb__tools__Plugin_t = {"_p_std__unique_ptrT_kdb__tools__Plugin_t", "std::unique_ptr< kdb::tools::Plugin > *|kdb::tools::PluginPtr *", 0, 0, (void*)0, 0};
   26938             : static swig_type_info _swigt__p_std__unordered_mapT_kdb__tools__PluginSpec_std__unordered_mapT_std__string_std__string_t_kdb__tools__PluginSpecHash_kdb__tools__PluginSpecName_t = {"_p_std__unordered_mapT_kdb__tools__PluginSpec_std__unordered_mapT_std__string_std__string_t_kdb__tools__PluginSpecHash_kdb__tools__PluginSpecName_t", "std::unordered_map< kdb::tools::PluginSpec,std::unordered_map< std::string,std::string >,kdb::tools::PluginSpecHash,kdb::tools::PluginSpecName > *", 0, 0, (void*)0, 0};
   26939             : static swig_type_info _swigt__p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t = {"_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t", "std::vector< kdb::tools::BackendInfo,std::allocator< kdb::tools::BackendInfo > > *|std::vector< kdb::tools::BackendInfo > *", 0, 0, (void*)0, 0};
   26940             : static swig_type_info _swigt__p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t = {"_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t", "std::vector< kdb::tools::PluginSpec,std::allocator< kdb::tools::PluginSpec > > *|std::vector< kdb::tools::PluginSpec > *|kdb::tools::PluginSpecVector *", 0, 0, (void*)0, 0};
   26941             : static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *|std::vector< std::string > *", 0, 0, (void*)0, 0};
   26942             : static swig_type_info _swigt__p_swig__ConstIterator = {"_p_swig__ConstIterator", "swig::ConstIterator *", 0, 0, (void*)0, 0};
   26943             : static swig_type_info _swigt__p_swig__GC_VALUE = {"_p_swig__GC_VALUE", "swig::GC_VALUE *", 0, 0, (void*)0, 0};
   26944             : static swig_type_info _swigt__p_swig__Iterator = {"_p_swig__Iterator", "swig::Iterator *", 0, 0, (void*)0, 0};
   26945             : 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};
   26946             : 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};
   26947             : 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};
   26948             : static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
   26949             : static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
   26950             : static swig_type_info _swigt__p_void = {"_p_void", "VALUE|void *", 0, 0, (void*)0, 0};
   26951             : 
   26952             : static swig_type_info *swig_type_initial[] = {
   26953             :   &_swigt__p_BackendInfoVector,
   26954             :   &_swigt__p_Backends,
   26955             :   &_swigt__p__Plugin,
   26956             :   &_swigt__p_allocator_type,
   26957             :   &_swigt__p_char,
   26958             :   &_swigt__p_const_iterator,
   26959             :   &_swigt__p_difference_type,
   26960             :   &_swigt__p_f_p__Key_p__KeySet__int,
   26961             :   &_swigt__p_int,
   26962             :   &_swigt__p_kdb__Key,
   26963             :   &_swigt__p_kdb__KeySet,
   26964             :   &_swigt__p_kdb__tools__Backend,
   26965             :   &_swigt__p_kdb__tools__BackendBuilder,
   26966             :   &_swigt__p_kdb__tools__BackendBuilderInit,
   26967             :   &_swigt__p_kdb__tools__BackendCheckException,
   26968             :   &_swigt__p_kdb__tools__BackendFactory,
   26969             :   &_swigt__p_kdb__tools__BackendInfo,
   26970             :   &_swigt__p_kdb__tools__BackendInterface,
   26971             :   &_swigt__p_kdb__tools__Backends,
   26972             :   &_swigt__p_kdb__tools__BadPluginName,
   26973             :   &_swigt__p_kdb__tools__ConflictViolation,
   26974             :   &_swigt__p_kdb__tools__CyclicOrderingViolation,
   26975             :   &_swigt__p_kdb__tools__ErrorPlugins,
   26976             :   &_swigt__p_kdb__tools__FileNotValidException,
   26977             :   &_swigt__p_kdb__tools__GetPlugins,
   26978             :   &_swigt__p_kdb__tools__GlobalPlugins,
   26979             :   &_swigt__p_kdb__tools__GlobalPluginsBuilder,
   26980             :   &_swigt__p_kdb__tools__ImportExportBackend,
   26981             :   &_swigt__p_kdb__tools__MissingNeeded,
   26982             :   &_swigt__p_kdb__tools__MissingSymbol,
   26983             :   &_swigt__p_kdb__tools__MockPluginDatabase,
   26984             :   &_swigt__p_kdb__tools__Modules,
   26985             :   &_swigt__p_kdb__tools__ModulesPluginDatabase,
   26986             :   &_swigt__p_kdb__tools__MountBackendBuilder,
   26987             :   &_swigt__p_kdb__tools__MountBackendInterface,
   26988             :   &_swigt__p_kdb__tools__MountpointAlreadyInUseException,
   26989             :   &_swigt__p_kdb__tools__MountpointInvalidException,
   26990             :   &_swigt__p_kdb__tools__NoGlobalPlugin,
   26991             :   &_swigt__p_kdb__tools__NoPlugin,
   26992             :   &_swigt__p_kdb__tools__NoSuchBackend,
   26993             :   &_swigt__p_kdb__tools__OrderingViolation,
   26994             :   &_swigt__p_kdb__tools__ParseException,
   26995             :   &_swigt__p_kdb__tools__Place,
   26996             :   &_swigt__p_kdb__tools__Plugin,
   26997             :   &_swigt__p_kdb__tools__PluginAdder,
   26998             :   &_swigt__p_kdb__tools__PluginAlreadyInserted,
   26999             :   &_swigt__p_kdb__tools__PluginCheckException,
   27000             :   &_swigt__p_kdb__tools__PluginConfigInvalid,
   27001             :   &_swigt__p_kdb__tools__PluginDatabase,
   27002             :   &_swigt__p_kdb__tools__PluginNoContract,
   27003             :   &_swigt__p_kdb__tools__PluginNoInfo,
   27004             :   &_swigt__p_kdb__tools__PluginSpec,
   27005             :   &_swigt__p_kdb__tools__PluginSpecFullName,
   27006             :   &_swigt__p_kdb__tools__PluginSpecHash,
   27007             :   &_swigt__p_kdb__tools__PluginSpecName,
   27008             :   &_swigt__p_kdb__tools__PluginSpecRefName,
   27009             :   &_swigt__p_kdb__tools__PluginVariantDatabase,
   27010             :   &_swigt__p_kdb__tools__Plugins,
   27011             :   &_swigt__p_kdb__tools__ReferenceNotFound,
   27012             :   &_swigt__p_kdb__tools__ResolverPlugin,
   27013             :   &_swigt__p_kdb__tools__SerializeInterface,
   27014             :   &_swigt__p_kdb__tools__SetPlugins,
   27015             :   &_swigt__p_kdb__tools__SpecBackendBuilder,
   27016             :   &_swigt__p_kdb__tools__SpecReader,
   27017             :   &_swigt__p_kdb__tools__StoragePlugin,
   27018             :   &_swigt__p_kdb__tools__SymbolDuplicate,
   27019             :   &_swigt__p_kdb__tools__SymbolMismatch,
   27020             :   &_swigt__p_kdb__tools__TooManyPlugins,
   27021             :   &_swigt__p_kdb__tools__ToolException,
   27022             :   &_swigt__p_kdb__tools__VersionInfoMismatch,
   27023             :   &_swigt__p_kdb__tools__WrongStatus,
   27024             :   &_swigt__p_key_type,
   27025             :   &_swigt__p_long_long,
   27026             :   &_swigt__p_mapped_type,
   27027             :   &_swigt__p_p_void,
   27028             :   &_swigt__p_short,
   27029             :   &_swigt__p_signed_char,
   27030             :   &_swigt__p_size_type,
   27031             :   &_swigt__p_std__allocatorT_kdb__tools__BackendInfo_t,
   27032             :   &_swigt__p_std__allocatorT_kdb__tools__PluginSpec_t,
   27033             :   &_swigt__p_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t,
   27034             :   &_swigt__p_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t,
   27035             :   &_swigt__p_std__allocatorT_std__string_t,
   27036             :   &_swigt__p_std__lessT_int_t,
   27037             :   &_swigt__p_std__lessT_kdb__Key_t,
   27038             :   &_swigt__p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t,
   27039             :   &_swigt__p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t,
   27040             :   &_swigt__p_std__mapT_std__string_int_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_int_t_t_t,
   27041             :   &_swigt__p_std__ostream,
   27042             :   &_swigt__p_std__runtime_error,
   27043             :   &_swigt__p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t,
   27044             :   &_swigt__p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t,
   27045             :   &_swigt__p_std__shared_ptrT_kdb__tools__PluginDatabase_t,
   27046             :   &_swigt__p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t,
   27047             :   &_swigt__p_std__unique_ptrT_kdb__tools__BackendInterface_t,
   27048             :   &_swigt__p_std__unique_ptrT_kdb__tools__MountBackendInterface_t,
   27049             :   &_swigt__p_std__unique_ptrT_kdb__tools__Plugin_t,
   27050             :   &_swigt__p_std__unordered_mapT_kdb__tools__PluginSpec_std__unordered_mapT_std__string_std__string_t_kdb__tools__PluginSpecHash_kdb__tools__PluginSpecName_t,
   27051             :   &_swigt__p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t,
   27052             :   &_swigt__p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t,
   27053             :   &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
   27054             :   &_swigt__p_swig__ConstIterator,
   27055             :   &_swigt__p_swig__GC_VALUE,
   27056             :   &_swigt__p_swig__Iterator,
   27057             :   &_swigt__p_unsigned_char,
   27058             :   &_swigt__p_unsigned_int,
   27059             :   &_swigt__p_unsigned_long_long,
   27060             :   &_swigt__p_unsigned_short,
   27061             :   &_swigt__p_value_type,
   27062             :   &_swigt__p_void,
   27063             : };
   27064             : 
   27065             : static swig_cast_info _swigc__p_BackendInfoVector[] = {  {&_swigt__p_BackendInfoVector, 0, 0, 0},{0, 0, 0, 0}};
   27066             : static swig_cast_info _swigc__p_Backends[] = {  {&_swigt__p_Backends, 0, 0, 0},{0, 0, 0, 0}};
   27067             : static swig_cast_info _swigc__p__Plugin[] = {  {&_swigt__p__Plugin, 0, 0, 0},{0, 0, 0, 0}};
   27068             : static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
   27069             : static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
   27070             : static swig_cast_info _swigc__p_const_iterator[] = {  {&_swigt__p_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
   27071             : static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
   27072             : static swig_cast_info _swigc__p_f_p__Key_p__KeySet__int[] = {  {&_swigt__p_f_p__Key_p__KeySet__int, 0, 0, 0},{0, 0, 0, 0}};
   27073             : static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
   27074             : static swig_cast_info _swigc__p_kdb__Key[] = {  {&_swigt__p_kdb__Key, 0, 0, 0},{0, 0, 0, 0}};
   27075             : static swig_cast_info _swigc__p_kdb__KeySet[] = {  {&_swigt__p_kdb__KeySet, 0, 0, 0},{0, 0, 0, 0}};
   27076             : static swig_cast_info _swigc__p_kdb__tools__Backend[] = {  {&_swigt__p_kdb__tools__Backend, 0, 0, 0},{0, 0, 0, 0}};
   27077             : static swig_cast_info _swigc__p_kdb__tools__BackendBuilder[] = {  {&_swigt__p_kdb__tools__BackendBuilder, 0, 0, 0},  {&_swigt__p_kdb__tools__GlobalPluginsBuilder, _p_kdb__tools__GlobalPluginsBuilderTo_p_kdb__tools__BackendBuilder, 0, 0},  {&_swigt__p_kdb__tools__MountBackendBuilder, _p_kdb__tools__MountBackendBuilderTo_p_kdb__tools__BackendBuilder, 0, 0},  {&_swigt__p_kdb__tools__SpecBackendBuilder, _p_kdb__tools__SpecBackendBuilderTo_p_kdb__tools__BackendBuilder, 0, 0},{0, 0, 0, 0}};
   27078             : static swig_cast_info _swigc__p_kdb__tools__BackendBuilderInit[] = {  {&_swigt__p_kdb__tools__BackendBuilderInit, 0, 0, 0},{0, 0, 0, 0}};
   27079             : static swig_cast_info _swigc__p_kdb__tools__BackendCheckException[] = {  {&_swigt__p_kdb__tools__BackendCheckException, 0, 0, 0},  {&_swigt__p_kdb__tools__FileNotValidException, _p_kdb__tools__FileNotValidExceptionTo_p_kdb__tools__BackendCheckException, 0, 0},  {&_swigt__p_kdb__tools__MountpointInvalidException, _p_kdb__tools__MountpointInvalidExceptionTo_p_kdb__tools__BackendCheckException, 0, 0},  {&_swigt__p_kdb__tools__MountpointAlreadyInUseException, _p_kdb__tools__MountpointAlreadyInUseExceptionTo_p_kdb__tools__BackendCheckException, 0, 0},  {&_swigt__p_kdb__tools__NoSuchBackend, _p_kdb__tools__NoSuchBackendTo_p_kdb__tools__BackendCheckException, 0, 0},{0, 0, 0, 0}};
   27080             : static swig_cast_info _swigc__p_kdb__tools__BackendFactory[] = {  {&_swigt__p_kdb__tools__BackendFactory, 0, 0, 0},{0, 0, 0, 0}};
   27081             : static swig_cast_info _swigc__p_kdb__tools__BackendInfo[] = {  {&_swigt__p_kdb__tools__BackendInfo, 0, 0, 0},{0, 0, 0, 0}};
   27082             : static swig_cast_info _swigc__p_kdb__tools__BackendInterface[] = {  {&_swigt__p_kdb__tools__BackendInterface, 0, 0, 0},  {&_swigt__p_kdb__tools__MountBackendInterface, _p_kdb__tools__MountBackendInterfaceTo_p_kdb__tools__BackendInterface, 0, 0},  {&_swigt__p_kdb__tools__PluginAdder, _p_kdb__tools__PluginAdderTo_p_kdb__tools__BackendInterface, 0, 0},  {&_swigt__p_kdb__tools__MountBackendBuilder, _p_kdb__tools__MountBackendBuilderTo_p_kdb__tools__BackendInterface, 0, 0},  {&_swigt__p_kdb__tools__SpecBackendBuilder, _p_kdb__tools__SpecBackendBuilderTo_p_kdb__tools__BackendInterface, 0, 0},  {&_swigt__p_kdb__tools__BackendBuilder, _p_kdb__tools__BackendBuilderTo_p_kdb__tools__BackendInterface, 0, 0},  {&_swigt__p_kdb__tools__GlobalPluginsBuilder, _p_kdb__tools__GlobalPluginsBuilderTo_p_kdb__tools__BackendInterface, 0, 0},  {&_swigt__p_kdb__tools__Backend, _p_kdb__tools__BackendTo_p_kdb__tools__BackendInterface, 0, 0},  {&_swigt__p_kdb__tools__ImportExportBackend, _p_kdb__tools__ImportExportBackendTo_p_kdb__tools__BackendInterface, 0, 0},  {&_swigt__p_kdb__tools__GlobalPlugins, _p_kdb__tools__GlobalPluginsTo_p_kdb__tools__BackendInterface, 0, 0},{0, 0, 0, 0}};
   27083             : static swig_cast_info _swigc__p_kdb__tools__Backends[] = {  {&_swigt__p_kdb__tools__Backends, 0, 0, 0},{0, 0, 0, 0}};
   27084             : static swig_cast_info _swigc__p_kdb__tools__BadPluginName[] = {  {&_swigt__p_kdb__tools__BadPluginName, 0, 0, 0},{0, 0, 0, 0}};
   27085             : static swig_cast_info _swigc__p_kdb__tools__ConflictViolation[] = {  {&_swigt__p_kdb__tools__ConflictViolation, 0, 0, 0},{0, 0, 0, 0}};
   27086             : static swig_cast_info _swigc__p_kdb__tools__CyclicOrderingViolation[] = {  {&_swigt__p_kdb__tools__CyclicOrderingViolation, 0, 0, 0},{0, 0, 0, 0}};
   27087             : static swig_cast_info _swigc__p_kdb__tools__ErrorPlugins[] = {  {&_swigt__p_kdb__tools__ErrorPlugins, 0, 0, 0},{0, 0, 0, 0}};
   27088             : static swig_cast_info _swigc__p_kdb__tools__FileNotValidException[] = {  {&_swigt__p_kdb__tools__FileNotValidException, 0, 0, 0},{0, 0, 0, 0}};
   27089             : static swig_cast_info _swigc__p_kdb__tools__GetPlugins[] = {  {&_swigt__p_kdb__tools__GetPlugins, 0, 0, 0},{0, 0, 0, 0}};
   27090             : static swig_cast_info _swigc__p_kdb__tools__GlobalPlugins[] = {  {&_swigt__p_kdb__tools__GlobalPlugins, 0, 0, 0},{0, 0, 0, 0}};
   27091             : static swig_cast_info _swigc__p_kdb__tools__GlobalPluginsBuilder[] = {  {&_swigt__p_kdb__tools__GlobalPluginsBuilder, 0, 0, 0},{0, 0, 0, 0}};
   27092             : static swig_cast_info _swigc__p_kdb__tools__ImportExportBackend[] = {  {&_swigt__p_kdb__tools__ImportExportBackend, 0, 0, 0},{0, 0, 0, 0}};
   27093             : static swig_cast_info _swigc__p_kdb__tools__MissingNeeded[] = {  {&_swigt__p_kdb__tools__MissingNeeded, 0, 0, 0},{0, 0, 0, 0}};
   27094             : static swig_cast_info _swigc__p_kdb__tools__MissingSymbol[] = {  {&_swigt__p_kdb__tools__MissingSymbol, 0, 0, 0},{0, 0, 0, 0}};
   27095             : static swig_cast_info _swigc__p_kdb__tools__MockPluginDatabase[] = {  {&_swigt__p_kdb__tools__MockPluginDatabase, 0, 0, 0},{0, 0, 0, 0}};
   27096             : static swig_cast_info _swigc__p_kdb__tools__Modules[] = {  {&_swigt__p_kdb__tools__Modules, 0, 0, 0},{0, 0, 0, 0}};
   27097             : static swig_cast_info _swigc__p_kdb__tools__ModulesPluginDatabase[] = {  {&_swigt__p_kdb__tools__ModulesPluginDatabase, 0, 0, 0},  {&_swigt__p_kdb__tools__PluginVariantDatabase, _p_kdb__tools__PluginVariantDatabaseTo_p_kdb__tools__ModulesPluginDatabase, 0, 0},  {&_swigt__p_kdb__tools__MockPluginDatabase, _p_kdb__tools__MockPluginDatabaseTo_p_kdb__tools__ModulesPluginDatabase, 0, 0},{0, 0, 0, 0}};
   27098             : static swig_cast_info _swigc__p_kdb__tools__MountBackendBuilder[] = {  {&_swigt__p_kdb__tools__MountBackendBuilder, 0, 0, 0},  {&_swigt__p_kdb__tools__SpecBackendBuilder, _p_kdb__tools__SpecBackendBuilderTo_p_kdb__tools__MountBackendBuilder, 0, 0},{0, 0, 0, 0}};
   27099             : static swig_cast_info _swigc__p_kdb__tools__MountBackendInterface[] = {  {&_swigt__p_kdb__tools__MountBackendInterface, 0, 0, 0},  {&_swigt__p_kdb__tools__MountBackendBuilder, _p_kdb__tools__MountBackendBuilderTo_p_kdb__tools__MountBackendInterface, 0, 0},  {&_swigt__p_kdb__tools__SpecBackendBuilder, _p_kdb__tools__SpecBackendBuilderTo_p_kdb__tools__MountBackendInterface, 0, 0},  {&_swigt__p_kdb__tools__Backend, _p_kdb__tools__BackendTo_p_kdb__tools__MountBackendInterface, 0, 0},{0, 0, 0, 0}};
   27100             : static swig_cast_info _swigc__p_kdb__tools__MountpointAlreadyInUseException[] = {  {&_swigt__p_kdb__tools__MountpointAlreadyInUseException, 0, 0, 0},{0, 0, 0, 0}};
   27101             : static swig_cast_info _swigc__p_kdb__tools__MountpointInvalidException[] = {  {&_swigt__p_kdb__tools__MountpointInvalidException, 0, 0, 0},{0, 0, 0, 0}};
   27102             : static swig_cast_info _swigc__p_kdb__tools__NoGlobalPlugin[] = {  {&_swigt__p_kdb__tools__NoGlobalPlugin, 0, 0, 0},{0, 0, 0, 0}};
   27103             : static swig_cast_info _swigc__p_kdb__tools__NoPlugin[] = {  {&_swigt__p_kdb__tools__NoPlugin, 0, 0, 0},{0, 0, 0, 0}};
   27104             : static swig_cast_info _swigc__p_kdb__tools__NoSuchBackend[] = {  {&_swigt__p_kdb__tools__NoSuchBackend, 0, 0, 0},{0, 0, 0, 0}};
   27105             : static swig_cast_info _swigc__p_kdb__tools__OrderingViolation[] = {  {&_swigt__p_kdb__tools__OrderingViolation, 0, 0, 0},  {&_swigt__p_kdb__tools__CyclicOrderingViolation, _p_kdb__tools__CyclicOrderingViolationTo_p_kdb__tools__OrderingViolation, 0, 0},{0, 0, 0, 0}};
   27106             : static swig_cast_info _swigc__p_kdb__tools__ParseException[] = {  {&_swigt__p_kdb__tools__ParseException, 0, 0, 0},{0, 0, 0, 0}};
   27107             : static swig_cast_info _swigc__p_kdb__tools__Place[] = {  {&_swigt__p_kdb__tools__Place, 0, 0, 0},{0, 0, 0, 0}};
   27108             : static swig_cast_info _swigc__p_kdb__tools__Plugin[] = {  {&_swigt__p_kdb__tools__Plugin, 0, 0, 0},{0, 0, 0, 0}};
   27109             : static swig_cast_info _swigc__p_kdb__tools__PluginAdder[] = {  {&_swigt__p_kdb__tools__PluginAdder, 0, 0, 0},  {&_swigt__p_kdb__tools__ImportExportBackend, _p_kdb__tools__ImportExportBackendTo_p_kdb__tools__PluginAdder, 0, 0},  {&_swigt__p_kdb__tools__GlobalPlugins, _p_kdb__tools__GlobalPluginsTo_p_kdb__tools__PluginAdder, 0, 0},{0, 0, 0, 0}};
   27110             : static swig_cast_info _swigc__p_kdb__tools__PluginAlreadyInserted[] = {  {&_swigt__p_kdb__tools__PluginAlreadyInserted, 0, 0, 0},{0, 0, 0, 0}};
   27111             : static swig_cast_info _swigc__p_kdb__tools__PluginCheckException[] = {  {&_swigt__p_kdb__tools__PluginConfigInvalid, _p_kdb__tools__PluginConfigInvalidTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__PluginNoContract, _p_kdb__tools__PluginNoContractTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__PluginNoInfo, _p_kdb__tools__PluginNoInfoTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__ConflictViolation, _p_kdb__tools__ConflictViolationTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__CyclicOrderingViolation, _p_kdb__tools__CyclicOrderingViolationTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__OrderingViolation, _p_kdb__tools__OrderingViolationTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__TooManyPlugins, _p_kdb__tools__TooManyPluginsTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__MissingNeeded, _p_kdb__tools__MissingNeededTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__ReferenceNotFound, _p_kdb__tools__ReferenceNotFoundTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__SymbolDuplicate, _p_kdb__tools__SymbolDuplicateTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__PluginCheckException, 0, 0, 0},  {&_swigt__p_kdb__tools__NoPlugin, _p_kdb__tools__NoPluginTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__StoragePlugin, _p_kdb__tools__StoragePluginTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__PluginAlreadyInserted, _p_kdb__tools__PluginAlreadyInsertedTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__NoGlobalPlugin, _p_kdb__tools__NoGlobalPluginTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__WrongStatus, _p_kdb__tools__WrongStatusTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__BadPluginName, _p_kdb__tools__BadPluginNameTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__ResolverPlugin, _p_kdb__tools__ResolverPluginTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__SymbolMismatch, _p_kdb__tools__SymbolMismatchTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__MissingSymbol, _p_kdb__tools__MissingSymbolTo_p_kdb__tools__PluginCheckException, 0, 0},  {&_swigt__p_kdb__tools__VersionInfoMismatch, _p_kdb__tools__VersionInfoMismatchTo_p_kdb__tools__PluginCheckException, 0, 0},{0, 0, 0, 0}};
   27112             : static swig_cast_info _swigc__p_kdb__tools__PluginConfigInvalid[] = {  {&_swigt__p_kdb__tools__PluginConfigInvalid, 0, 0, 0},{0, 0, 0, 0}};
   27113             : static swig_cast_info _swigc__p_kdb__tools__PluginDatabase[] = {  {&_swigt__p_kdb__tools__PluginDatabase, 0, 0, 0},  {&_swigt__p_kdb__tools__ModulesPluginDatabase, _p_kdb__tools__ModulesPluginDatabaseTo_p_kdb__tools__PluginDatabase, 0, 0},  {&_swigt__p_kdb__tools__PluginVariantDatabase, _p_kdb__tools__PluginVariantDatabaseTo_p_kdb__tools__PluginDatabase, 0, 0},  {&_swigt__p_kdb__tools__MockPluginDatabase, _p_kdb__tools__MockPluginDatabaseTo_p_kdb__tools__PluginDatabase, 0, 0},{0, 0, 0, 0}};
   27114             : static swig_cast_info _swigc__p_kdb__tools__PluginNoContract[] = {  {&_swigt__p_kdb__tools__PluginNoContract, 0, 0, 0},{0, 0, 0, 0}};
   27115             : static swig_cast_info _swigc__p_kdb__tools__PluginNoInfo[] = {  {&_swigt__p_kdb__tools__PluginNoInfo, 0, 0, 0},{0, 0, 0, 0}};
   27116             : static swig_cast_info _swigc__p_kdb__tools__PluginSpec[] = {  {&_swigt__p_kdb__tools__PluginSpec, 0, 0, 0},{0, 0, 0, 0}};
   27117             : static swig_cast_info _swigc__p_kdb__tools__PluginSpecFullName[] = {  {&_swigt__p_kdb__tools__PluginSpecFullName, 0, 0, 0},{0, 0, 0, 0}};
   27118             : static swig_cast_info _swigc__p_kdb__tools__PluginSpecHash[] = {  {&_swigt__p_kdb__tools__PluginSpecHash, 0, 0, 0},{0, 0, 0, 0}};
   27119             : static swig_cast_info _swigc__p_kdb__tools__PluginSpecName[] = {  {&_swigt__p_kdb__tools__PluginSpecName, 0, 0, 0},{0, 0, 0, 0}};
   27120             : static swig_cast_info _swigc__p_kdb__tools__PluginSpecRefName[] = {  {&_swigt__p_kdb__tools__PluginSpecRefName, 0, 0, 0},{0, 0, 0, 0}};
   27121             : static swig_cast_info _swigc__p_kdb__tools__PluginVariantDatabase[] = {  {&_swigt__p_kdb__tools__PluginVariantDatabase, 0, 0, 0},{0, 0, 0, 0}};
   27122             : static swig_cast_info _swigc__p_kdb__tools__Plugins[] = {  {&_swigt__p_kdb__tools__Plugins, 0, 0, 0},  {&_swigt__p_kdb__tools__GetPlugins, _p_kdb__tools__GetPluginsTo_p_kdb__tools__Plugins, 0, 0},  {&_swigt__p_kdb__tools__SetPlugins, _p_kdb__tools__SetPluginsTo_p_kdb__tools__Plugins, 0, 0},  {&_swigt__p_kdb__tools__ErrorPlugins, _p_kdb__tools__ErrorPluginsTo_p_kdb__tools__Plugins, 0, 0},{0, 0, 0, 0}};
   27123             : static swig_cast_info _swigc__p_kdb__tools__ReferenceNotFound[] = {  {&_swigt__p_kdb__tools__ReferenceNotFound, 0, 0, 0},{0, 0, 0, 0}};
   27124             : static swig_cast_info _swigc__p_kdb__tools__ResolverPlugin[] = {  {&_swigt__p_kdb__tools__ResolverPlugin, 0, 0, 0},{0, 0, 0, 0}};
   27125             : static swig_cast_info _swigc__p_kdb__tools__SerializeInterface[] = {  {&_swigt__p_kdb__tools__SerializeInterface, 0, 0, 0},  {&_swigt__p_kdb__tools__MountBackendInterface, _p_kdb__tools__MountBackendInterfaceTo_p_kdb__tools__SerializeInterface, 0, 0},  {&_swigt__p_kdb__tools__MountBackendBuilder, _p_kdb__tools__MountBackendBuilderTo_p_kdb__tools__SerializeInterface, 0, 0},  {&_swigt__p_kdb__tools__SpecBackendBuilder, _p_kdb__tools__SpecBackendBuilderTo_p_kdb__tools__SerializeInterface, 0, 0},  {&_swigt__p_kdb__tools__Backend, _p_kdb__tools__BackendTo_p_kdb__tools__SerializeInterface, 0, 0},  {&_swigt__p_kdb__tools__GlobalPlugins, _p_kdb__tools__GlobalPluginsTo_p_kdb__tools__SerializeInterface, 0, 0},{0, 0, 0, 0}};
   27126             : static swig_cast_info _swigc__p_kdb__tools__SetPlugins[] = {  {&_swigt__p_kdb__tools__SetPlugins, 0, 0, 0},{0, 0, 0, 0}};
   27127             : static swig_cast_info _swigc__p_kdb__tools__SpecBackendBuilder[] = {  {&_swigt__p_kdb__tools__SpecBackendBuilder, 0, 0, 0},{0, 0, 0, 0}};
   27128             : static swig_cast_info _swigc__p_kdb__tools__SpecReader[] = {  {&_swigt__p_kdb__tools__SpecReader, 0, 0, 0},{0, 0, 0, 0}};
   27129             : static swig_cast_info _swigc__p_kdb__tools__StoragePlugin[] = {  {&_swigt__p_kdb__tools__StoragePlugin, 0, 0, 0},{0, 0, 0, 0}};
   27130             : static swig_cast_info _swigc__p_kdb__tools__SymbolDuplicate[] = {  {&_swigt__p_kdb__tools__SymbolDuplicate, 0, 0, 0},{0, 0, 0, 0}};
   27131             : static swig_cast_info _swigc__p_kdb__tools__SymbolMismatch[] = {  {&_swigt__p_kdb__tools__SymbolMismatch, 0, 0, 0},{0, 0, 0, 0}};
   27132             : static swig_cast_info _swigc__p_kdb__tools__TooManyPlugins[] = {  {&_swigt__p_kdb__tools__TooManyPlugins, 0, 0, 0},{0, 0, 0, 0}};
   27133             : static swig_cast_info _swigc__p_kdb__tools__ToolException[] = {  {&_swigt__p_kdb__tools__PluginConfigInvalid, _p_kdb__tools__PluginConfigInvalidTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__PluginNoContract, _p_kdb__tools__PluginNoContractTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__PluginNoInfo, _p_kdb__tools__PluginNoInfoTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__ConflictViolation, _p_kdb__tools__ConflictViolationTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__CyclicOrderingViolation, _p_kdb__tools__CyclicOrderingViolationTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__OrderingViolation, _p_kdb__tools__OrderingViolationTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__TooManyPlugins, _p_kdb__tools__TooManyPluginsTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__NoSuchBackend, _p_kdb__tools__NoSuchBackendTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__MissingNeeded, _p_kdb__tools__MissingNeededTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__ReferenceNotFound, _p_kdb__tools__ReferenceNotFoundTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__MountpointAlreadyInUseException, _p_kdb__tools__MountpointAlreadyInUseExceptionTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__MountpointInvalidException, _p_kdb__tools__MountpointInvalidExceptionTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__FileNotValidException, _p_kdb__tools__FileNotValidExceptionTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__ToolException, 0, 0, 0},  {&_swigt__p_kdb__tools__BackendCheckException, _p_kdb__tools__BackendCheckExceptionTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__PluginCheckException, _p_kdb__tools__PluginCheckExceptionTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__SymbolDuplicate, _p_kdb__tools__SymbolDuplicateTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__ParseException, _p_kdb__tools__ParseExceptionTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__StoragePlugin, _p_kdb__tools__StoragePluginTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__NoPlugin, _p_kdb__tools__NoPluginTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__PluginAlreadyInserted, _p_kdb__tools__PluginAlreadyInsertedTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__NoGlobalPlugin, _p_kdb__tools__NoGlobalPluginTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__WrongStatus, _p_kdb__tools__WrongStatusTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__BadPluginName, _p_kdb__tools__BadPluginNameTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__ResolverPlugin, _p_kdb__tools__ResolverPluginTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__SymbolMismatch, _p_kdb__tools__SymbolMismatchTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__MissingSymbol, _p_kdb__tools__MissingSymbolTo_p_kdb__tools__ToolException, 0, 0},  {&_swigt__p_kdb__tools__VersionInfoMismatch, _p_kdb__tools__VersionInfoMismatchTo_p_kdb__tools__ToolException, 0, 0},{0, 0, 0, 0}};
   27134             : static swig_cast_info _swigc__p_kdb__tools__VersionInfoMismatch[] = {  {&_swigt__p_kdb__tools__VersionInfoMismatch, 0, 0, 0},{0, 0, 0, 0}};
   27135             : static swig_cast_info _swigc__p_kdb__tools__WrongStatus[] = {  {&_swigt__p_kdb__tools__WrongStatus, 0, 0, 0},{0, 0, 0, 0}};
   27136             : static swig_cast_info _swigc__p_key_type[] = {  {&_swigt__p_key_type, 0, 0, 0},{0, 0, 0, 0}};
   27137             : static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
   27138             : static swig_cast_info _swigc__p_mapped_type[] = {  {&_swigt__p_mapped_type, 0, 0, 0},{0, 0, 0, 0}};
   27139             : static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
   27140             : static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
   27141             : static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
   27142             : static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
   27143             : static swig_cast_info _swigc__p_std__allocatorT_kdb__tools__BackendInfo_t[] = {  {&_swigt__p_std__allocatorT_kdb__tools__BackendInfo_t, 0, 0, 0},{0, 0, 0, 0}};
   27144             : static swig_cast_info _swigc__p_std__allocatorT_kdb__tools__PluginSpec_t[] = {  {&_swigt__p_std__allocatorT_kdb__tools__PluginSpec_t, 0, 0, 0},{0, 0, 0, 0}};
   27145             : static swig_cast_info _swigc__p_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t, 0, 0, 0},{0, 0, 0, 0}};
   27146             : static swig_cast_info _swigc__p_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t, 0, 0, 0},{0, 0, 0, 0}};
   27147             : static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = {  {&_swigt__p_std__allocatorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
   27148             : static swig_cast_info _swigc__p_std__lessT_int_t[] = {  {&_swigt__p_std__lessT_int_t, 0, 0, 0},{0, 0, 0, 0}};
   27149             : static swig_cast_info _swigc__p_std__lessT_kdb__Key_t[] = {  {&_swigt__p_std__lessT_kdb__Key_t, 0, 0, 0},{0, 0, 0, 0}};
   27150             : static swig_cast_info _swigc__p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t[] = {  {&_swigt__p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
   27151             : static swig_cast_info _swigc__p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t[] = {  {&_swigt__p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
   27152             : static swig_cast_info _swigc__p_std__mapT_std__string_int_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_int_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_int_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
   27153             : static swig_cast_info _swigc__p_std__ostream[] = {  {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}};
   27154             : static swig_cast_info _swigc__p_std__runtime_error[] = {  {&_swigt__p_kdb__tools__PluginConfigInvalid, _p_kdb__tools__PluginConfigInvalidTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__PluginNoContract, _p_kdb__tools__PluginNoContractTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__PluginNoInfo, _p_kdb__tools__PluginNoInfoTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__CyclicOrderingViolation, _p_kdb__tools__CyclicOrderingViolationTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__OrderingViolation, _p_kdb__tools__OrderingViolationTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__ConflictViolation, _p_kdb__tools__ConflictViolationTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__TooManyPlugins, _p_kdb__tools__TooManyPluginsTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__NoSuchBackend, _p_kdb__tools__NoSuchBackendTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__MissingNeeded, _p_kdb__tools__MissingNeededTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__ReferenceNotFound, _p_kdb__tools__ReferenceNotFoundTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__MountpointAlreadyInUseException, _p_kdb__tools__MountpointAlreadyInUseExceptionTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__MountpointInvalidException, _p_kdb__tools__MountpointInvalidExceptionTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__FileNotValidException, _p_kdb__tools__FileNotValidExceptionTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__BackendCheckException, _p_kdb__tools__BackendCheckExceptionTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__PluginCheckException, _p_kdb__tools__PluginCheckExceptionTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__SymbolDuplicate, _p_kdb__tools__SymbolDuplicateTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__ParseException, _p_kdb__tools__ParseExceptionTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__ToolException, _p_kdb__tools__ToolExceptionTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__StoragePlugin, _p_kdb__tools__StoragePluginTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__NoPlugin, _p_kdb__tools__NoPluginTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__PluginAlreadyInserted, _p_kdb__tools__PluginAlreadyInsertedTo_p_std__runtime_error, 0, 0},  {&_swigt__p_std__runtime_error, 0, 0, 0},  {&_swigt__p_kdb__tools__NoGlobalPlugin, _p_kdb__tools__NoGlobalPluginTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__WrongStatus, _p_kdb__tools__WrongStatusTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__BadPluginName, _p_kdb__tools__BadPluginNameTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__ResolverPlugin, _p_kdb__tools__ResolverPluginTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__SymbolMismatch, _p_kdb__tools__SymbolMismatchTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__MissingSymbol, _p_kdb__tools__MissingSymbolTo_p_std__runtime_error, 0, 0},  {&_swigt__p_kdb__tools__VersionInfoMismatch, _p_kdb__tools__VersionInfoMismatchTo_p_std__runtime_error, 0, 0},{0, 0, 0, 0}};
   27155             : static swig_cast_info _swigc__p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t[] = {  {&_swigt__p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t, 0, 0, 0},{0, 0, 0, 0}};
   27156             : static swig_cast_info _swigc__p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t[] = {  {&_swigt__p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t, _p_std__shared_ptrT_kdb__tools__MockPluginDatabase_tTo_p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t, 0, 0},  {&_swigt__p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t, _p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_tTo_p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t, 0, 0},  {&_swigt__p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t, 0, 0, 0},{0, 0, 0, 0}};
   27157             : static swig_cast_info _swigc__p_std__shared_ptrT_kdb__tools__PluginDatabase_t[] = {  {&_swigt__p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t, _p_std__shared_ptrT_kdb__tools__MockPluginDatabase_tTo_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, 0, 0},  {&_swigt__p_std__shared_ptrT_kdb__tools__PluginDatabase_t, 0, 0, 0},  {&_swigt__p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t, _p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_tTo_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, 0, 0},  {&_swigt__p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t, _p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_tTo_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, 0, 0},{0, 0, 0, 0}};
   27158             : static swig_cast_info _swigc__p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t[] = {  {&_swigt__p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t, 0, 0, 0},{0, 0, 0, 0}};
   27159             : static swig_cast_info _swigc__p_std__unique_ptrT_kdb__tools__BackendInterface_t[] = {  {&_swigt__p_std__unique_ptrT_kdb__tools__BackendInterface_t, 0, 0, 0},{0, 0, 0, 0}};
   27160             : static swig_cast_info _swigc__p_std__unique_ptrT_kdb__tools__MountBackendInterface_t[] = {  {&_swigt__p_std__unique_ptrT_kdb__tools__MountBackendInterface_t, 0, 0, 0},{0, 0, 0, 0}};
   27161             : static swig_cast_info _swigc__p_std__unique_ptrT_kdb__tools__Plugin_t[] = {  {&_swigt__p_std__unique_ptrT_kdb__tools__Plugin_t, 0, 0, 0},{0, 0, 0, 0}};
   27162             : static swig_cast_info _swigc__p_std__unordered_mapT_kdb__tools__PluginSpec_std__unordered_mapT_std__string_std__string_t_kdb__tools__PluginSpecHash_kdb__tools__PluginSpecName_t[] = {  {&_swigt__p_std__unordered_mapT_kdb__tools__PluginSpec_std__unordered_mapT_std__string_std__string_t_kdb__tools__PluginSpecHash_kdb__tools__PluginSpecName_t, 0, 0, 0},{0, 0, 0, 0}};
   27163             : static swig_cast_info _swigc__p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t[] = {  {&_swigt__p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, 0, 0, 0},{0, 0, 0, 0}};
   27164             : static swig_cast_info _swigc__p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t[] = {  {&_swigt__p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, 0, 0, 0},{0, 0, 0, 0}};
   27165             : static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
   27166             : static swig_cast_info _swigc__p_swig__ConstIterator[] = {  {&_swigt__p_swig__ConstIterator, 0, 0, 0},  {&_swigt__p_swig__Iterator, _p_swig__IteratorTo_p_swig__ConstIterator, 0, 0},{0, 0, 0, 0}};
   27167             : static swig_cast_info _swigc__p_swig__GC_VALUE[] = {  {&_swigt__p_swig__GC_VALUE, 0, 0, 0},{0, 0, 0, 0}};
   27168             : static swig_cast_info _swigc__p_swig__Iterator[] = {  {&_swigt__p_swig__Iterator, 0, 0, 0},{0, 0, 0, 0}};
   27169             : static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
   27170             : static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
   27171             : static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
   27172             : static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
   27173             : static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
   27174             : static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
   27175             : 
   27176             : static swig_cast_info *swig_cast_initial[] = {
   27177             :   _swigc__p_BackendInfoVector,
   27178             :   _swigc__p_Backends,
   27179             :   _swigc__p__Plugin,
   27180             :   _swigc__p_allocator_type,
   27181             :   _swigc__p_char,
   27182             :   _swigc__p_const_iterator,
   27183             :   _swigc__p_difference_type,
   27184             :   _swigc__p_f_p__Key_p__KeySet__int,
   27185             :   _swigc__p_int,
   27186             :   _swigc__p_kdb__Key,
   27187             :   _swigc__p_kdb__KeySet,
   27188             :   _swigc__p_kdb__tools__Backend,
   27189             :   _swigc__p_kdb__tools__BackendBuilder,
   27190             :   _swigc__p_kdb__tools__BackendBuilderInit,
   27191             :   _swigc__p_kdb__tools__BackendCheckException,
   27192             :   _swigc__p_kdb__tools__BackendFactory,
   27193             :   _swigc__p_kdb__tools__BackendInfo,
   27194             :   _swigc__p_kdb__tools__BackendInterface,
   27195             :   _swigc__p_kdb__tools__Backends,
   27196             :   _swigc__p_kdb__tools__BadPluginName,
   27197             :   _swigc__p_kdb__tools__ConflictViolation,
   27198             :   _swigc__p_kdb__tools__CyclicOrderingViolation,
   27199             :   _swigc__p_kdb__tools__ErrorPlugins,
   27200             :   _swigc__p_kdb__tools__FileNotValidException,
   27201             :   _swigc__p_kdb__tools__GetPlugins,
   27202             :   _swigc__p_kdb__tools__GlobalPlugins,
   27203             :   _swigc__p_kdb__tools__GlobalPluginsBuilder,
   27204             :   _swigc__p_kdb__tools__ImportExportBackend,
   27205             :   _swigc__p_kdb__tools__MissingNeeded,
   27206             :   _swigc__p_kdb__tools__MissingSymbol,
   27207             :   _swigc__p_kdb__tools__MockPluginDatabase,
   27208             :   _swigc__p_kdb__tools__Modules,
   27209             :   _swigc__p_kdb__tools__ModulesPluginDatabase,
   27210             :   _swigc__p_kdb__tools__MountBackendBuilder,
   27211             :   _swigc__p_kdb__tools__MountBackendInterface,
   27212             :   _swigc__p_kdb__tools__MountpointAlreadyInUseException,
   27213             :   _swigc__p_kdb__tools__MountpointInvalidException,
   27214             :   _swigc__p_kdb__tools__NoGlobalPlugin,
   27215             :   _swigc__p_kdb__tools__NoPlugin,
   27216             :   _swigc__p_kdb__tools__NoSuchBackend,
   27217             :   _swigc__p_kdb__tools__OrderingViolation,
   27218             :   _swigc__p_kdb__tools__ParseException,
   27219             :   _swigc__p_kdb__tools__Place,
   27220             :   _swigc__p_kdb__tools__Plugin,
   27221             :   _swigc__p_kdb__tools__PluginAdder,
   27222             :   _swigc__p_kdb__tools__PluginAlreadyInserted,
   27223             :   _swigc__p_kdb__tools__PluginCheckException,
   27224             :   _swigc__p_kdb__tools__PluginConfigInvalid,
   27225             :   _swigc__p_kdb__tools__PluginDatabase,
   27226             :   _swigc__p_kdb__tools__PluginNoContract,
   27227             :   _swigc__p_kdb__tools__PluginNoInfo,
   27228             :   _swigc__p_kdb__tools__PluginSpec,
   27229             :   _swigc__p_kdb__tools__PluginSpecFullName,
   27230             :   _swigc__p_kdb__tools__PluginSpecHash,
   27231             :   _swigc__p_kdb__tools__PluginSpecName,
   27232             :   _swigc__p_kdb__tools__PluginSpecRefName,
   27233             :   _swigc__p_kdb__tools__PluginVariantDatabase,
   27234             :   _swigc__p_kdb__tools__Plugins,
   27235             :   _swigc__p_kdb__tools__ReferenceNotFound,
   27236             :   _swigc__p_kdb__tools__ResolverPlugin,
   27237             :   _swigc__p_kdb__tools__SerializeInterface,
   27238             :   _swigc__p_kdb__tools__SetPlugins,
   27239             :   _swigc__p_kdb__tools__SpecBackendBuilder,
   27240             :   _swigc__p_kdb__tools__SpecReader,
   27241             :   _swigc__p_kdb__tools__StoragePlugin,
   27242             :   _swigc__p_kdb__tools__SymbolDuplicate,
   27243             :   _swigc__p_kdb__tools__SymbolMismatch,
   27244             :   _swigc__p_kdb__tools__TooManyPlugins,
   27245             :   _swigc__p_kdb__tools__ToolException,
   27246             :   _swigc__p_kdb__tools__VersionInfoMismatch,
   27247             :   _swigc__p_kdb__tools__WrongStatus,
   27248             :   _swigc__p_key_type,
   27249             :   _swigc__p_long_long,
   27250             :   _swigc__p_mapped_type,
   27251             :   _swigc__p_p_void,
   27252             :   _swigc__p_short,
   27253             :   _swigc__p_signed_char,
   27254             :   _swigc__p_size_type,
   27255             :   _swigc__p_std__allocatorT_kdb__tools__BackendInfo_t,
   27256             :   _swigc__p_std__allocatorT_kdb__tools__PluginSpec_t,
   27257             :   _swigc__p_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t,
   27258             :   _swigc__p_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t,
   27259             :   _swigc__p_std__allocatorT_std__string_t,
   27260             :   _swigc__p_std__lessT_int_t,
   27261             :   _swigc__p_std__lessT_kdb__Key_t,
   27262             :   _swigc__p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t,
   27263             :   _swigc__p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t,
   27264             :   _swigc__p_std__mapT_std__string_int_std__lessT_std__string_t_std__allocatorT_std__pairT_std__string_const_int_t_t_t,
   27265             :   _swigc__p_std__ostream,
   27266             :   _swigc__p_std__runtime_error,
   27267             :   _swigc__p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t,
   27268             :   _swigc__p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t,
   27269             :   _swigc__p_std__shared_ptrT_kdb__tools__PluginDatabase_t,
   27270             :   _swigc__p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t,
   27271             :   _swigc__p_std__unique_ptrT_kdb__tools__BackendInterface_t,
   27272             :   _swigc__p_std__unique_ptrT_kdb__tools__MountBackendInterface_t,
   27273             :   _swigc__p_std__unique_ptrT_kdb__tools__Plugin_t,
   27274             :   _swigc__p_std__unordered_mapT_kdb__tools__PluginSpec_std__unordered_mapT_std__string_std__string_t_kdb__tools__PluginSpecHash_kdb__tools__PluginSpecName_t,
   27275             :   _swigc__p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t,
   27276             :   _swigc__p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t,
   27277             :   _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
   27278             :   _swigc__p_swig__ConstIterator,
   27279             :   _swigc__p_swig__GC_VALUE,
   27280             :   _swigc__p_swig__Iterator,
   27281             :   _swigc__p_unsigned_char,
   27282             :   _swigc__p_unsigned_int,
   27283             :   _swigc__p_unsigned_long_long,
   27284             :   _swigc__p_unsigned_short,
   27285             :   _swigc__p_value_type,
   27286             :   _swigc__p_void,
   27287             : };
   27288             : 
   27289             : 
   27290             : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
   27291             : 
   27292             : /* -----------------------------------------------------------------------------
   27293             :  * Type initialization:
   27294             :  * This problem is tough by the requirement that no dynamic
   27295             :  * memory is used. Also, since swig_type_info structures store pointers to
   27296             :  * swig_cast_info structures and swig_cast_info structures store pointers back
   27297             :  * to swig_type_info structures, we need some lookup code at initialization.
   27298             :  * The idea is that swig generates all the structures that are needed.
   27299             :  * The runtime then collects these partially filled structures.
   27300             :  * The SWIG_InitializeModule function takes these initial arrays out of
   27301             :  * swig_module, and does all the lookup, filling in the swig_module.types
   27302             :  * array with the correct data and linking the correct swig_cast_info
   27303             :  * structures together.
   27304             :  *
   27305             :  * The generated swig_type_info structures are assigned statically to an initial
   27306             :  * array. We just loop through that array, and handle each type individually.
   27307             :  * First we lookup if this type has been already loaded, and if so, use the
   27308             :  * loaded structure instead of the generated one. Then we have to fill in the
   27309             :  * cast linked list. The cast data is initially stored in something like a
   27310             :  * two-dimensional array. Each row corresponds to a type (there are the same
   27311             :  * number of rows as there are in the swig_type_initial array). Each entry in
   27312             :  * a column is one of the swig_cast_info structures for that type.
   27313             :  * The cast_initial array is actually an array of arrays, because each row has
   27314             :  * a variable number of columns. So to actually build the cast linked list,
   27315             :  * we find the array of casts associated with the type, and loop through it
   27316             :  * adding the casts to the list. The one last trick we need to do is making
   27317             :  * sure the type pointer in the swig_cast_info struct is correct.
   27318             :  *
   27319             :  * First off, we lookup the cast->type name to see if it is already loaded.
   27320             :  * There are three cases to handle:
   27321             :  *  1) If the cast->type has already been loaded AND the type we are adding
   27322             :  *     casting info to has not been loaded (it is in this module), THEN we
   27323             :  *     replace the cast->type pointer with the type pointer that has already
   27324             :  *     been loaded.
   27325             :  *  2) If BOTH types (the one we are adding casting info to, and the
   27326             :  *     cast->type) are loaded, THEN the cast info has already been loaded by
   27327             :  *     the previous module so we just ignore it.
   27328             :  *  3) Finally, if cast->type has not already been loaded, then we add that
   27329             :  *     swig_cast_info to the linked list (because the cast->type) pointer will
   27330             :  *     be correct.
   27331             :  * ----------------------------------------------------------------------------- */
   27332             : 
   27333             : #ifdef __cplusplus
   27334             : extern "C" {
   27335             : #if 0
   27336             : } /* c-mode */
   27337             : #endif
   27338             : #endif
   27339             : 
   27340             : #if 0
   27341             : #define SWIGRUNTIME_DEBUG
   27342             : #endif
   27343             : 
   27344             : 
   27345             : SWIGRUNTIME void
   27346           6 : SWIG_InitializeModule(void *clientdata) {
   27347             :   size_t i;
   27348             :   swig_module_info *module_head, *iter;
   27349             :   int init;
   27350             : 
   27351             :   /* check to see if the circular list has been setup, if not, set it up */
   27352           6 :   if (swig_module.next==0) {
   27353             :     /* Initialize the swig_module */
   27354           6 :     swig_module.type_initial = swig_type_initial;
   27355           6 :     swig_module.cast_initial = swig_cast_initial;
   27356           6 :     swig_module.next = &swig_module;
   27357           6 :     init = 1;
   27358             :   } else {
   27359             :     init = 0;
   27360             :   }
   27361             : 
   27362             :   /* Try and load any already created modules */
   27363           6 :   module_head = SWIG_GetModule(clientdata);
   27364           6 :   if (!module_head) {
   27365             :     /* This is the first module loaded for this interpreter */
   27366             :     /* so set the swig module into the interpreter */
   27367           6 :     SWIG_SetModule(clientdata, &swig_module);
   27368             :   } else {
   27369             :     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
   27370             :     iter=module_head;
   27371             :     do {
   27372           0 :       if (iter==&swig_module) {
   27373             :         /* Our module is already in the list, so there's nothing more to do. */
   27374             :         return;
   27375             :       }
   27376           0 :       iter=iter->next;
   27377           0 :     } while (iter!= module_head);
   27378             : 
   27379             :     /* otherwise we must add our module into the list */
   27380           0 :     swig_module.next = module_head->next;
   27381           0 :     module_head->next = &swig_module;
   27382             :   }
   27383             : 
   27384             :   /* When multiple interpreters are used, a module could have already been initialized in
   27385             :      a different interpreter, but not yet have a pointer in this interpreter.
   27386             :      In this case, we do not want to continue adding types... everything should be
   27387             :      set up already */
   27388           6 :   if (init == 0) return;
   27389             : 
   27390             :   /* Now work on filling in swig_module.types */
   27391             : #ifdef SWIGRUNTIME_DEBUG
   27392             :   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
   27393             : #endif
   27394        1326 :   for (i = 0; i < swig_module.size; ++i) {
   27395         660 :     swig_type_info *type = 0;
   27396             :     swig_type_info *ret;
   27397             :     swig_cast_info *cast;
   27398             : 
   27399             : #ifdef SWIGRUNTIME_DEBUG
   27400             :     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
   27401             : #endif
   27402             : 
   27403             :     /* if there is another module already loaded */
   27404         660 :     if (swig_module.next != &swig_module) {
   27405           0 :       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
   27406             :     }
   27407         660 :     if (type) {
   27408             :       /* Overwrite clientdata field */
   27409             : #ifdef SWIGRUNTIME_DEBUG
   27410             :       printf("SWIG_InitializeModule: found type %s\n", type->name);
   27411             : #endif
   27412           0 :       if (swig_module.type_initial[i]->clientdata) {
   27413           0 :         type->clientdata = swig_module.type_initial[i]->clientdata;
   27414             : #ifdef SWIGRUNTIME_DEBUG
   27415             :       printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
   27416             : #endif
   27417             :       }
   27418             :     } else {
   27419         660 :       type = swig_module.type_initial[i];
   27420             :     }
   27421             : 
   27422             :     /* Insert casting types */
   27423         660 :     cast = swig_module.cast_initial[i];
   27424        2022 :     while (cast->type) {
   27425             : 
   27426             :       /* Don't need to add information already in the list */
   27427        1362 :       ret = 0;
   27428             : #ifdef SWIGRUNTIME_DEBUG
   27429             :       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
   27430             : #endif
   27431        1362 :       if (swig_module.next != &swig_module) {
   27432           0 :         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
   27433             : #ifdef SWIGRUNTIME_DEBUG
   27434             :         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
   27435             : #endif
   27436             :       }
   27437        1362 :       if (ret) {
   27438           0 :         if (type == swig_module.type_initial[i]) {
   27439             : #ifdef SWIGRUNTIME_DEBUG
   27440             :           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
   27441             : #endif
   27442           0 :           cast->type = ret;
   27443           0 :           ret = 0;
   27444             :         } else {
   27445             :           /* Check for casting already in the list */
   27446           0 :           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
   27447             : #ifdef SWIGRUNTIME_DEBUG
   27448             :           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
   27449             : #endif
   27450           0 :           if (!ocast) ret = 0;
   27451             :         }
   27452             :       }
   27453             : 
   27454        1362 :       if (!ret) {
   27455             : #ifdef SWIGRUNTIME_DEBUG
   27456             :         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
   27457             : #endif
   27458        1362 :         if (type->cast) {
   27459         702 :           type->cast->prev = cast;
   27460         702 :           cast->next = type->cast;
   27461             :         }
   27462        1362 :         type->cast = cast;
   27463             :       }
   27464        1362 :       cast++;
   27465             :     }
   27466             :     /* Set entry in modules->types array equal to the type */
   27467         660 :     swig_module.types[i] = type;
   27468             :   }
   27469           6 :   swig_module.types[i] = 0;
   27470             : 
   27471             : #ifdef SWIGRUNTIME_DEBUG
   27472             :   printf("**** SWIG_InitializeModule: Cast List ******\n");
   27473             :   for (i = 0; i < swig_module.size; ++i) {
   27474             :     int j = 0;
   27475             :     swig_cast_info *cast = swig_module.cast_initial[i];
   27476             :     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
   27477             :     while (cast->type) {
   27478             :       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
   27479             :       cast++;
   27480             :       ++j;
   27481             :     }
   27482             :   printf("---- Total casts: %d\n",j);
   27483             :   }
   27484             :   printf("**** SWIG_InitializeModule: Cast List ******\n");
   27485             : #endif
   27486             : }
   27487             : 
   27488             : /* This function will propagate the clientdata field of type to
   27489             : * any new swig_type_info structures that have been added into the list
   27490             : * of equivalent types.  It is like calling
   27491             : * SWIG_TypeClientData(type, clientdata) a second time.
   27492             : */
   27493             : SWIGRUNTIME void
   27494             : SWIG_PropagateClientData(void) {
   27495             :   size_t i;
   27496             :   swig_cast_info *equiv;
   27497             :   static int init_run = 0;
   27498             : 
   27499             :   if (init_run) return;
   27500             :   init_run = 1;
   27501             : 
   27502             :   for (i = 0; i < swig_module.size; i++) {
   27503             :     if (swig_module.types[i]->clientdata) {
   27504             :       equiv = swig_module.types[i]->cast;
   27505             :       while (equiv) {
   27506             :         if (!equiv->converter) {
   27507             :           if (equiv->type && !equiv->type->clientdata)
   27508             :             SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
   27509             :         }
   27510             :         equiv = equiv->next;
   27511             :       }
   27512             :     }
   27513             :   }
   27514             : }
   27515             : 
   27516             : #ifdef __cplusplus
   27517             : #if 0
   27518             : { /* c-mode */
   27519             : #endif
   27520             : }
   27521             : #endif
   27522             : 
   27523             : /*
   27524             : 
   27525             : */
   27526             : #ifdef __cplusplus
   27527             : extern "C"
   27528             : #endif
   27529           6 : SWIGEXPORT void Init__kdbtools(void) {
   27530             :   size_t i;
   27531             :   
   27532           6 :   SWIG_InitRuntime();
   27533           6 :   mKdbtools = rb_define_module("Kdbtools");
   27534             :   
   27535           6 :   SWIG_InitializeModule(0);
   27536         666 :   for (i = 0; i < swig_module.size; i++) {
   27537         660 :     SWIG_define_class(swig_module.types[i]);
   27538             :   }
   27539             :   
   27540           6 :   SWIG_RubyInitializeTrackings();
   27541             :   
   27542           6 :   SwigClassGCVALUE.klass = rb_define_class_under(mKdbtools, "GCVALUE", rb_cObject);
   27543           6 :   SwigClassGCVALUE.mImpl = rb_define_module_under(SwigClassGCVALUE.klass, "Impl");
   27544           6 :   SWIG_TypeClientData(SWIGTYPE_p_swig__GC_VALUE, (void *) &SwigClassGCVALUE);
   27545           6 :   rb_undef_alloc_func(SwigClassGCVALUE.klass);
   27546           6 :   rb_define_method(SwigClassGCVALUE.mImpl, "inspect", VALUEFUNC(_wrap_GCVALUE_inspect), -1);
   27547           6 :   rb_define_method(SwigClassGCVALUE.mImpl, "to_s", VALUEFUNC(_wrap_GCVALUE_to_s), -1);
   27548           6 :   SwigClassGCVALUE.mark = 0;
   27549           6 :   SwigClassGCVALUE.trackObjects = 0;
   27550           6 :   rb_include_module(SwigClassGCVALUE.klass, SwigClassGCVALUE.mImpl);
   27551             :   
   27552           6 :   swig::SwigGCReferences::initialize();
   27553             :   
   27554             :   
   27555           6 :   SwigClassConstIterator.klass = rb_define_class_under(mKdbtools, "ConstIterator", rb_cObject);
   27556           6 :   SwigClassConstIterator.mImpl = rb_define_module_under(SwigClassConstIterator.klass, "Impl");
   27557           6 :   SWIG_TypeClientData(SWIGTYPE_p_swig__ConstIterator, (void *) &SwigClassConstIterator);
   27558           6 :   rb_undef_alloc_func(SwigClassConstIterator.klass);
   27559           6 :   rb_define_method(SwigClassConstIterator.mImpl, "value", VALUEFUNC(_wrap_ConstIterator_value), -1);
   27560           6 :   rb_define_method(SwigClassConstIterator.mImpl, "dup", VALUEFUNC(_wrap_ConstIterator_dup), -1);
   27561           6 :   rb_define_method(SwigClassConstIterator.mImpl, "inspect", VALUEFUNC(_wrap_ConstIterator_inspect), -1);
   27562           6 :   rb_define_method(SwigClassConstIterator.mImpl, "to_s", VALUEFUNC(_wrap_ConstIterator_to_s), -1);
   27563           6 :   rb_define_method(SwigClassConstIterator.mImpl, "next", VALUEFUNC(_wrap_ConstIterator_next), -1);
   27564           6 :   rb_define_method(SwigClassConstIterator.mImpl, "previous", VALUEFUNC(_wrap_ConstIterator_previous), -1);
   27565           6 :   rb_define_method(SwigClassConstIterator.mImpl, "==", VALUEFUNC(_wrap_ConstIterator___eq__), -1);
   27566           6 :   rb_define_method(SwigClassConstIterator.mImpl, "+", VALUEFUNC(_wrap_ConstIterator___add__), -1);
   27567           6 :   rb_define_method(SwigClassConstIterator.mImpl, "-", VALUEFUNC(_wrap_ConstIterator___sub__), -1);
   27568           6 :   SwigClassConstIterator.mark = 0;
   27569           6 :   SwigClassConstIterator.destroy = (void (*)(void *)) free_swig_ConstIterator;
   27570           6 :   SwigClassConstIterator.trackObjects = 0;
   27571           6 :   rb_include_module(SwigClassConstIterator.klass, SwigClassConstIterator.mImpl);
   27572             :   
   27573           6 :   SwigClassIterator.klass = rb_define_class_under(mKdbtools, "Iterator", rb_cObject);
   27574           6 :   SwigClassIterator.mImpl = rb_define_module_under(SwigClassIterator.klass, "Impl");
   27575           6 :   SWIG_TypeClientData(SWIGTYPE_p_swig__Iterator, (void *) &SwigClassIterator);
   27576           6 :   rb_undef_alloc_func(SwigClassIterator.klass);
   27577           6 :   rb_define_method(SwigClassIterator.mImpl, "value=", VALUEFUNC(_wrap_Iterator_valuee___), -1);
   27578           6 :   rb_define_method(SwigClassIterator.mImpl, "dup", VALUEFUNC(_wrap_Iterator_dup), -1);
   27579           6 :   rb_define_method(SwigClassIterator.mImpl, "next", VALUEFUNC(_wrap_Iterator_next), -1);
   27580           6 :   rb_define_method(SwigClassIterator.mImpl, "previous", VALUEFUNC(_wrap_Iterator_previous), -1);
   27581           6 :   rb_define_method(SwigClassIterator.mImpl, "==", VALUEFUNC(_wrap_Iterator___eq__), -1);
   27582           6 :   rb_define_method(SwigClassIterator.mImpl, "+", VALUEFUNC(_wrap_Iterator___add__), -1);
   27583           6 :   rb_define_method(SwigClassIterator.mImpl, "-", VALUEFUNC(_wrap_Iterator___sub__), -1);
   27584           6 :   rb_include_module(SwigClassIterator.mImpl, ((swig_class *) SWIGTYPE_p_swig__ConstIterator->clientdata)->mImpl);
   27585           6 :   SwigClassIterator.mark = 0;
   27586           6 :   SwigClassIterator.destroy = (void (*)(void *)) free_swig_Iterator;
   27587           6 :   SwigClassIterator.trackObjects = 0;
   27588           6 :   rb_include_module(SwigClassIterator.klass, SwigClassIterator.mImpl);
   27589           6 :   rb_define_const(mKdbtools, "SHARED_PTR_DISOWN", SWIG_From_int(static_cast< int >(0)));
   27590             :   
   27591           6 :   SwigClassVectorStr.klass = rb_define_class_under(mKdbtools, "VectorStr", rb_cObject);
   27592           6 :   SwigClassVectorStr.mImpl = rb_define_module_under(SwigClassVectorStr.klass, "Impl");
   27593           6 :   SWIG_TypeClientData(SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, (void *) &SwigClassVectorStr);
   27594           6 :   rb_include_module(SwigClassVectorStr.klass, rb_eval_string("Enumerable"));
   27595           6 :   rb_define_alloc_func(SwigClassVectorStr.klass, _wrap_VectorStr_allocate);
   27596           6 :   rb_define_method(SwigClassVectorStr.klass, "initialize", VALUEFUNC(_wrap_new_VectorStr), -1);
   27597           6 :   rb_define_method(SwigClassVectorStr.mImpl, "dup", VALUEFUNC(_wrap_VectorStr_dup), -1);
   27598           6 :   rb_define_method(SwigClassVectorStr.mImpl, "inspect", VALUEFUNC(_wrap_VectorStr_inspect), -1);
   27599           6 :   rb_define_method(SwigClassVectorStr.mImpl, "to_a", VALUEFUNC(_wrap_VectorStr_to_a), -1);
   27600           6 :   rb_define_method(SwigClassVectorStr.mImpl, "to_s", VALUEFUNC(_wrap_VectorStr_to_s), -1);
   27601           6 :   rb_define_method(SwigClassVectorStr.mImpl, "slice", VALUEFUNC(_wrap_VectorStr_slice), -1);
   27602           6 :   rb_define_method(SwigClassVectorStr.mImpl, "each", VALUEFUNC(_wrap_VectorStr_each), -1);
   27603           6 :   rb_define_method(SwigClassVectorStr.mImpl, "__delete_2__", VALUEFUNC(_wrap_VectorStr___delete_2__), -1);
   27604           6 :   rb_define_method(SwigClassVectorStr.mImpl, "select", VALUEFUNC(_wrap_VectorStr_select), -1);
   27605           6 :   rb_define_method(SwigClassVectorStr.mImpl, "delete_at", VALUEFUNC(_wrap_VectorStr_delete_at), -1);
   27606           6 :   rb_define_method(SwigClassVectorStr.mImpl, "at", VALUEFUNC(_wrap_VectorStr_at), -1);
   27607           6 :   rb_define_method(SwigClassVectorStr.mImpl, "[]", VALUEFUNC(_wrap_VectorStr___getitem__), -1);
   27608           6 :   rb_define_method(SwigClassVectorStr.mImpl, "[]=", VALUEFUNC(_wrap_VectorStr___setitem__), -1);
   27609           6 :   rb_define_method(SwigClassVectorStr.mImpl, "reject_bang", VALUEFUNC(_wrap_VectorStr_reject_bang), -1);
   27610           6 :   rb_define_alias(SwigClassVectorStr.mImpl, "delete_if", "reject_bang");
   27611           6 :   rb_define_method(SwigClassVectorStr.mImpl, "pop", VALUEFUNC(_wrap_VectorStr_pop), -1);
   27612           6 :   rb_define_method(SwigClassVectorStr.mImpl, "push", VALUEFUNC(_wrap_VectorStr_push), -1);
   27613           6 :   rb_define_alias(SwigClassVectorStr.mImpl, "<<", "push");
   27614           6 :   rb_define_method(SwigClassVectorStr.mImpl, "reject", VALUEFUNC(_wrap_VectorStr_reject), -1);
   27615           6 :   rb_define_method(SwigClassVectorStr.mImpl, "shift", VALUEFUNC(_wrap_VectorStr_shift), -1);
   27616           6 :   rb_define_method(SwigClassVectorStr.mImpl, "insert", VALUEFUNC(_wrap_VectorStr_insert), -1);
   27617           6 :   rb_define_method(SwigClassVectorStr.mImpl, "unshift", VALUEFUNC(_wrap_VectorStr_unshift), -1);
   27618           6 :   rb_define_method(SwigClassVectorStr.mImpl, "empty", VALUEFUNC(_wrap_VectorStr_empty), -1);
   27619           6 :   rb_define_method(SwigClassVectorStr.mImpl, "size", VALUEFUNC(_wrap_VectorStr_size), -1);
   27620           6 :   rb_define_method(SwigClassVectorStr.mImpl, "swap", VALUEFUNC(_wrap_VectorStr_swap), -1);
   27621           6 :   rb_define_method(SwigClassVectorStr.mImpl, "clear", VALUEFUNC(_wrap_VectorStr_clear), -1);
   27622           6 :   rb_define_method(SwigClassVectorStr.mImpl, "get_allocator", VALUEFUNC(_wrap_VectorStr_get_allocator), -1);
   27623           6 :   rb_define_method(SwigClassVectorStr.mImpl, "front", VALUEFUNC(_wrap_VectorStr_front), -1);
   27624           6 :   rb_define_method(SwigClassVectorStr.mImpl, "back", VALUEFUNC(_wrap_VectorStr_back), -1);
   27625           6 :   rb_define_method(SwigClassVectorStr.mImpl, "assign", VALUEFUNC(_wrap_VectorStr_assign), -1);
   27626           6 :   rb_define_method(SwigClassVectorStr.mImpl, "resize", VALUEFUNC(_wrap_VectorStr_resize), -1);
   27627           6 :   rb_define_method(SwigClassVectorStr.mImpl, "reserve", VALUEFUNC(_wrap_VectorStr_reserve), -1);
   27628           6 :   rb_define_method(SwigClassVectorStr.mImpl, "capacity", VALUEFUNC(_wrap_VectorStr_capacity), -1);
   27629           6 :   rb_define_method(SwigClassVectorStr.mImpl, "map_bang", VALUEFUNC(_wrap_VectorStr_map_bang), -1);
   27630           6 :   rb_define_method(SwigClassVectorStr.mImpl, "__delete__", VALUEFUNC(_wrap_VectorStr___delete__), -1);
   27631           6 :   SwigClassVectorStr.mark = 0;
   27632           6 :   SwigClassVectorStr.destroy = (void (*)(void *)) free_std_vector_Sl_std_string_Sg_;
   27633           6 :   SwigClassVectorStr.trackObjects = 0;
   27634           6 :   rb_include_module(SwigClassVectorStr.klass, SwigClassVectorStr.mImpl);
   27635           6 :   rb_require("kdb");
   27636             :   
   27637             :   /* correct SWIG type <-> Ruby class mapping
   27638             :      *
   27639             :      * SWIG creates in the first step, for each known class to map
   27640             :      * a Ruby class under module SWIG, named
   27641             :      *   'TYPE_p_<cpp-namespace><cpp-class-name>'
   27642             :      * I'm not really sure about its purpose, maybe a fallback?
   27643             :      * In the second step, SWIG creates all its 'real' Ruby classes
   27644             :      * under the defined module and updates its type map records, to
   27645             :      * store this 'real' class (Ruby klass VALUE).
   27646             :      *
   27647             :      * The function SWIG_Ruby_NewPointerObj(), given a type_info struct
   27648             :      * lookups the corresponding type table entry to fetch the 'real'
   27649             :      * klass Object created earlier. If no such klass Object is found for
   27650             :      * the corresponding type_info, the fallback klass under SWIG module
   27651             :      * is used.
   27652             :      *
   27653             :      * So far so good, but: The %import kdb.i lets swig know about the
   27654             :      * kdb::Key and kdb::KeySet types and creates entries in SWIGs type
   27655             :      * table. However, these type table entries arn't never filled up
   27656             :      * (more correctly the client data). So for our imported stuff from
   27657             :      * 'kdb.i' we will end up with getting these fake
   27658             :      * 'SWIG::TYPE_p_kdb__KeyXXX' klasses but not with our real
   27659             :      * 'Kdb::KeyXXX' klasses.
   27660             :      *
   27661             :      * Until now, if not seen any better method of correcting this myself
   27662             :      * by hand. So here we get our real 'Kdb::*' klasses and update the
   27663             :      * fallback mechanism (the SWIG modules constants).
   27664             :      *
   27665             :      * I've filed an issue at https://github.com/swig/swig/issues/903
   27666             :      */
   27667           6 :   VALUE my_mKdb = Qnil;
   27668           6 :   VALUE my_kKey = Qnil;
   27669           6 :   VALUE my_kKeySet = Qnil;
   27670             :   
   27671             :   /* get the Kdb module and its classes (they already exist, so they
   27672             :      * aren't recreated) */
   27673           6 :   my_mKdb = rb_define_module("Kdb");
   27674           6 :   my_kKey = rb_define_class_under(my_mKdb, "Key", rb_cObject);
   27675           6 :   my_kKeySet = rb_define_class_under(my_mKdb, "KeySet", rb_cObject);
   27676             :   
   27677             :   /* SWIG (also Ruby?) uses these constants to fetch the Ruby class
   27678             :      * object, so we simply have to reinitialize these constants */
   27679             :   /* do a remove first to avoid "const already set" warning */
   27680           6 :   rb_const_remove(_mSWIG, rb_intern("TYPE_p_kdb__Key"));
   27681           6 :   rb_const_set(_mSWIG, rb_intern("TYPE_p_kdb__Key"), my_kKey);
   27682           6 :   rb_const_remove(_mSWIG, rb_intern("TYPE_p_kdb__KeySet"));
   27683           6 :   rb_const_set(_mSWIG, rb_intern("TYPE_p_kdb__KeySet"), my_kKeySet);
   27684             :   
   27685             :   
   27686           6 :   SwigClassToolException.klass = rb_define_class_under(mKdbtools, "ToolException", rb_eRuntimeError);
   27687           6 :   SwigClassToolException.mImpl = rb_define_module_under(SwigClassToolException.klass, "Impl");
   27688           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__ToolException, (void *) &SwigClassToolException);
   27689           6 :   rb_define_alloc_func(SwigClassToolException.klass, _wrap_ToolException_allocate);
   27690           6 :   rb_define_method(SwigClassToolException.klass, "initialize", VALUEFUNC(_wrap_new_ToolException), -1);
   27691           6 :   SwigClassToolException.mark = 0;
   27692           6 :   SwigClassToolException.destroy = (void (*)(void *)) free_kdb_tools_ToolException;
   27693           6 :   SwigClassToolException.trackObjects = 0;
   27694           6 :   rb_include_module(SwigClassToolException.klass, SwigClassToolException.mImpl);
   27695             :   
   27696           6 :   SwigClassParseException.klass = rb_define_class_under(mKdbtools, "ParseException", rb_eRuntimeError);
   27697           6 :   SwigClassParseException.mImpl = rb_define_module_under(SwigClassParseException.klass, "Impl");
   27698           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__ParseException, (void *) &SwigClassParseException);
   27699           6 :   rb_define_alloc_func(SwigClassParseException.klass, _wrap_ParseException_allocate);
   27700           6 :   rb_define_method(SwigClassParseException.klass, "initialize", VALUEFUNC(_wrap_new_ParseException), -1);
   27701           6 :   rb_define_method(SwigClassParseException.mImpl, "to_s", VALUEFUNC(_wrap_ParseException_to_s), -1);
   27702           6 :   rb_define_method(SwigClassParseException.mImpl, "m_str=", VALUEFUNC(_wrap_ParseException_m_str_set), -1);
   27703           6 :   rb_define_method(SwigClassParseException.mImpl, "m_str", VALUEFUNC(_wrap_ParseException_m_str_get), -1);
   27704           6 :   rb_include_module(SwigClassParseException.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__ToolException->clientdata)->mImpl);
   27705           6 :   SwigClassParseException.mark = 0;
   27706           6 :   SwigClassParseException.destroy = (void (*)(void *)) free_kdb_tools_ParseException;
   27707           6 :   SwigClassParseException.trackObjects = 0;
   27708           6 :   rb_include_module(SwigClassParseException.klass, SwigClassParseException.mImpl);
   27709             :   
   27710           6 :   SwigClassPluginCheckException.klass = rb_define_class_under(mKdbtools, "PluginCheckException", rb_eRuntimeError);
   27711           6 :   SwigClassPluginCheckException.mImpl = rb_define_module_under(SwigClassPluginCheckException.klass, "Impl");
   27712           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__PluginCheckException, (void *) &SwigClassPluginCheckException);
   27713           6 :   rb_define_alloc_func(SwigClassPluginCheckException.klass, _wrap_PluginCheckException_allocate);
   27714           6 :   rb_define_method(SwigClassPluginCheckException.klass, "initialize", VALUEFUNC(_wrap_new_PluginCheckException), -1);
   27715           6 :   rb_define_method(SwigClassPluginCheckException.mImpl, "to_s", VALUEFUNC(_wrap_PluginCheckException_to_s), -1);
   27716           6 :   rb_include_module(SwigClassPluginCheckException.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__ToolException->clientdata)->mImpl);
   27717           6 :   SwigClassPluginCheckException.mark = 0;
   27718           6 :   SwigClassPluginCheckException.destroy = (void (*)(void *)) free_kdb_tools_PluginCheckException;
   27719           6 :   SwigClassPluginCheckException.trackObjects = 0;
   27720           6 :   rb_include_module(SwigClassPluginCheckException.klass, SwigClassPluginCheckException.mImpl);
   27721             :   
   27722           6 :   SwigClassBackendCheckException.klass = rb_define_class_under(mKdbtools, "BackendCheckException", rb_eRuntimeError);
   27723           6 :   SwigClassBackendCheckException.mImpl = rb_define_module_under(SwigClassBackendCheckException.klass, "Impl");
   27724           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__BackendCheckException, (void *) &SwigClassBackendCheckException);
   27725           6 :   rb_define_alloc_func(SwigClassBackendCheckException.klass, _wrap_BackendCheckException_allocate);
   27726           6 :   rb_define_method(SwigClassBackendCheckException.klass, "initialize", VALUEFUNC(_wrap_new_BackendCheckException), -1);
   27727           6 :   rb_define_method(SwigClassBackendCheckException.mImpl, "to_s", VALUEFUNC(_wrap_BackendCheckException_to_s), -1);
   27728           6 :   rb_include_module(SwigClassBackendCheckException.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__ToolException->clientdata)->mImpl);
   27729           6 :   SwigClassBackendCheckException.mark = 0;
   27730           6 :   SwigClassBackendCheckException.destroy = (void (*)(void *)) free_kdb_tools_BackendCheckException;
   27731           6 :   SwigClassBackendCheckException.trackObjects = 0;
   27732           6 :   rb_include_module(SwigClassBackendCheckException.klass, SwigClassBackendCheckException.mImpl);
   27733             :   
   27734           6 :   SwigClassFileNotValidException.klass = rb_define_class_under(mKdbtools, "FileNotValidException", rb_eRuntimeError);
   27735           6 :   SwigClassFileNotValidException.mImpl = rb_define_module_under(SwigClassFileNotValidException.klass, "Impl");
   27736           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__FileNotValidException, (void *) &SwigClassFileNotValidException);
   27737           6 :   rb_define_alloc_func(SwigClassFileNotValidException.klass, _wrap_FileNotValidException_allocate);
   27738           6 :   rb_define_method(SwigClassFileNotValidException.klass, "initialize", VALUEFUNC(_wrap_new_FileNotValidException), -1);
   27739           6 :   rb_include_module(SwigClassFileNotValidException.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__BackendCheckException->clientdata)->mImpl);
   27740           6 :   SwigClassFileNotValidException.mark = 0;
   27741           6 :   SwigClassFileNotValidException.destroy = (void (*)(void *)) free_kdb_tools_FileNotValidException;
   27742           6 :   SwigClassFileNotValidException.trackObjects = 0;
   27743           6 :   rb_include_module(SwigClassFileNotValidException.klass, SwigClassFileNotValidException.mImpl);
   27744             :   
   27745           6 :   SwigClassMountpointInvalidException.klass = rb_define_class_under(mKdbtools, "MountpointInvalidException", rb_eRuntimeError);
   27746           6 :   SwigClassMountpointInvalidException.mImpl = rb_define_module_under(SwigClassMountpointInvalidException.klass, "Impl");
   27747           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__MountpointInvalidException, (void *) &SwigClassMountpointInvalidException);
   27748           6 :   rb_define_alloc_func(SwigClassMountpointInvalidException.klass, _wrap_MountpointInvalidException_allocate);
   27749           6 :   rb_define_method(SwigClassMountpointInvalidException.klass, "initialize", VALUEFUNC(_wrap_new_MountpointInvalidException), -1);
   27750           6 :   rb_include_module(SwigClassMountpointInvalidException.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__BackendCheckException->clientdata)->mImpl);
   27751           6 :   SwigClassMountpointInvalidException.mark = 0;
   27752           6 :   SwigClassMountpointInvalidException.destroy = (void (*)(void *)) free_kdb_tools_MountpointInvalidException;
   27753           6 :   SwigClassMountpointInvalidException.trackObjects = 0;
   27754           6 :   rb_include_module(SwigClassMountpointInvalidException.klass, SwigClassMountpointInvalidException.mImpl);
   27755             :   
   27756           6 :   SwigClassMountpointAlreadyInUseException.klass = rb_define_class_under(mKdbtools, "MountpointAlreadyInUseException", rb_eRuntimeError);
   27757           6 :   SwigClassMountpointAlreadyInUseException.mImpl = rb_define_module_under(SwigClassMountpointAlreadyInUseException.klass, "Impl");
   27758           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__MountpointAlreadyInUseException, (void *) &SwigClassMountpointAlreadyInUseException);
   27759           6 :   rb_define_alloc_func(SwigClassMountpointAlreadyInUseException.klass, _wrap_MountpointAlreadyInUseException_allocate);
   27760           6 :   rb_define_method(SwigClassMountpointAlreadyInUseException.klass, "initialize", VALUEFUNC(_wrap_new_MountpointAlreadyInUseException), -1);
   27761           6 :   rb_define_method(SwigClassMountpointAlreadyInUseException.mImpl, "m_str=", VALUEFUNC(_wrap_MountpointAlreadyInUseException_m_str_set), -1);
   27762           6 :   rb_define_method(SwigClassMountpointAlreadyInUseException.mImpl, "m_str", VALUEFUNC(_wrap_MountpointAlreadyInUseException_m_str_get), -1);
   27763           6 :   rb_include_module(SwigClassMountpointAlreadyInUseException.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__BackendCheckException->clientdata)->mImpl);
   27764           6 :   SwigClassMountpointAlreadyInUseException.mark = 0;
   27765           6 :   SwigClassMountpointAlreadyInUseException.destroy = (void (*)(void *)) free_kdb_tools_MountpointAlreadyInUseException;
   27766           6 :   SwigClassMountpointAlreadyInUseException.trackObjects = 0;
   27767           6 :   rb_include_module(SwigClassMountpointAlreadyInUseException.klass, SwigClassMountpointAlreadyInUseException.mImpl);
   27768             :   
   27769           6 :   SwigClassNoSuchBackend.klass = rb_define_class_under(mKdbtools, "NoSuchBackend", rb_eRuntimeError);
   27770           6 :   SwigClassNoSuchBackend.mImpl = rb_define_module_under(SwigClassNoSuchBackend.klass, "Impl");
   27771           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__NoSuchBackend, (void *) &SwigClassNoSuchBackend);
   27772           6 :   rb_define_alloc_func(SwigClassNoSuchBackend.klass, _wrap_NoSuchBackend_allocate);
   27773           6 :   rb_define_method(SwigClassNoSuchBackend.klass, "initialize", VALUEFUNC(_wrap_new_NoSuchBackend), -1);
   27774           6 :   rb_include_module(SwigClassNoSuchBackend.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__BackendCheckException->clientdata)->mImpl);
   27775           6 :   SwigClassNoSuchBackend.mark = 0;
   27776           6 :   SwigClassNoSuchBackend.destroy = (void (*)(void *)) free_kdb_tools_NoSuchBackend;
   27777           6 :   SwigClassNoSuchBackend.trackObjects = 0;
   27778           6 :   rb_include_module(SwigClassNoSuchBackend.klass, SwigClassNoSuchBackend.mImpl);
   27779             :   
   27780           6 :   SwigClassPluginAlreadyInserted.klass = rb_define_class_under(mKdbtools, "PluginAlreadyInserted", rb_eRuntimeError);
   27781           6 :   SwigClassPluginAlreadyInserted.mImpl = rb_define_module_under(SwigClassPluginAlreadyInserted.klass, "Impl");
   27782           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__PluginAlreadyInserted, (void *) &SwigClassPluginAlreadyInserted);
   27783           6 :   rb_define_alloc_func(SwigClassPluginAlreadyInserted.klass, _wrap_PluginAlreadyInserted_allocate);
   27784           6 :   rb_define_method(SwigClassPluginAlreadyInserted.klass, "initialize", VALUEFUNC(_wrap_new_PluginAlreadyInserted), -1);
   27785           6 :   rb_define_method(SwigClassPluginAlreadyInserted.mImpl, "m_str=", VALUEFUNC(_wrap_PluginAlreadyInserted_m_str_set), -1);
   27786           6 :   rb_define_method(SwigClassPluginAlreadyInserted.mImpl, "m_str", VALUEFUNC(_wrap_PluginAlreadyInserted_m_str_get), -1);
   27787           6 :   rb_include_module(SwigClassPluginAlreadyInserted.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27788           6 :   SwigClassPluginAlreadyInserted.mark = 0;
   27789           6 :   SwigClassPluginAlreadyInserted.destroy = (void (*)(void *)) free_kdb_tools_PluginAlreadyInserted;
   27790           6 :   SwigClassPluginAlreadyInserted.trackObjects = 0;
   27791           6 :   rb_include_module(SwigClassPluginAlreadyInserted.klass, SwigClassPluginAlreadyInserted.mImpl);
   27792             :   
   27793           6 :   SwigClassPluginConfigInvalid.klass = rb_define_class_under(mKdbtools, "PluginConfigInvalid", rb_eRuntimeError);
   27794           6 :   SwigClassPluginConfigInvalid.mImpl = rb_define_module_under(SwigClassPluginConfigInvalid.klass, "Impl");
   27795           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__PluginConfigInvalid, (void *) &SwigClassPluginConfigInvalid);
   27796           6 :   rb_define_alloc_func(SwigClassPluginConfigInvalid.klass, _wrap_PluginConfigInvalid_allocate);
   27797           6 :   rb_define_method(SwigClassPluginConfigInvalid.klass, "initialize", VALUEFUNC(_wrap_new_PluginConfigInvalid), -1);
   27798           6 :   rb_include_module(SwigClassPluginConfigInvalid.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27799           6 :   SwigClassPluginConfigInvalid.mark = 0;
   27800           6 :   SwigClassPluginConfigInvalid.destroy = (void (*)(void *)) free_kdb_tools_PluginConfigInvalid;
   27801           6 :   SwigClassPluginConfigInvalid.trackObjects = 0;
   27802           6 :   rb_include_module(SwigClassPluginConfigInvalid.klass, SwigClassPluginConfigInvalid.mImpl);
   27803             :   
   27804           6 :   SwigClassBadPluginName.klass = rb_define_class_under(mKdbtools, "BadPluginName", rb_eRuntimeError);
   27805           6 :   SwigClassBadPluginName.mImpl = rb_define_module_under(SwigClassBadPluginName.klass, "Impl");
   27806           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__BadPluginName, (void *) &SwigClassBadPluginName);
   27807           6 :   rb_define_alloc_func(SwigClassBadPluginName.klass, _wrap_BadPluginName_allocate);
   27808           6 :   rb_define_method(SwigClassBadPluginName.klass, "initialize", VALUEFUNC(_wrap_new_BadPluginName), -1);
   27809           6 :   rb_define_method(SwigClassBadPluginName.mImpl, "m_str=", VALUEFUNC(_wrap_BadPluginName_m_str_set), -1);
   27810           6 :   rb_define_method(SwigClassBadPluginName.mImpl, "m_str", VALUEFUNC(_wrap_BadPluginName_m_str_get), -1);
   27811           6 :   rb_include_module(SwigClassBadPluginName.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27812           6 :   SwigClassBadPluginName.mark = 0;
   27813           6 :   SwigClassBadPluginName.destroy = (void (*)(void *)) free_kdb_tools_BadPluginName;
   27814           6 :   SwigClassBadPluginName.trackObjects = 0;
   27815           6 :   rb_include_module(SwigClassBadPluginName.klass, SwigClassBadPluginName.mImpl);
   27816             :   
   27817           6 :   SwigClassTooManyPlugins.klass = rb_define_class_under(mKdbtools, "TooManyPlugins", rb_eRuntimeError);
   27818           6 :   SwigClassTooManyPlugins.mImpl = rb_define_module_under(SwigClassTooManyPlugins.klass, "Impl");
   27819           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__TooManyPlugins, (void *) &SwigClassTooManyPlugins);
   27820           6 :   rb_define_alloc_func(SwigClassTooManyPlugins.klass, _wrap_TooManyPlugins_allocate);
   27821           6 :   rb_define_method(SwigClassTooManyPlugins.klass, "initialize", VALUEFUNC(_wrap_new_TooManyPlugins), -1);
   27822           6 :   rb_define_method(SwigClassTooManyPlugins.mImpl, "m_str=", VALUEFUNC(_wrap_TooManyPlugins_m_str_set), -1);
   27823           6 :   rb_define_method(SwigClassTooManyPlugins.mImpl, "m_str", VALUEFUNC(_wrap_TooManyPlugins_m_str_get), -1);
   27824           6 :   rb_include_module(SwigClassTooManyPlugins.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27825           6 :   SwigClassTooManyPlugins.mark = 0;
   27826           6 :   SwigClassTooManyPlugins.destroy = (void (*)(void *)) free_kdb_tools_TooManyPlugins;
   27827           6 :   SwigClassTooManyPlugins.trackObjects = 0;
   27828           6 :   rb_include_module(SwigClassTooManyPlugins.klass, SwigClassTooManyPlugins.mImpl);
   27829             :   
   27830           6 :   SwigClassOrderingViolation.klass = rb_define_class_under(mKdbtools, "OrderingViolation", rb_eRuntimeError);
   27831           6 :   SwigClassOrderingViolation.mImpl = rb_define_module_under(SwigClassOrderingViolation.klass, "Impl");
   27832           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__OrderingViolation, (void *) &SwigClassOrderingViolation);
   27833           6 :   rb_define_alloc_func(SwigClassOrderingViolation.klass, _wrap_OrderingViolation_allocate);
   27834           6 :   rb_define_method(SwigClassOrderingViolation.klass, "initialize", VALUEFUNC(_wrap_new_OrderingViolation), -1);
   27835           6 :   rb_include_module(SwigClassOrderingViolation.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27836           6 :   SwigClassOrderingViolation.mark = 0;
   27837           6 :   SwigClassOrderingViolation.destroy = (void (*)(void *)) free_kdb_tools_OrderingViolation;
   27838           6 :   SwigClassOrderingViolation.trackObjects = 0;
   27839           6 :   rb_include_module(SwigClassOrderingViolation.klass, SwigClassOrderingViolation.mImpl);
   27840             :   
   27841           6 :   SwigClassCyclicOrderingViolation.klass = rb_define_class_under(mKdbtools, "CyclicOrderingViolation", rb_eRuntimeError);
   27842           6 :   SwigClassCyclicOrderingViolation.mImpl = rb_define_module_under(SwigClassCyclicOrderingViolation.klass, "Impl");
   27843           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__CyclicOrderingViolation, (void *) &SwigClassCyclicOrderingViolation);
   27844           6 :   rb_define_alloc_func(SwigClassCyclicOrderingViolation.klass, _wrap_CyclicOrderingViolation_allocate);
   27845           6 :   rb_define_method(SwigClassCyclicOrderingViolation.klass, "initialize", VALUEFUNC(_wrap_new_CyclicOrderingViolation), -1);
   27846           6 :   rb_include_module(SwigClassCyclicOrderingViolation.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__OrderingViolation->clientdata)->mImpl);
   27847           6 :   SwigClassCyclicOrderingViolation.mark = 0;
   27848           6 :   SwigClassCyclicOrderingViolation.destroy = (void (*)(void *)) free_kdb_tools_CyclicOrderingViolation;
   27849           6 :   SwigClassCyclicOrderingViolation.trackObjects = 0;
   27850           6 :   rb_include_module(SwigClassCyclicOrderingViolation.klass, SwigClassCyclicOrderingViolation.mImpl);
   27851             :   
   27852           6 :   SwigClassConflictViolation.klass = rb_define_class_under(mKdbtools, "ConflictViolation", rb_eRuntimeError);
   27853           6 :   SwigClassConflictViolation.mImpl = rb_define_module_under(SwigClassConflictViolation.klass, "Impl");
   27854           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__ConflictViolation, (void *) &SwigClassConflictViolation);
   27855           6 :   rb_define_alloc_func(SwigClassConflictViolation.klass, _wrap_ConflictViolation_allocate);
   27856           6 :   rb_define_method(SwigClassConflictViolation.klass, "initialize", VALUEFUNC(_wrap_new_ConflictViolation), -1);
   27857           6 :   rb_include_module(SwigClassConflictViolation.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27858           6 :   SwigClassConflictViolation.mark = 0;
   27859           6 :   SwigClassConflictViolation.destroy = (void (*)(void *)) free_kdb_tools_ConflictViolation;
   27860           6 :   SwigClassConflictViolation.trackObjects = 0;
   27861           6 :   rb_include_module(SwigClassConflictViolation.klass, SwigClassConflictViolation.mImpl);
   27862             :   
   27863           6 :   SwigClassNoPlugin.klass = rb_define_class_under(mKdbtools, "NoPlugin", rb_eRuntimeError);
   27864           6 :   SwigClassNoPlugin.mImpl = rb_define_module_under(SwigClassNoPlugin.klass, "Impl");
   27865           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__NoPlugin, (void *) &SwigClassNoPlugin);
   27866           6 :   rb_define_alloc_func(SwigClassNoPlugin.klass, _wrap_NoPlugin_allocate);
   27867           6 :   rb_define_method(SwigClassNoPlugin.klass, "initialize", VALUEFUNC(_wrap_new_NoPlugin), -1);
   27868           6 :   rb_include_module(SwigClassNoPlugin.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27869           6 :   SwigClassNoPlugin.mark = 0;
   27870           6 :   SwigClassNoPlugin.destroy = (void (*)(void *)) free_kdb_tools_NoPlugin;
   27871           6 :   SwigClassNoPlugin.trackObjects = 0;
   27872           6 :   rb_include_module(SwigClassNoPlugin.klass, SwigClassNoPlugin.mImpl);
   27873             :   
   27874           6 :   SwigClassReferenceNotFound.klass = rb_define_class_under(mKdbtools, "ReferenceNotFound", rb_eRuntimeError);
   27875           6 :   SwigClassReferenceNotFound.mImpl = rb_define_module_under(SwigClassReferenceNotFound.klass, "Impl");
   27876           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__ReferenceNotFound, (void *) &SwigClassReferenceNotFound);
   27877           6 :   rb_define_alloc_func(SwigClassReferenceNotFound.klass, _wrap_ReferenceNotFound_allocate);
   27878           6 :   rb_define_method(SwigClassReferenceNotFound.klass, "initialize", VALUEFUNC(_wrap_new_ReferenceNotFound), -1);
   27879           6 :   rb_include_module(SwigClassReferenceNotFound.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27880           6 :   SwigClassReferenceNotFound.mark = 0;
   27881           6 :   SwigClassReferenceNotFound.destroy = (void (*)(void *)) free_kdb_tools_ReferenceNotFound;
   27882           6 :   SwigClassReferenceNotFound.trackObjects = 0;
   27883           6 :   rb_include_module(SwigClassReferenceNotFound.klass, SwigClassReferenceNotFound.mImpl);
   27884             :   
   27885           6 :   SwigClassMissingNeeded.klass = rb_define_class_under(mKdbtools, "MissingNeeded", rb_eRuntimeError);
   27886           6 :   SwigClassMissingNeeded.mImpl = rb_define_module_under(SwigClassMissingNeeded.klass, "Impl");
   27887           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__MissingNeeded, (void *) &SwigClassMissingNeeded);
   27888           6 :   rb_define_alloc_func(SwigClassMissingNeeded.klass, _wrap_MissingNeeded_allocate);
   27889           6 :   rb_define_method(SwigClassMissingNeeded.klass, "initialize", VALUEFUNC(_wrap_new_MissingNeeded), -1);
   27890           6 :   rb_define_method(SwigClassMissingNeeded.mImpl, "msg=", VALUEFUNC(_wrap_MissingNeeded_msg_set), -1);
   27891           6 :   rb_define_method(SwigClassMissingNeeded.mImpl, "msg", VALUEFUNC(_wrap_MissingNeeded_msg_get), -1);
   27892           6 :   rb_include_module(SwigClassMissingNeeded.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27893           6 :   SwigClassMissingNeeded.mark = 0;
   27894           6 :   SwigClassMissingNeeded.destroy = (void (*)(void *)) free_kdb_tools_MissingNeeded;
   27895           6 :   SwigClassMissingNeeded.trackObjects = 0;
   27896           6 :   rb_include_module(SwigClassMissingNeeded.klass, SwigClassMissingNeeded.mImpl);
   27897             :   
   27898           6 :   SwigClassMissingSymbol.klass = rb_define_class_under(mKdbtools, "MissingSymbol", rb_eRuntimeError);
   27899           6 :   SwigClassMissingSymbol.mImpl = rb_define_module_under(SwigClassMissingSymbol.klass, "Impl");
   27900           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__MissingSymbol, (void *) &SwigClassMissingSymbol);
   27901           6 :   rb_define_alloc_func(SwigClassMissingSymbol.klass, _wrap_MissingSymbol_allocate);
   27902           6 :   rb_define_method(SwigClassMissingSymbol.klass, "initialize", VALUEFUNC(_wrap_new_MissingSymbol), -1);
   27903           6 :   rb_define_method(SwigClassMissingSymbol.mImpl, "msg=", VALUEFUNC(_wrap_MissingSymbol_msg_set), -1);
   27904           6 :   rb_define_method(SwigClassMissingSymbol.mImpl, "msg", VALUEFUNC(_wrap_MissingSymbol_msg_get), -1);
   27905           6 :   rb_include_module(SwigClassMissingSymbol.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27906           6 :   SwigClassMissingSymbol.mark = 0;
   27907           6 :   SwigClassMissingSymbol.destroy = (void (*)(void *)) free_kdb_tools_MissingSymbol;
   27908           6 :   SwigClassMissingSymbol.trackObjects = 0;
   27909           6 :   rb_include_module(SwigClassMissingSymbol.klass, SwigClassMissingSymbol.mImpl);
   27910             :   
   27911           6 :   SwigClassWrongStatus.klass = rb_define_class_under(mKdbtools, "WrongStatus", rb_eRuntimeError);
   27912           6 :   SwigClassWrongStatus.mImpl = rb_define_module_under(SwigClassWrongStatus.klass, "Impl");
   27913           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__WrongStatus, (void *) &SwigClassWrongStatus);
   27914           6 :   rb_define_alloc_func(SwigClassWrongStatus.klass, _wrap_WrongStatus_allocate);
   27915           6 :   rb_define_method(SwigClassWrongStatus.klass, "initialize", VALUEFUNC(_wrap_new_WrongStatus), -1);
   27916           6 :   rb_define_method(SwigClassWrongStatus.mImpl, "msg=", VALUEFUNC(_wrap_WrongStatus_msg_set), -1);
   27917           6 :   rb_define_method(SwigClassWrongStatus.mImpl, "msg", VALUEFUNC(_wrap_WrongStatus_msg_get), -1);
   27918           6 :   rb_include_module(SwigClassWrongStatus.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27919           6 :   SwigClassWrongStatus.mark = 0;
   27920           6 :   SwigClassWrongStatus.destroy = (void (*)(void *)) free_kdb_tools_WrongStatus;
   27921           6 :   SwigClassWrongStatus.trackObjects = 0;
   27922           6 :   rb_include_module(SwigClassWrongStatus.klass, SwigClassWrongStatus.mImpl);
   27923             :   
   27924           6 :   SwigClassSymbolMismatch.klass = rb_define_class_under(mKdbtools, "SymbolMismatch", rb_eRuntimeError);
   27925           6 :   SwigClassSymbolMismatch.mImpl = rb_define_module_under(SwigClassSymbolMismatch.klass, "Impl");
   27926           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__SymbolMismatch, (void *) &SwigClassSymbolMismatch);
   27927           6 :   rb_define_alloc_func(SwigClassSymbolMismatch.klass, _wrap_SymbolMismatch_allocate);
   27928           6 :   rb_define_method(SwigClassSymbolMismatch.klass, "initialize", VALUEFUNC(_wrap_new_SymbolMismatch), -1);
   27929           6 :   rb_define_method(SwigClassSymbolMismatch.mImpl, "msg=", VALUEFUNC(_wrap_SymbolMismatch_msg_set), -1);
   27930           6 :   rb_define_method(SwigClassSymbolMismatch.mImpl, "msg", VALUEFUNC(_wrap_SymbolMismatch_msg_get), -1);
   27931           6 :   rb_include_module(SwigClassSymbolMismatch.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27932           6 :   SwigClassSymbolMismatch.mark = 0;
   27933           6 :   SwigClassSymbolMismatch.destroy = (void (*)(void *)) free_kdb_tools_SymbolMismatch;
   27934           6 :   SwigClassSymbolMismatch.trackObjects = 0;
   27935           6 :   rb_include_module(SwigClassSymbolMismatch.klass, SwigClassSymbolMismatch.mImpl);
   27936             :   
   27937           6 :   SwigClassNoGlobalPlugin.klass = rb_define_class_under(mKdbtools, "NoGlobalPlugin", rb_eRuntimeError);
   27938           6 :   SwigClassNoGlobalPlugin.mImpl = rb_define_module_under(SwigClassNoGlobalPlugin.klass, "Impl");
   27939           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__NoGlobalPlugin, (void *) &SwigClassNoGlobalPlugin);
   27940           6 :   rb_define_alloc_func(SwigClassNoGlobalPlugin.klass, _wrap_NoGlobalPlugin_allocate);
   27941           6 :   rb_define_method(SwigClassNoGlobalPlugin.klass, "initialize", VALUEFUNC(_wrap_new_NoGlobalPlugin), -1);
   27942           6 :   rb_define_method(SwigClassNoGlobalPlugin.mImpl, "msg=", VALUEFUNC(_wrap_NoGlobalPlugin_msg_set), -1);
   27943           6 :   rb_define_method(SwigClassNoGlobalPlugin.mImpl, "msg", VALUEFUNC(_wrap_NoGlobalPlugin_msg_get), -1);
   27944           6 :   rb_include_module(SwigClassNoGlobalPlugin.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27945           6 :   SwigClassNoGlobalPlugin.mark = 0;
   27946           6 :   SwigClassNoGlobalPlugin.destroy = (void (*)(void *)) free_kdb_tools_NoGlobalPlugin;
   27947           6 :   SwigClassNoGlobalPlugin.trackObjects = 0;
   27948           6 :   rb_include_module(SwigClassNoGlobalPlugin.klass, SwigClassNoGlobalPlugin.mImpl);
   27949             :   
   27950           6 :   SwigClassSymbolDuplicate.klass = rb_define_class_under(mKdbtools, "SymbolDuplicate", rb_eRuntimeError);
   27951           6 :   SwigClassSymbolDuplicate.mImpl = rb_define_module_under(SwigClassSymbolDuplicate.klass, "Impl");
   27952           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__SymbolDuplicate, (void *) &SwigClassSymbolDuplicate);
   27953           6 :   rb_define_alloc_func(SwigClassSymbolDuplicate.klass, _wrap_SymbolDuplicate_allocate);
   27954           6 :   rb_define_method(SwigClassSymbolDuplicate.klass, "initialize", VALUEFUNC(_wrap_new_SymbolDuplicate), -1);
   27955           6 :   rb_define_method(SwigClassSymbolDuplicate.mImpl, "msg=", VALUEFUNC(_wrap_SymbolDuplicate_msg_set), -1);
   27956           6 :   rb_define_method(SwigClassSymbolDuplicate.mImpl, "msg", VALUEFUNC(_wrap_SymbolDuplicate_msg_get), -1);
   27957           6 :   rb_include_module(SwigClassSymbolDuplicate.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27958           6 :   SwigClassSymbolDuplicate.mark = 0;
   27959           6 :   SwigClassSymbolDuplicate.destroy = (void (*)(void *)) free_kdb_tools_SymbolDuplicate;
   27960           6 :   SwigClassSymbolDuplicate.trackObjects = 0;
   27961           6 :   rb_include_module(SwigClassSymbolDuplicate.klass, SwigClassSymbolDuplicate.mImpl);
   27962             :   
   27963           6 :   SwigClassStoragePlugin.klass = rb_define_class_under(mKdbtools, "StoragePlugin", rb_eRuntimeError);
   27964           6 :   SwigClassStoragePlugin.mImpl = rb_define_module_under(SwigClassStoragePlugin.klass, "Impl");
   27965           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__StoragePlugin, (void *) &SwigClassStoragePlugin);
   27966           6 :   rb_define_alloc_func(SwigClassStoragePlugin.klass, _wrap_StoragePlugin_allocate);
   27967           6 :   rb_define_method(SwigClassStoragePlugin.klass, "initialize", VALUEFUNC(_wrap_new_StoragePlugin), -1);
   27968           6 :   rb_include_module(SwigClassStoragePlugin.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27969           6 :   SwigClassStoragePlugin.mark = 0;
   27970           6 :   SwigClassStoragePlugin.destroy = (void (*)(void *)) free_kdb_tools_StoragePlugin;
   27971           6 :   SwigClassStoragePlugin.trackObjects = 0;
   27972           6 :   rb_include_module(SwigClassStoragePlugin.klass, SwigClassStoragePlugin.mImpl);
   27973             :   
   27974           6 :   SwigClassResolverPlugin.klass = rb_define_class_under(mKdbtools, "ResolverPlugin", rb_eRuntimeError);
   27975           6 :   SwigClassResolverPlugin.mImpl = rb_define_module_under(SwigClassResolverPlugin.klass, "Impl");
   27976           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__ResolverPlugin, (void *) &SwigClassResolverPlugin);
   27977           6 :   rb_define_alloc_func(SwigClassResolverPlugin.klass, _wrap_ResolverPlugin_allocate);
   27978           6 :   rb_define_method(SwigClassResolverPlugin.klass, "initialize", VALUEFUNC(_wrap_new_ResolverPlugin), -1);
   27979           6 :   rb_include_module(SwigClassResolverPlugin.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27980           6 :   SwigClassResolverPlugin.mark = 0;
   27981           6 :   SwigClassResolverPlugin.destroy = (void (*)(void *)) free_kdb_tools_ResolverPlugin;
   27982           6 :   SwigClassResolverPlugin.trackObjects = 0;
   27983           6 :   rb_include_module(SwigClassResolverPlugin.klass, SwigClassResolverPlugin.mImpl);
   27984             :   
   27985           6 :   SwigClassPluginNoContract.klass = rb_define_class_under(mKdbtools, "PluginNoContract", rb_eRuntimeError);
   27986           6 :   SwigClassPluginNoContract.mImpl = rb_define_module_under(SwigClassPluginNoContract.klass, "Impl");
   27987           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__PluginNoContract, (void *) &SwigClassPluginNoContract);
   27988           6 :   rb_define_alloc_func(SwigClassPluginNoContract.klass, _wrap_PluginNoContract_allocate);
   27989           6 :   rb_define_method(SwigClassPluginNoContract.klass, "initialize", VALUEFUNC(_wrap_new_PluginNoContract), -1);
   27990           6 :   rb_include_module(SwigClassPluginNoContract.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   27991           6 :   SwigClassPluginNoContract.mark = 0;
   27992           6 :   SwigClassPluginNoContract.destroy = (void (*)(void *)) free_kdb_tools_PluginNoContract;
   27993           6 :   SwigClassPluginNoContract.trackObjects = 0;
   27994           6 :   rb_include_module(SwigClassPluginNoContract.klass, SwigClassPluginNoContract.mImpl);
   27995             :   
   27996           6 :   SwigClassPluginNoInfo.klass = rb_define_class_under(mKdbtools, "PluginNoInfo", rb_eRuntimeError);
   27997           6 :   SwigClassPluginNoInfo.mImpl = rb_define_module_under(SwigClassPluginNoInfo.klass, "Impl");
   27998           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__PluginNoInfo, (void *) &SwigClassPluginNoInfo);
   27999           6 :   rb_define_alloc_func(SwigClassPluginNoInfo.klass, _wrap_PluginNoInfo_allocate);
   28000           6 :   rb_define_method(SwigClassPluginNoInfo.klass, "initialize", VALUEFUNC(_wrap_new_PluginNoInfo), -1);
   28001           6 :   rb_include_module(SwigClassPluginNoInfo.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   28002           6 :   SwigClassPluginNoInfo.mark = 0;
   28003           6 :   SwigClassPluginNoInfo.destroy = (void (*)(void *)) free_kdb_tools_PluginNoInfo;
   28004           6 :   SwigClassPluginNoInfo.trackObjects = 0;
   28005           6 :   rb_include_module(SwigClassPluginNoInfo.klass, SwigClassPluginNoInfo.mImpl);
   28006             :   
   28007           6 :   SwigClassVersionInfoMismatch.klass = rb_define_class_under(mKdbtools, "VersionInfoMismatch", rb_eRuntimeError);
   28008           6 :   SwigClassVersionInfoMismatch.mImpl = rb_define_module_under(SwigClassVersionInfoMismatch.klass, "Impl");
   28009           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__VersionInfoMismatch, (void *) &SwigClassVersionInfoMismatch);
   28010           6 :   rb_define_alloc_func(SwigClassVersionInfoMismatch.klass, _wrap_VersionInfoMismatch_allocate);
   28011           6 :   rb_define_method(SwigClassVersionInfoMismatch.klass, "initialize", VALUEFUNC(_wrap_new_VersionInfoMismatch), -1);
   28012           6 :   rb_include_module(SwigClassVersionInfoMismatch.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginCheckException->clientdata)->mImpl);
   28013           6 :   SwigClassVersionInfoMismatch.mark = 0;
   28014           6 :   SwigClassVersionInfoMismatch.destroy = (void (*)(void *)) free_kdb_tools_VersionInfoMismatch;
   28015           6 :   SwigClassVersionInfoMismatch.trackObjects = 0;
   28016           6 :   rb_include_module(SwigClassVersionInfoMismatch.klass, SwigClassVersionInfoMismatch.mImpl);
   28017             :   
   28018           6 :   SwigClassPluginSpecVector.klass = rb_define_class_under(mKdbtools, "PluginSpecVector", rb_cObject);
   28019           6 :   SwigClassPluginSpecVector.mImpl = rb_define_module_under(SwigClassPluginSpecVector.klass, "Impl");
   28020           6 :   SWIG_TypeClientData(SWIGTYPE_p_std__vectorT_kdb__tools__PluginSpec_std__allocatorT_kdb__tools__PluginSpec_t_t, (void *) &SwigClassPluginSpecVector);
   28021           6 :   rb_include_module(SwigClassPluginSpecVector.klass, rb_eval_string("Enumerable"));
   28022           6 :   rb_define_alloc_func(SwigClassPluginSpecVector.klass, _wrap_PluginSpecVector_allocate);
   28023           6 :   rb_define_method(SwigClassPluginSpecVector.klass, "initialize", VALUEFUNC(_wrap_new_PluginSpecVector), -1);
   28024           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "dup", VALUEFUNC(_wrap_PluginSpecVector_dup), -1);
   28025           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "inspect", VALUEFUNC(_wrap_PluginSpecVector_inspect), -1);
   28026           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "to_a", VALUEFUNC(_wrap_PluginSpecVector_to_a), -1);
   28027           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "to_s", VALUEFUNC(_wrap_PluginSpecVector_to_s), -1);
   28028           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "slice", VALUEFUNC(_wrap_PluginSpecVector_slice), -1);
   28029           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "each", VALUEFUNC(_wrap_PluginSpecVector_each), -1);
   28030           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "__delete_2__", VALUEFUNC(_wrap_PluginSpecVector___delete_2__), -1);
   28031           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "select", VALUEFUNC(_wrap_PluginSpecVector_select), -1);
   28032           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "delete_at", VALUEFUNC(_wrap_PluginSpecVector_delete_at), -1);
   28033           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "at", VALUEFUNC(_wrap_PluginSpecVector_at), -1);
   28034           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "[]", VALUEFUNC(_wrap_PluginSpecVector___getitem__), -1);
   28035           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "[]=", VALUEFUNC(_wrap_PluginSpecVector___setitem__), -1);
   28036           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "reject_bang", VALUEFUNC(_wrap_PluginSpecVector_reject_bang), -1);
   28037           6 :   rb_define_alias(SwigClassPluginSpecVector.mImpl, "delete_if", "reject_bang");
   28038           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "pop", VALUEFUNC(_wrap_PluginSpecVector_pop), -1);
   28039           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "push", VALUEFUNC(_wrap_PluginSpecVector_push), -1);
   28040           6 :   rb_define_alias(SwigClassPluginSpecVector.mImpl, "<<", "push");
   28041           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "reject", VALUEFUNC(_wrap_PluginSpecVector_reject), -1);
   28042           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "shift", VALUEFUNC(_wrap_PluginSpecVector_shift), -1);
   28043           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "insert", VALUEFUNC(_wrap_PluginSpecVector_insert), -1);
   28044           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "unshift", VALUEFUNC(_wrap_PluginSpecVector_unshift), -1);
   28045           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "empty", VALUEFUNC(_wrap_PluginSpecVector_empty), -1);
   28046           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "size", VALUEFUNC(_wrap_PluginSpecVector_size), -1);
   28047           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "swap", VALUEFUNC(_wrap_PluginSpecVector_swap), -1);
   28048           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "clear", VALUEFUNC(_wrap_PluginSpecVector_clear), -1);
   28049           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "get_allocator", VALUEFUNC(_wrap_PluginSpecVector_get_allocator), -1);
   28050           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "front", VALUEFUNC(_wrap_PluginSpecVector_front), -1);
   28051           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "back", VALUEFUNC(_wrap_PluginSpecVector_back), -1);
   28052           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "assign", VALUEFUNC(_wrap_PluginSpecVector_assign), -1);
   28053           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "resize", VALUEFUNC(_wrap_PluginSpecVector_resize), -1);
   28054           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "reserve", VALUEFUNC(_wrap_PluginSpecVector_reserve), -1);
   28055           6 :   rb_define_method(SwigClassPluginSpecVector.mImpl, "capacity", VALUEFUNC(_wrap_PluginSpecVector_capacity), -1);
   28056           6 :   SwigClassPluginSpecVector.mark = 0;
   28057           6 :   SwigClassPluginSpecVector.destroy = (void (*)(void *)) free_std_vector_Sl_kdb_tools_PluginSpec_Sg_;
   28058           6 :   SwigClassPluginSpecVector.trackObjects = 0;
   28059           6 :   rb_include_module(SwigClassPluginSpecVector.klass, SwigClassPluginSpecVector.mImpl);
   28060             :   
   28061           6 :   SwigClassPluginSpec.klass = rb_define_class_under(mKdbtools, "PluginSpec", rb_cObject);
   28062           6 :   SwigClassPluginSpec.mImpl = rb_define_module_under(SwigClassPluginSpec.klass, "Impl");
   28063           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__PluginSpec, (void *) &SwigClassPluginSpec);
   28064           6 :   rb_define_alloc_func(SwigClassPluginSpec.klass, _wrap_PluginSpec_allocate);
   28065           6 :   rb_define_method(SwigClassPluginSpec.klass, "initialize", VALUEFUNC(_wrap_new_PluginSpec), -1);
   28066           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "fullname", VALUEFUNC(_wrap_PluginSpec_fullname), -1);
   28067           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "refname", VALUEFUNC(_wrap_PluginSpec_refname), -1);
   28068           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "is_refnumber?", VALUEFUNC(_wrap_PluginSpec_is_refnumberq___), -1);
   28069           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "name", VALUEFUNC(_wrap_PluginSpec_name), -1);
   28070           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "config", VALUEFUNC(_wrap_PluginSpec_config), -1);
   28071           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "fullname=", VALUEFUNC(_wrap_PluginSpec_fullnamee___), -1);
   28072           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "refname=", VALUEFUNC(_wrap_PluginSpec_refnamee___), -1);
   28073           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "refnumber=", VALUEFUNC(_wrap_PluginSpec_refnumbere___), -1);
   28074           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "name=", VALUEFUNC(_wrap_PluginSpec_namee___), -1);
   28075           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "append_config", VALUEFUNC(_wrap_PluginSpec_append_config), -1);
   28076           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "config=", VALUEFUNC(_wrap_PluginSpec_confige___), -1);
   28077           6 :   rb_define_method(SwigClassPluginSpec.mImpl, "validate", VALUEFUNC(_wrap_PluginSpec_validate), -1);
   28078           6 :   SwigClassPluginSpec.mark = 0;
   28079           6 :   SwigClassPluginSpec.destroy = (void (*)(void *)) free_kdb_tools_PluginSpec;
   28080           6 :   SwigClassPluginSpec.trackObjects = 0;
   28081           6 :   rb_include_module(SwigClassPluginSpec.klass, SwigClassPluginSpec.mImpl);
   28082             :   
   28083           6 :   SwigClassPluginSpecName.klass = rb_define_class_under(mKdbtools, "PluginSpecName", rb_cObject);
   28084           6 :   SwigClassPluginSpecName.mImpl = rb_define_module_under(SwigClassPluginSpecName.klass, "Impl");
   28085           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__PluginSpecName, (void *) &SwigClassPluginSpecName);
   28086           6 :   rb_define_alloc_func(SwigClassPluginSpecName.klass, _wrap_PluginSpecName_allocate);
   28087           6 :   rb_define_method(SwigClassPluginSpecName.klass, "initialize", VALUEFUNC(_wrap_new_PluginSpecName), -1);
   28088           6 :   rb_define_method(SwigClassPluginSpecName.mImpl, "call", VALUEFUNC(_wrap_PluginSpecName___call__), -1);
   28089           6 :   SwigClassPluginSpecName.mark = 0;
   28090           6 :   SwigClassPluginSpecName.destroy = (void (*)(void *)) free_kdb_tools_PluginSpecName;
   28091           6 :   SwigClassPluginSpecName.trackObjects = 0;
   28092           6 :   rb_include_module(SwigClassPluginSpecName.klass, SwigClassPluginSpecName.mImpl);
   28093             :   
   28094           6 :   SwigClassPluginSpecRefName.klass = rb_define_class_under(mKdbtools, "PluginSpecRefName", rb_cObject);
   28095           6 :   SwigClassPluginSpecRefName.mImpl = rb_define_module_under(SwigClassPluginSpecRefName.klass, "Impl");
   28096           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__PluginSpecRefName, (void *) &SwigClassPluginSpecRefName);
   28097           6 :   rb_define_alloc_func(SwigClassPluginSpecRefName.klass, _wrap_PluginSpecRefName_allocate);
   28098           6 :   rb_define_method(SwigClassPluginSpecRefName.klass, "initialize", VALUEFUNC(_wrap_new_PluginSpecRefName), -1);
   28099           6 :   rb_define_method(SwigClassPluginSpecRefName.mImpl, "call", VALUEFUNC(_wrap_PluginSpecRefName___call__), -1);
   28100           6 :   SwigClassPluginSpecRefName.mark = 0;
   28101           6 :   SwigClassPluginSpecRefName.destroy = (void (*)(void *)) free_kdb_tools_PluginSpecRefName;
   28102           6 :   SwigClassPluginSpecRefName.trackObjects = 0;
   28103           6 :   rb_include_module(SwigClassPluginSpecRefName.klass, SwigClassPluginSpecRefName.mImpl);
   28104             :   
   28105           6 :   SwigClassPluginSpecFullName.klass = rb_define_class_under(mKdbtools, "PluginSpecFullName", rb_cObject);
   28106           6 :   SwigClassPluginSpecFullName.mImpl = rb_define_module_under(SwigClassPluginSpecFullName.klass, "Impl");
   28107           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__PluginSpecFullName, (void *) &SwigClassPluginSpecFullName);
   28108           6 :   rb_define_alloc_func(SwigClassPluginSpecFullName.klass, _wrap_PluginSpecFullName_allocate);
   28109           6 :   rb_define_method(SwigClassPluginSpecFullName.klass, "initialize", VALUEFUNC(_wrap_new_PluginSpecFullName), -1);
   28110           6 :   rb_define_method(SwigClassPluginSpecFullName.mImpl, "call", VALUEFUNC(_wrap_PluginSpecFullName___call__), -1);
   28111           6 :   SwigClassPluginSpecFullName.mark = 0;
   28112           6 :   SwigClassPluginSpecFullName.destroy = (void (*)(void *)) free_kdb_tools_PluginSpecFullName;
   28113           6 :   SwigClassPluginSpecFullName.trackObjects = 0;
   28114           6 :   rb_include_module(SwigClassPluginSpecFullName.klass, SwigClassPluginSpecFullName.mImpl);
   28115             :   
   28116           6 :   SwigClassPluginSpecHash.klass = rb_define_class_under(mKdbtools, "PluginSpecHash", rb_cObject);
   28117           6 :   SwigClassPluginSpecHash.mImpl = rb_define_module_under(SwigClassPluginSpecHash.klass, "Impl");
   28118           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__PluginSpecHash, (void *) &SwigClassPluginSpecHash);
   28119           6 :   rb_define_alloc_func(SwigClassPluginSpecHash.klass, _wrap_PluginSpecHash_allocate);
   28120           6 :   rb_define_method(SwigClassPluginSpecHash.klass, "initialize", VALUEFUNC(_wrap_new_PluginSpecHash), -1);
   28121           6 :   rb_define_method(SwigClassPluginSpecHash.mImpl, "call", VALUEFUNC(_wrap_PluginSpecHash___call__), -1);
   28122           6 :   SwigClassPluginSpecHash.mark = 0;
   28123           6 :   SwigClassPluginSpecHash.destroy = (void (*)(void *)) free_kdb_tools_PluginSpecHash;
   28124           6 :   SwigClassPluginSpecHash.trackObjects = 0;
   28125           6 :   rb_include_module(SwigClassPluginSpecHash.klass, SwigClassPluginSpecHash.mImpl);
   28126           6 :   rb_define_module_function(mKdbtools, "<<", VALUEFUNC(_wrap___lshift__), -1);
   28127             :   
   28128           6 :   SwigClassPlugin.klass = rb_define_class_under(mKdbtools, "Plugin", rb_cObject);
   28129           6 :   SwigClassPlugin.mImpl = rb_define_module_under(SwigClassPlugin.klass, "Impl");
   28130           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__Plugin, (void *) &SwigClassPlugin);
   28131           6 :   rb_define_alloc_func(SwigClassPlugin.klass, _wrap_Plugin_allocate);
   28132           6 :   rb_define_method(SwigClassPlugin.klass, "initialize", VALUEFUNC(_wrap_new_Plugin), -1);
   28133           6 :   rb_define_method(SwigClassPlugin.mImpl, "firstRef=", VALUEFUNC(_wrap_Plugin_firstRef_set), -1);
   28134           6 :   rb_define_method(SwigClassPlugin.mImpl, "firstRef", VALUEFUNC(_wrap_Plugin_firstRef_get), -1);
   28135           6 :   rb_define_method(SwigClassPlugin.mImpl, "load_info", VALUEFUNC(_wrap_Plugin_load_info), -1);
   28136           6 :   rb_define_method(SwigClassPlugin.mImpl, "parse", VALUEFUNC(_wrap_Plugin_parse), -1);
   28137           6 :   rb_define_method(SwigClassPlugin.mImpl, "check", VALUEFUNC(_wrap_Plugin_check), -1);
   28138           6 :   rb_define_method(SwigClassPlugin.mImpl, "__deref__", VALUEFUNC(_wrap_Plugin___deref__), -1);
   28139           6 :   rb_define_method(SwigClassPlugin.mImpl, "lookup_info", VALUEFUNC(_wrap_Plugin_lookup_info), -1);
   28140           6 :   rb_define_method(SwigClassPlugin.mImpl, "find_info", VALUEFUNC(_wrap_Plugin_find_info), -1);
   28141           6 :   rb_define_method(SwigClassPlugin.mImpl, "get_info", VALUEFUNC(_wrap_Plugin_get_info), -1);
   28142           6 :   rb_define_method(SwigClassPlugin.mImpl, "get_needed_config", VALUEFUNC(_wrap_Plugin_get_needed_config), -1);
   28143           6 :   rb_define_method(SwigClassPlugin.mImpl, "get_config", VALUEFUNC(_wrap_Plugin_get_config), -1);
   28144           6 :   rb_define_method(SwigClassPlugin.mImpl, "open", VALUEFUNC(_wrap_Plugin_open), -1);
   28145           6 :   rb_define_method(SwigClassPlugin.mImpl, "close", VALUEFUNC(_wrap_Plugin_close), -1);
   28146           6 :   rb_define_method(SwigClassPlugin.mImpl, "get", VALUEFUNC(_wrap_Plugin_get), -1);
   28147           6 :   rb_define_method(SwigClassPlugin.mImpl, "set", VALUEFUNC(_wrap_Plugin_set), -1);
   28148           6 :   rb_define_method(SwigClassPlugin.mImpl, "commit", VALUEFUNC(_wrap_Plugin_commit), -1);
   28149           6 :   rb_define_method(SwigClassPlugin.mImpl, "error", VALUEFUNC(_wrap_Plugin_error), -1);
   28150           6 :   rb_define_method(SwigClassPlugin.mImpl, "name", VALUEFUNC(_wrap_Plugin_name), -1);
   28151           6 :   rb_define_method(SwigClassPlugin.mImpl, "get_full_name", VALUEFUNC(_wrap_Plugin_get_full_name), -1);
   28152           6 :   SwigClassPlugin.mark = 0;
   28153           6 :   SwigClassPlugin.destroy = (void (*)(void *)) free_kdb_tools_Plugin;
   28154           6 :   SwigClassPlugin.trackObjects = 0;
   28155           6 :   rb_include_module(SwigClassPlugin.klass, SwigClassPlugin.mImpl);
   28156             :   
   28157           6 :   SwigClassPlace.klass = rb_define_class_under(mKdbtools, "Place", rb_cObject);
   28158           6 :   SwigClassPlace.mImpl = rb_define_module_under(SwigClassPlace.klass, "Impl");
   28159           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__Place, (void *) &SwigClassPlace);
   28160           6 :   rb_define_alloc_func(SwigClassPlace.klass, _wrap_Place_allocate);
   28161           6 :   rb_define_method(SwigClassPlace.klass, "initialize", VALUEFUNC(_wrap_new_Place), -1);
   28162           6 :   rb_define_method(SwigClassPlace.mImpl, "current=", VALUEFUNC(_wrap_Place_current_set), -1);
   28163           6 :   rb_define_method(SwigClassPlace.mImpl, "current", VALUEFUNC(_wrap_Place_current_get), -1);
   28164           6 :   rb_define_method(SwigClassPlace.mImpl, "max=", VALUEFUNC(_wrap_Place_max_set), -1);
   28165           6 :   rb_define_method(SwigClassPlace.mImpl, "max", VALUEFUNC(_wrap_Place_max_get), -1);
   28166           6 :   SwigClassPlace.mark = 0;
   28167           6 :   SwigClassPlace.destroy = (void (*)(void *)) free_kdb_tools_Place;
   28168           6 :   SwigClassPlace.trackObjects = 0;
   28169           6 :   rb_include_module(SwigClassPlace.klass, SwigClassPlace.mImpl);
   28170             :   
   28171           6 :   SwigClassPlugins.klass = rb_define_class_under(mKdbtools, "Plugins", rb_cObject);
   28172           6 :   SwigClassPlugins.mImpl = rb_define_module_under(SwigClassPlugins.klass, "Impl");
   28173           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__Plugins, (void *) &SwigClassPlugins);
   28174           6 :   rb_define_alloc_func(SwigClassPlugins.klass, _wrap_Plugins_allocate);
   28175           6 :   rb_define_method(SwigClassPlugins.klass, "initialize", VALUEFUNC(_wrap_new_Plugins), -1);
   28176           6 :   rb_define_method(SwigClassPlugins.mImpl, "add_info", VALUEFUNC(_wrap_Plugins_add_info), -1);
   28177           6 :   rb_define_method(SwigClassPlugins.mImpl, "add_plugin", VALUEFUNC(_wrap_Plugins_add_plugin), -1);
   28178           6 :   rb_define_method(SwigClassPlugins.mImpl, "validate_provided", VALUEFUNC(_wrap_Plugins_validate_provided), -1);
   28179           6 :   rb_define_method(SwigClassPlugins.mImpl, "get_needed_missing", VALUEFUNC(_wrap_Plugins_get_needed_missing), -1);
   28180           6 :   rb_define_method(SwigClassPlugins.mImpl, "get_recommended_missing", VALUEFUNC(_wrap_Plugins_get_recommended_missing), -1);
   28181           6 :   rb_define_method(SwigClassPlugins.mImpl, "check_placement", VALUEFUNC(_wrap_Plugins_check_placement), -1);
   28182           6 :   rb_define_method(SwigClassPlugins.mImpl, "check_storage", VALUEFUNC(_wrap_Plugins_check_storage), -1);
   28183           6 :   rb_define_method(SwigClassPlugins.mImpl, "check_resolver", VALUEFUNC(_wrap_Plugins_check_resolver), -1);
   28184           6 :   rb_define_method(SwigClassPlugins.mImpl, "check_ordering", VALUEFUNC(_wrap_Plugins_check_ordering), -1);
   28185           6 :   rb_define_method(SwigClassPlugins.mImpl, "check_conflicts", VALUEFUNC(_wrap_Plugins_check_conflicts), -1);
   28186           6 :   SwigClassPlugins.mark = 0;
   28187           6 :   SwigClassPlugins.destroy = (void (*)(void *)) free_kdb_tools_Plugins;
   28188           6 :   SwigClassPlugins.trackObjects = 0;
   28189           6 :   rb_include_module(SwigClassPlugins.klass, SwigClassPlugins.mImpl);
   28190             :   
   28191           6 :   SwigClassGetPlugins.klass = rb_define_class_under(mKdbtools, "GetPlugins", rb_cObject);
   28192           6 :   SwigClassGetPlugins.mImpl = rb_define_module_under(SwigClassGetPlugins.klass, "Impl");
   28193           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__GetPlugins, (void *) &SwigClassGetPlugins);
   28194           6 :   rb_define_alloc_func(SwigClassGetPlugins.klass, _wrap_GetPlugins_allocate);
   28195           6 :   rb_define_method(SwigClassGetPlugins.klass, "initialize", VALUEFUNC(_wrap_new_GetPlugins), -1);
   28196           6 :   rb_define_method(SwigClassGetPlugins.mImpl, "try_plugin", VALUEFUNC(_wrap_GetPlugins_try_plugin), -1);
   28197           6 :   rb_define_method(SwigClassGetPlugins.mImpl, "add_plugin", VALUEFUNC(_wrap_GetPlugins_add_plugin), -1);
   28198           6 :   rb_define_method(SwigClassGetPlugins.mImpl, "validated", VALUEFUNC(_wrap_GetPlugins_validated), -1);
   28199           6 :   rb_define_method(SwigClassGetPlugins.mImpl, "serialise", VALUEFUNC(_wrap_GetPlugins_serialise), -1);
   28200           6 :   SwigClassGetPlugins.mark = 0;
   28201           6 :   SwigClassGetPlugins.destroy = (void (*)(void *)) free_kdb_tools_GetPlugins;
   28202           6 :   SwigClassGetPlugins.trackObjects = 0;
   28203           6 :   rb_include_module(SwigClassGetPlugins.klass, SwigClassGetPlugins.mImpl);
   28204             :   
   28205           6 :   SwigClassSetPlugins.klass = rb_define_class_under(mKdbtools, "SetPlugins", rb_cObject);
   28206           6 :   SwigClassSetPlugins.mImpl = rb_define_module_under(SwigClassSetPlugins.klass, "Impl");
   28207           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__SetPlugins, (void *) &SwigClassSetPlugins);
   28208           6 :   rb_define_alloc_func(SwigClassSetPlugins.klass, _wrap_SetPlugins_allocate);
   28209           6 :   rb_define_method(SwigClassSetPlugins.klass, "initialize", VALUEFUNC(_wrap_new_SetPlugins), -1);
   28210           6 :   rb_define_method(SwigClassSetPlugins.mImpl, "try_plugin", VALUEFUNC(_wrap_SetPlugins_try_plugin), -1);
   28211           6 :   rb_define_method(SwigClassSetPlugins.mImpl, "add_plugin", VALUEFUNC(_wrap_SetPlugins_add_plugin), -1);
   28212           6 :   rb_define_method(SwigClassSetPlugins.mImpl, "validated", VALUEFUNC(_wrap_SetPlugins_validated), -1);
   28213           6 :   rb_define_method(SwigClassSetPlugins.mImpl, "serialise", VALUEFUNC(_wrap_SetPlugins_serialise), -1);
   28214           6 :   SwigClassSetPlugins.mark = 0;
   28215           6 :   SwigClassSetPlugins.destroy = (void (*)(void *)) free_kdb_tools_SetPlugins;
   28216           6 :   SwigClassSetPlugins.trackObjects = 0;
   28217           6 :   rb_include_module(SwigClassSetPlugins.klass, SwigClassSetPlugins.mImpl);
   28218             :   
   28219           6 :   SwigClassErrorPlugins.klass = rb_define_class_under(mKdbtools, "ErrorPlugins", rb_cObject);
   28220           6 :   SwigClassErrorPlugins.mImpl = rb_define_module_under(SwigClassErrorPlugins.klass, "Impl");
   28221           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__ErrorPlugins, (void *) &SwigClassErrorPlugins);
   28222           6 :   rb_define_alloc_func(SwigClassErrorPlugins.klass, _wrap_ErrorPlugins_allocate);
   28223           6 :   rb_define_method(SwigClassErrorPlugins.klass, "initialize", VALUEFUNC(_wrap_new_ErrorPlugins), -1);
   28224           6 :   rb_define_method(SwigClassErrorPlugins.mImpl, "status", VALUEFUNC(_wrap_ErrorPlugins_status), -1);
   28225           6 :   rb_define_method(SwigClassErrorPlugins.mImpl, "try_plugin", VALUEFUNC(_wrap_ErrorPlugins_try_plugin), -1);
   28226           6 :   rb_define_method(SwigClassErrorPlugins.mImpl, "add_plugin", VALUEFUNC(_wrap_ErrorPlugins_add_plugin), -1);
   28227           6 :   rb_define_method(SwigClassErrorPlugins.mImpl, "validated", VALUEFUNC(_wrap_ErrorPlugins_validated), -1);
   28228           6 :   rb_define_method(SwigClassErrorPlugins.mImpl, "serialise", VALUEFUNC(_wrap_ErrorPlugins_serialise), -1);
   28229           6 :   SwigClassErrorPlugins.mark = 0;
   28230           6 :   SwigClassErrorPlugins.destroy = (void (*)(void *)) free_kdb_tools_ErrorPlugins;
   28231           6 :   SwigClassErrorPlugins.trackObjects = 0;
   28232           6 :   rb_include_module(SwigClassErrorPlugins.klass, SwigClassErrorPlugins.mImpl);
   28233             :   
   28234           6 :   SwigClassIntPluginSpecMap.klass = rb_define_class_under(mKdbtools, "IntPluginSpecMap", rb_cObject);
   28235           6 :   SwigClassIntPluginSpecMap.mImpl = rb_define_module_under(SwigClassIntPluginSpecMap.klass, "Impl");
   28236           6 :   SWIG_TypeClientData(SWIGTYPE_p_std__mapT_int_kdb__tools__PluginSpec_std__lessT_int_t_std__allocatorT_std__pairT_int_const_kdb__tools__PluginSpec_t_t_t, (void *) &SwigClassIntPluginSpecMap);
   28237           6 :   rb_include_module(SwigClassIntPluginSpecMap.klass, rb_eval_string("Enumerable"));
   28238           6 :   rb_define_alloc_func(SwigClassIntPluginSpecMap.klass, _wrap_IntPluginSpecMap_allocate);
   28239           6 :   rb_define_method(SwigClassIntPluginSpecMap.klass, "initialize", VALUEFUNC(_wrap_new_IntPluginSpecMap), -1);
   28240           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "dup", VALUEFUNC(_wrap_IntPluginSpecMap_dup), -1);
   28241           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "__delete__", VALUEFUNC(_wrap_IntPluginSpecMap___delete__), -1);
   28242           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "has_key", VALUEFUNC(_wrap_IntPluginSpecMap_has_key), -1);
   28243           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "keys", VALUEFUNC(_wrap_IntPluginSpecMap_keys), -1);
   28244           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "each", VALUEFUNC(_wrap_IntPluginSpecMap_each), -1);
   28245           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "select", VALUEFUNC(_wrap_IntPluginSpecMap_select), -1);
   28246           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "values_at", VALUEFUNC(_wrap_IntPluginSpecMap_values_at), -1);
   28247           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "each_key", VALUEFUNC(_wrap_IntPluginSpecMap_each_key), -1);
   28248           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "values", VALUEFUNC(_wrap_IntPluginSpecMap_values), -1);
   28249           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "each_value", VALUEFUNC(_wrap_IntPluginSpecMap_each_value), -1);
   28250           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "entries", VALUEFUNC(_wrap_IntPluginSpecMap_entries), -1);
   28251           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "__contains__", VALUEFUNC(_wrap_IntPluginSpecMap___contains__), -1);
   28252           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "key_iterator", VALUEFUNC(_wrap_IntPluginSpecMap_key_iterator), -1);
   28253           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "value_iterator", VALUEFUNC(_wrap_IntPluginSpecMap_value_iterator), -1);
   28254           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "[]", VALUEFUNC(_wrap_IntPluginSpecMap___getitem__), -1);
   28255           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "[]=", VALUEFUNC(_wrap_IntPluginSpecMap___setitem__), -1);
   28256           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "inspect", VALUEFUNC(_wrap_IntPluginSpecMap_inspect), -1);
   28257           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "to_a", VALUEFUNC(_wrap_IntPluginSpecMap_to_a), -1);
   28258           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "to_s", VALUEFUNC(_wrap_IntPluginSpecMap_to_s), -1);
   28259           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "empty", VALUEFUNC(_wrap_IntPluginSpecMap_empty), -1);
   28260           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "size", VALUEFUNC(_wrap_IntPluginSpecMap_size), -1);
   28261           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "swap", VALUEFUNC(_wrap_IntPluginSpecMap_swap), -1);
   28262           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "clear", VALUEFUNC(_wrap_IntPluginSpecMap_clear), -1);
   28263           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "get_allocator", VALUEFUNC(_wrap_IntPluginSpecMap_get_allocator), -1);
   28264           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "erase", VALUEFUNC(_wrap_IntPluginSpecMap_erase), -1);
   28265           6 :   rb_define_method(SwigClassIntPluginSpecMap.mImpl, "count", VALUEFUNC(_wrap_IntPluginSpecMap_count), -1);
   28266           6 :   SwigClassIntPluginSpecMap.mark = 0;
   28267           6 :   SwigClassIntPluginSpecMap.destroy = (void (*)(void *)) free_std_map_Sl_int_Sc_kdb_tools_PluginSpec_Sg_;
   28268           6 :   SwigClassIntPluginSpecMap.trackObjects = 0;
   28269           6 :   rb_include_module(SwigClassIntPluginSpecMap.klass, SwigClassIntPluginSpecMap.mImpl);
   28270           6 :   rb_define_const(mKdbtools, "PLUGIN_STATUS_PROVIDES", SWIG_From_int(static_cast< int >(kdb::tools::PluginDatabase::Status::provides)));
   28271           6 :   rb_define_const(mKdbtools, "PLUGIN_STATUS_REAL", SWIG_From_int(static_cast< int >(kdb::tools::PluginDatabase::Status::real)));
   28272           6 :   rb_define_const(mKdbtools, "PLUGIN_STATUS_MISSING", SWIG_From_int(static_cast< int >(kdb::tools::PluginDatabase::Status::missing)));
   28273             :   
   28274           6 :   SwigClassPluginDatabase.klass = rb_define_class_under(mKdbtools, "PluginDatabase", rb_cObject);
   28275           6 :   SwigClassPluginDatabase.mImpl = rb_define_module_under(SwigClassPluginDatabase.klass, "Impl");
   28276           6 :   SWIG_TypeClientData(SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginDatabase_t, (void *) &SwigClassPluginDatabase);
   28277           6 :   rb_undef_alloc_func(SwigClassPluginDatabase.klass);
   28278           6 :   rb_define_method(SwigClassPluginDatabase.mImpl, "list_all_plugins", VALUEFUNC(_wrap_PluginDatabase_list_all_plugins), -1);
   28279           6 :   rb_define_const(SwigClassPluginDatabase.mImpl, "Provides", SWIG_From_int(static_cast< int >(kdb::tools::PluginDatabase::provides)));
   28280           6 :   rb_define_const(SwigClassPluginDatabase.mImpl, "Real", SWIG_From_int(static_cast< int >(kdb::tools::PluginDatabase::real)));
   28281           6 :   rb_define_const(SwigClassPluginDatabase.mImpl, "Missing", SWIG_From_int(static_cast< int >(kdb::tools::PluginDatabase::missing)));
   28282           6 :   rb_define_method(SwigClassPluginDatabase.mImpl, "status", VALUEFUNC(_wrap_PluginDatabase_status), -1);
   28283           6 :   rb_define_method(SwigClassPluginDatabase.mImpl, "lookup_info", VALUEFUNC(_wrap_PluginDatabase_lookup_info), -1);
   28284           6 :   rb_define_method(SwigClassPluginDatabase.mImpl, "lookup_metadata", VALUEFUNC(_wrap_PluginDatabase_lookup_metadata), -1);
   28285           6 :   rb_define_method(SwigClassPluginDatabase.mImpl, "lookup_provides", VALUEFUNC(_wrap_PluginDatabase_lookup_provides), -1);
   28286           6 :   rb_define_method(SwigClassPluginDatabase.mImpl, "lookup_all_provides_with_status", VALUEFUNC(_wrap_PluginDatabase_lookup_all_provides_with_status), -1);
   28287           6 :   rb_define_method(SwigClassPluginDatabase.mImpl, "lookup_all_provides", VALUEFUNC(_wrap_PluginDatabase_lookup_all_provides), -1);
   28288           6 :   rb_define_singleton_method(SwigClassPluginDatabase.klass, "calculate_status", VALUEFUNC(_wrap_PluginDatabase_calculate_status), -1);
   28289           6 :   rb_define_singleton_method(SwigClassPluginDatabase.klass, "statusMap", VALUEFUNC(_wrap_PluginDatabase_statusMap_get), 0);
   28290           6 :   SwigClassPluginDatabase.mark = 0;
   28291           6 :   SwigClassPluginDatabase.destroy = (void (*)(void *)) free_kdb_tools_PluginDatabase;
   28292           6 :   SwigClassPluginDatabase.trackObjects = 0;
   28293           6 :   rb_include_module(SwigClassPluginDatabase.klass, SwigClassPluginDatabase.mImpl);
   28294             :   
   28295           6 :   SwigClassModulesPluginDatabase.klass = rb_define_class_under(mKdbtools, "ModulesPluginDatabase", rb_cObject);
   28296           6 :   SwigClassModulesPluginDatabase.mImpl = rb_define_module_under(SwigClassModulesPluginDatabase.klass, "Impl");
   28297           6 :   SWIG_TypeClientData(SWIGTYPE_p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t, (void *) &SwigClassModulesPluginDatabase);
   28298           6 :   rb_define_alloc_func(SwigClassModulesPluginDatabase.klass, _wrap_ModulesPluginDatabase_allocate);
   28299           6 :   rb_define_method(SwigClassModulesPluginDatabase.klass, "initialize", VALUEFUNC(_wrap_new_ModulesPluginDatabase), -1);
   28300           6 :   rb_include_module(SwigClassModulesPluginDatabase.mImpl, ((swig_class *) SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginDatabase_t->clientdata)->mImpl);
   28301           6 :   SwigClassModulesPluginDatabase.mark = 0;
   28302           6 :   SwigClassModulesPluginDatabase.destroy = (void (*)(void *)) free_kdb_tools_ModulesPluginDatabase;
   28303           6 :   SwigClassModulesPluginDatabase.trackObjects = 0;
   28304           6 :   rb_include_module(SwigClassModulesPluginDatabase.klass, SwigClassModulesPluginDatabase.mImpl);
   28305             :   
   28306           6 :   SwigClassPluginVariantDatabase.klass = rb_define_class_under(mKdbtools, "PluginVariantDatabase", rb_cObject);
   28307           6 :   SwigClassPluginVariantDatabase.mImpl = rb_define_module_under(SwigClassPluginVariantDatabase.klass, "Impl");
   28308           6 :   SWIG_TypeClientData(SWIGTYPE_p_std__shared_ptrT_kdb__tools__PluginVariantDatabase_t, (void *) &SwigClassPluginVariantDatabase);
   28309           6 :   rb_define_alloc_func(SwigClassPluginVariantDatabase.klass, _wrap_PluginVariantDatabase_allocate);
   28310           6 :   rb_define_method(SwigClassPluginVariantDatabase.klass, "initialize", VALUEFUNC(_wrap_new_PluginVariantDatabase), -1);
   28311           6 :   rb_define_method(SwigClassPluginVariantDatabase.mImpl, "get_plugin_variants", VALUEFUNC(_wrap_PluginVariantDatabase_get_plugin_variants), -1);
   28312           6 :   rb_include_module(SwigClassPluginVariantDatabase.mImpl, ((swig_class *) SWIGTYPE_p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t->clientdata)->mImpl);
   28313           6 :   SwigClassPluginVariantDatabase.mark = 0;
   28314           6 :   SwigClassPluginVariantDatabase.destroy = (void (*)(void *)) free_kdb_tools_PluginVariantDatabase;
   28315           6 :   SwigClassPluginVariantDatabase.trackObjects = 0;
   28316           6 :   rb_include_module(SwigClassPluginVariantDatabase.klass, SwigClassPluginVariantDatabase.mImpl);
   28317             :   
   28318           6 :   SwigClassMockPluginDatabase.klass = rb_define_class_under(mKdbtools, "MockPluginDatabase", rb_cObject);
   28319           6 :   SwigClassMockPluginDatabase.mImpl = rb_define_module_under(SwigClassMockPluginDatabase.klass, "Impl");
   28320           6 :   SWIG_TypeClientData(SWIGTYPE_p_std__shared_ptrT_kdb__tools__MockPluginDatabase_t, (void *) &SwigClassMockPluginDatabase);
   28321           6 :   rb_define_alloc_func(SwigClassMockPluginDatabase.klass, _wrap_MockPluginDatabase_allocate);
   28322           6 :   rb_define_method(SwigClassMockPluginDatabase.klass, "initialize", VALUEFUNC(_wrap_new_MockPluginDatabase), -1);
   28323           6 :   rb_define_method(SwigClassMockPluginDatabase.mImpl, "data=", VALUEFUNC(_wrap_MockPluginDatabase_data_set), -1);
   28324           6 :   rb_define_method(SwigClassMockPluginDatabase.mImpl, "data", VALUEFUNC(_wrap_MockPluginDatabase_data_get), -1);
   28325           6 :   rb_define_method(SwigClassMockPluginDatabase.mImpl, "set_checkconf_function", VALUEFUNC(_wrap_MockPluginDatabase_set_checkconf_function), -1);
   28326           6 :   rb_include_module(SwigClassMockPluginDatabase.mImpl, ((swig_class *) SWIGTYPE_p_std__shared_ptrT_kdb__tools__ModulesPluginDatabase_t->clientdata)->mImpl);
   28327           6 :   SwigClassMockPluginDatabase.mark = 0;
   28328           6 :   SwigClassMockPluginDatabase.destroy = (void (*)(void *)) free_kdb_tools_MockPluginDatabase;
   28329           6 :   SwigClassMockPluginDatabase.trackObjects = 0;
   28330           6 :   rb_include_module(SwigClassMockPluginDatabase.klass, SwigClassMockPluginDatabase.mImpl);
   28331             :   
   28332           6 :   SwigClassModules.klass = rb_define_class_under(mKdbtools, "Modules", rb_cObject);
   28333           6 :   SwigClassModules.mImpl = rb_define_module_under(SwigClassModules.klass, "Impl");
   28334           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__Modules, (void *) &SwigClassModules);
   28335           6 :   rb_define_alloc_func(SwigClassModules.klass, _wrap_Modules_allocate);
   28336           6 :   rb_define_method(SwigClassModules.klass, "initialize", VALUEFUNC(_wrap_new_Modules), -1);
   28337           6 :   rb_define_method(SwigClassModules.mImpl, "load", VALUEFUNC(_wrap_Modules_load), -1);
   28338           6 :   SwigClassModules.mark = 0;
   28339           6 :   SwigClassModules.destroy = (void (*)(void *)) free_kdb_tools_Modules;
   28340           6 :   SwigClassModules.trackObjects = 0;
   28341           6 :   rb_include_module(SwigClassModules.klass, SwigClassModules.mImpl);
   28342           6 :   rb_define_module_function(mKdbtools, "parse_plugin_arguments", VALUEFUNC(_wrap_parse_plugin_arguments), -1);
   28343           6 :   rb_define_module_function(mKdbtools, "parse_arguments", VALUEFUNC(_wrap_parse_arguments), -1);
   28344             :   
   28345           6 :   SwigClassBackendInterface.klass = rb_define_class_under(mKdbtools, "BackendInterface", rb_cObject);
   28346           6 :   SwigClassBackendInterface.mImpl = rb_define_module_under(SwigClassBackendInterface.klass, "Impl");
   28347           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__BackendInterface, (void *) &SwigClassBackendInterface);
   28348           6 :   rb_undef_alloc_func(SwigClassBackendInterface.klass);
   28349           6 :   rb_define_method(SwigClassBackendInterface.mImpl, "add_plugin", VALUEFUNC(_wrap_BackendInterface_add_plugin), -1);
   28350           6 :   SwigClassBackendInterface.mark = 0;
   28351           6 :   SwigClassBackendInterface.destroy = (void (*)(void *)) free_kdb_tools_BackendInterface;
   28352           6 :   SwigClassBackendInterface.trackObjects = 0;
   28353           6 :   rb_include_module(SwigClassBackendInterface.klass, SwigClassBackendInterface.mImpl);
   28354             :   
   28355           6 :   SwigClassSerializeInterface.klass = rb_define_class_under(mKdbtools, "SerializeInterface", rb_cObject);
   28356           6 :   SwigClassSerializeInterface.mImpl = rb_define_module_under(SwigClassSerializeInterface.klass, "Impl");
   28357           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__SerializeInterface, (void *) &SwigClassSerializeInterface);
   28358           6 :   rb_undef_alloc_func(SwigClassSerializeInterface.klass);
   28359           6 :   rb_define_method(SwigClassSerializeInterface.mImpl, "serialize", VALUEFUNC(_wrap_SerializeInterface_serialize), -1);
   28360           6 :   SwigClassSerializeInterface.mark = 0;
   28361           6 :   SwigClassSerializeInterface.destroy = (void (*)(void *)) free_kdb_tools_SerializeInterface;
   28362           6 :   SwigClassSerializeInterface.trackObjects = 0;
   28363           6 :   rb_include_module(SwigClassSerializeInterface.klass, SwigClassSerializeInterface.mImpl);
   28364             :   
   28365           6 :   SwigClassMountBackendInterface.klass = rb_define_class_under(mKdbtools, "MountBackendInterface", rb_cObject);
   28366           6 :   SwigClassMountBackendInterface.mImpl = rb_define_module_under(SwigClassMountBackendInterface.klass, "Impl");
   28367           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__MountBackendInterface, (void *) &SwigClassMountBackendInterface);
   28368           6 :   rb_undef_alloc_func(SwigClassMountBackendInterface.klass);
   28369           6 :   rb_define_method(SwigClassMountBackendInterface.mImpl, "validated", VALUEFUNC(_wrap_MountBackendInterface_validated), -1);
   28370           6 :   rb_define_method(SwigClassMountBackendInterface.mImpl, "set_mountpoint", VALUEFUNC(_wrap_MountBackendInterface_set_mountpoint), -1);
   28371           6 :   rb_define_method(SwigClassMountBackendInterface.mImpl, "get_mountpoint", VALUEFUNC(_wrap_MountBackendInterface_get_mountpoint), -1);
   28372           6 :   rb_define_method(SwigClassMountBackendInterface.mImpl, "set_backend_config", VALUEFUNC(_wrap_MountBackendInterface_set_backend_config), -1);
   28373           6 :   rb_define_method(SwigClassMountBackendInterface.mImpl, "use_config_file", VALUEFUNC(_wrap_MountBackendInterface_use_config_file), -1);
   28374           6 :   rb_define_method(SwigClassMountBackendInterface.mImpl, "get_config_file", VALUEFUNC(_wrap_MountBackendInterface_get_config_file), -1);
   28375           6 :   rb_include_module(SwigClassMountBackendInterface.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__BackendInterface->clientdata)->mImpl);
   28376           6 :   rb_include_module(SwigClassMountBackendInterface.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__SerializeInterface->clientdata)->mImpl);
   28377           6 :   SwigClassMountBackendInterface.mark = 0;
   28378           6 :   SwigClassMountBackendInterface.destroy = (void (*)(void *)) free_kdb_tools_MountBackendInterface;
   28379           6 :   SwigClassMountBackendInterface.trackObjects = 0;
   28380           6 :   rb_include_module(SwigClassMountBackendInterface.klass, SwigClassMountBackendInterface.mImpl);
   28381             :   
   28382           6 :   SwigClassBackend.klass = rb_define_class_under(mKdbtools, "Backend", rb_cObject);
   28383           6 :   SwigClassBackend.mImpl = rb_define_module_under(SwigClassBackend.klass, "Impl");
   28384           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__Backend, (void *) &SwigClassBackend);
   28385           6 :   rb_define_alloc_func(SwigClassBackend.klass, _wrap_Backend_allocate);
   28386           6 :   rb_define_method(SwigClassBackend.klass, "initialize", VALUEFUNC(_wrap_new_Backend), -1);
   28387           6 :   rb_define_method(SwigClassBackend.mImpl, "status", VALUEFUNC(_wrap_Backend_status), -1);
   28388           6 :   rb_include_module(SwigClassBackend.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__MountBackendInterface->clientdata)->mImpl);
   28389           6 :   SwigClassBackend.mark = 0;
   28390           6 :   SwigClassBackend.destroy = (void (*)(void *)) free_kdb_tools_Backend;
   28391           6 :   SwigClassBackend.trackObjects = 0;
   28392           6 :   rb_include_module(SwigClassBackend.klass, SwigClassBackend.mImpl);
   28393             :   
   28394           6 :   SwigClassBackendFactory.klass = rb_define_class_under(mKdbtools, "BackendFactory", rb_cObject);
   28395           6 :   SwigClassBackendFactory.mImpl = rb_define_module_under(SwigClassBackendFactory.klass, "Impl");
   28396           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__BackendFactory, (void *) &SwigClassBackendFactory);
   28397           6 :   rb_define_alloc_func(SwigClassBackendFactory.klass, _wrap_BackendFactory_allocate);
   28398           6 :   rb_define_method(SwigClassBackendFactory.klass, "initialize", VALUEFUNC(_wrap_new_BackendFactory), -1);
   28399           6 :   rb_define_method(SwigClassBackendFactory.mImpl, "create", VALUEFUNC(_wrap_BackendFactory_create), -1);
   28400           6 :   SwigClassBackendFactory.mark = 0;
   28401           6 :   SwigClassBackendFactory.destroy = (void (*)(void *)) free_kdb_tools_BackendFactory;
   28402           6 :   SwigClassBackendFactory.trackObjects = 0;
   28403           6 :   rb_include_module(SwigClassBackendFactory.klass, SwigClassBackendFactory.mImpl);
   28404             :   
   28405           6 :   SwigClassPluginAdder.klass = rb_define_class_under(mKdbtools, "PluginAdder", rb_cObject);
   28406           6 :   SwigClassPluginAdder.mImpl = rb_define_module_under(SwigClassPluginAdder.klass, "Impl");
   28407           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__PluginAdder, (void *) &SwigClassPluginAdder);
   28408           6 :   rb_define_alloc_func(SwigClassPluginAdder.klass, _wrap_PluginAdder_allocate);
   28409           6 :   rb_define_method(SwigClassPluginAdder.klass, "initialize", VALUEFUNC(_wrap_new_PluginAdder), -1);
   28410           6 :   rb_include_module(SwigClassPluginAdder.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__BackendInterface->clientdata)->mImpl);
   28411           6 :   SwigClassPluginAdder.mark = 0;
   28412           6 :   SwigClassPluginAdder.destroy = (void (*)(void *)) free_kdb_tools_PluginAdder;
   28413           6 :   SwigClassPluginAdder.trackObjects = 0;
   28414           6 :   rb_include_module(SwigClassPluginAdder.klass, SwigClassPluginAdder.mImpl);
   28415             :   
   28416           6 :   SwigClassGlobalPlugins.klass = rb_define_class_under(mKdbtools, "GlobalPlugins", rb_cObject);
   28417           6 :   SwigClassGlobalPlugins.mImpl = rb_define_module_under(SwigClassGlobalPlugins.klass, "Impl");
   28418           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__GlobalPlugins, (void *) &SwigClassGlobalPlugins);
   28419           6 :   rb_define_alloc_func(SwigClassGlobalPlugins.klass, _wrap_GlobalPlugins_allocate);
   28420           6 :   rb_define_method(SwigClassGlobalPlugins.klass, "initialize", VALUEFUNC(_wrap_new_GlobalPlugins), -1);
   28421           6 :   rb_include_module(SwigClassGlobalPlugins.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginAdder->clientdata)->mImpl);
   28422           6 :   rb_include_module(SwigClassGlobalPlugins.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__SerializeInterface->clientdata)->mImpl);
   28423           6 :   SwigClassGlobalPlugins.mark = 0;
   28424           6 :   SwigClassGlobalPlugins.destroy = (void (*)(void *)) free_kdb_tools_GlobalPlugins;
   28425           6 :   SwigClassGlobalPlugins.trackObjects = 0;
   28426           6 :   rb_include_module(SwigClassGlobalPlugins.klass, SwigClassGlobalPlugins.mImpl);
   28427             :   
   28428           6 :   SwigClassImportExportBackend.klass = rb_define_class_under(mKdbtools, "ImportExportBackend", rb_cObject);
   28429           6 :   SwigClassImportExportBackend.mImpl = rb_define_module_under(SwigClassImportExportBackend.klass, "Impl");
   28430           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__ImportExportBackend, (void *) &SwigClassImportExportBackend);
   28431           6 :   rb_define_alloc_func(SwigClassImportExportBackend.klass, _wrap_ImportExportBackend_allocate);
   28432           6 :   rb_define_method(SwigClassImportExportBackend.klass, "initialize", VALUEFUNC(_wrap_new_ImportExportBackend), -1);
   28433           6 :   rb_define_method(SwigClassImportExportBackend.mImpl, "import_from_file", VALUEFUNC(_wrap_ImportExportBackend_import_from_file), -1);
   28434           6 :   rb_define_method(SwigClassImportExportBackend.mImpl, "export_to_file", VALUEFUNC(_wrap_ImportExportBackend_export_to_file), -1);
   28435           6 :   rb_define_method(SwigClassImportExportBackend.mImpl, "status", VALUEFUNC(_wrap_ImportExportBackend_status), -1);
   28436           6 :   rb_include_module(SwigClassImportExportBackend.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__PluginAdder->clientdata)->mImpl);
   28437           6 :   SwigClassImportExportBackend.mark = 0;
   28438           6 :   SwigClassImportExportBackend.destroy = (void (*)(void *)) free_kdb_tools_ImportExportBackend;
   28439           6 :   SwigClassImportExportBackend.trackObjects = 0;
   28440           6 :   rb_include_module(SwigClassImportExportBackend.klass, SwigClassImportExportBackend.mImpl);
   28441             :   
   28442           6 :   SwigClassBackendInfoVector.klass = rb_define_class_under(mKdbtools, "BackendInfoVector", rb_cObject);
   28443           6 :   SwigClassBackendInfoVector.mImpl = rb_define_module_under(SwigClassBackendInfoVector.klass, "Impl");
   28444           6 :   SWIG_TypeClientData(SWIGTYPE_p_std__vectorT_kdb__tools__BackendInfo_std__allocatorT_kdb__tools__BackendInfo_t_t, (void *) &SwigClassBackendInfoVector);
   28445           6 :   rb_include_module(SwigClassBackendInfoVector.klass, rb_eval_string("Enumerable"));
   28446           6 :   rb_define_alloc_func(SwigClassBackendInfoVector.klass, _wrap_BackendInfoVector_allocate);
   28447           6 :   rb_define_method(SwigClassBackendInfoVector.klass, "initialize", VALUEFUNC(_wrap_new_BackendInfoVector), -1);
   28448           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "dup", VALUEFUNC(_wrap_BackendInfoVector_dup), -1);
   28449           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "inspect", VALUEFUNC(_wrap_BackendInfoVector_inspect), -1);
   28450           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "to_a", VALUEFUNC(_wrap_BackendInfoVector_to_a), -1);
   28451           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "to_s", VALUEFUNC(_wrap_BackendInfoVector_to_s), -1);
   28452           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "slice", VALUEFUNC(_wrap_BackendInfoVector_slice), -1);
   28453           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "each", VALUEFUNC(_wrap_BackendInfoVector_each), -1);
   28454           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "__delete_2__", VALUEFUNC(_wrap_BackendInfoVector___delete_2__), -1);
   28455           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "select", VALUEFUNC(_wrap_BackendInfoVector_select), -1);
   28456           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "delete_at", VALUEFUNC(_wrap_BackendInfoVector_delete_at), -1);
   28457           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "at", VALUEFUNC(_wrap_BackendInfoVector_at), -1);
   28458           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "[]", VALUEFUNC(_wrap_BackendInfoVector___getitem__), -1);
   28459           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "[]=", VALUEFUNC(_wrap_BackendInfoVector___setitem__), -1);
   28460           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "reject_bang", VALUEFUNC(_wrap_BackendInfoVector_reject_bang), -1);
   28461           6 :   rb_define_alias(SwigClassBackendInfoVector.mImpl, "delete_if", "reject_bang");
   28462           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "pop", VALUEFUNC(_wrap_BackendInfoVector_pop), -1);
   28463           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "push", VALUEFUNC(_wrap_BackendInfoVector_push), -1);
   28464           6 :   rb_define_alias(SwigClassBackendInfoVector.mImpl, "<<", "push");
   28465           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "reject", VALUEFUNC(_wrap_BackendInfoVector_reject), -1);
   28466           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "shift", VALUEFUNC(_wrap_BackendInfoVector_shift), -1);
   28467           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "insert", VALUEFUNC(_wrap_BackendInfoVector_insert), -1);
   28468           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "unshift", VALUEFUNC(_wrap_BackendInfoVector_unshift), -1);
   28469           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "empty", VALUEFUNC(_wrap_BackendInfoVector_empty), -1);
   28470           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "size", VALUEFUNC(_wrap_BackendInfoVector_size), -1);
   28471           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "swap", VALUEFUNC(_wrap_BackendInfoVector_swap), -1);
   28472           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "clear", VALUEFUNC(_wrap_BackendInfoVector_clear), -1);
   28473           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "get_allocator", VALUEFUNC(_wrap_BackendInfoVector_get_allocator), -1);
   28474           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "front", VALUEFUNC(_wrap_BackendInfoVector_front), -1);
   28475           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "back", VALUEFUNC(_wrap_BackendInfoVector_back), -1);
   28476           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "assign", VALUEFUNC(_wrap_BackendInfoVector_assign), -1);
   28477           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "resize", VALUEFUNC(_wrap_BackendInfoVector_resize), -1);
   28478           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "reserve", VALUEFUNC(_wrap_BackendInfoVector_reserve), -1);
   28479           6 :   rb_define_method(SwigClassBackendInfoVector.mImpl, "capacity", VALUEFUNC(_wrap_BackendInfoVector_capacity), -1);
   28480           6 :   SwigClassBackendInfoVector.mark = 0;
   28481           6 :   SwigClassBackendInfoVector.destroy = (void (*)(void *)) free_std_vector_Sl_kdb_tools_BackendInfo_Sg_;
   28482           6 :   SwigClassBackendInfoVector.trackObjects = 0;
   28483           6 :   rb_include_module(SwigClassBackendInfoVector.klass, SwigClassBackendInfoVector.mImpl);
   28484           6 :   rb_define_const(mKdbtools, "MOUNTPOINTS_PATH", SWIG_FromCharPtr(kdb::tools::Backends::mountpointsPath));
   28485             :   
   28486           6 :   SwigClassBackendInfo.klass = rb_define_class_under(mKdbtools, "BackendInfo", rb_cObject);
   28487           6 :   SwigClassBackendInfo.mImpl = rb_define_module_under(SwigClassBackendInfo.klass, "Impl");
   28488           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__BackendInfo, (void *) &SwigClassBackendInfo);
   28489           6 :   rb_define_alloc_func(SwigClassBackendInfo.klass, _wrap_BackendInfo_allocate);
   28490           6 :   rb_define_method(SwigClassBackendInfo.klass, "initialize", VALUEFUNC(_wrap_new_BackendInfo), -1);
   28491           6 :   rb_define_method(SwigClassBackendInfo.mImpl, "name=", VALUEFUNC(_wrap_BackendInfo_name_set), -1);
   28492           6 :   rb_define_method(SwigClassBackendInfo.mImpl, "name", VALUEFUNC(_wrap_BackendInfo_name_get), -1);
   28493           6 :   rb_define_method(SwigClassBackendInfo.mImpl, "mountpoint=", VALUEFUNC(_wrap_BackendInfo_mountpoint_set), -1);
   28494           6 :   rb_define_method(SwigClassBackendInfo.mImpl, "mountpoint", VALUEFUNC(_wrap_BackendInfo_mountpoint_get), -1);
   28495           6 :   rb_define_method(SwigClassBackendInfo.mImpl, "path=", VALUEFUNC(_wrap_BackendInfo_path_set), -1);
   28496           6 :   rb_define_method(SwigClassBackendInfo.mImpl, "path", VALUEFUNC(_wrap_BackendInfo_path_get), -1);
   28497           6 :   SwigClassBackendInfo.mark = 0;
   28498           6 :   SwigClassBackendInfo.destroy = (void (*)(void *)) free_kdb_tools_BackendInfo;
   28499           6 :   SwigClassBackendInfo.trackObjects = 0;
   28500           6 :   rb_include_module(SwigClassBackendInfo.klass, SwigClassBackendInfo.mImpl);
   28501             :   
   28502           6 :   SwigClassBackends.klass = rb_define_class_under(mKdbtools, "Backends", rb_cObject);
   28503           6 :   SwigClassBackends.mImpl = rb_define_module_under(SwigClassBackends.klass, "Impl");
   28504           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__Backends, (void *) &SwigClassBackends);
   28505           6 :   rb_define_alloc_func(SwigClassBackends.klass, _wrap_Backends_allocate);
   28506           6 :   rb_define_method(SwigClassBackends.klass, "initialize", VALUEFUNC(_wrap_new_Backends), -1);
   28507           6 :   rb_define_singleton_method(SwigClassBackends.klass, "get_backend_info", VALUEFUNC(_wrap_Backends_get_backend_info), -1);
   28508           6 :   rb_define_singleton_method(SwigClassBackends.klass, "find_backend", VALUEFUNC(_wrap_Backends_find_backend), -1);
   28509           6 :   rb_define_singleton_method(SwigClassBackends.klass, "umount", VALUEFUNC(_wrap_Backends_umount), -1);
   28510           6 :   rb_define_singleton_method(SwigClassBackends.klass, "get_base_path", VALUEFUNC(_wrap_Backends_get_base_path), -1);
   28511           6 :   SwigClassBackends.mark = 0;
   28512           6 :   SwigClassBackends.destroy = (void (*)(void *)) free_kdb_tools_Backends;
   28513           6 :   SwigClassBackends.trackObjects = 0;
   28514           6 :   rb_include_module(SwigClassBackends.klass, SwigClassBackends.mImpl);
   28515           6 :   rb_define_const(mKdbtools, "GLOBAL_PLUGINS_PATH", SWIG_FromCharPtr(kdb::tools::GlobalPluginsBuilder::globalPluginsPath));
   28516             :   
   28517           6 :   SwigClassBackendBuilder.klass = rb_define_class_under(mKdbtools, "BackendBuilder", rb_cObject);
   28518           6 :   SwigClassBackendBuilder.mImpl = rb_define_module_under(SwigClassBackendBuilder.klass, "Impl");
   28519           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__BackendBuilder, (void *) &SwigClassBackendBuilder);
   28520           6 :   rb_define_alloc_func(SwigClassBackendBuilder.klass, _wrap_BackendBuilder_allocate);
   28521           6 :   rb_define_method(SwigClassBackendBuilder.klass, "initialize", VALUEFUNC(_wrap_new_BackendBuilder), -1);
   28522           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "get_plugin_database", VALUEFUNC(_wrap_BackendBuilder_get_plugin_database), -1);
   28523           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "get_backend_factory", VALUEFUNC(_wrap_BackendBuilder_get_backend_factory), -1);
   28524           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "add_plugins", VALUEFUNC(_wrap_BackendBuilder_add_plugins), -1);
   28525           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "rem_plugin", VALUEFUNC(_wrap_BackendBuilder_rem_plugin), -1);
   28526           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "need_metadata", VALUEFUNC(_wrap_BackendBuilder_need_metadata), -1);
   28527           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "need_plugin", VALUEFUNC(_wrap_BackendBuilder_need_plugin), -1);
   28528           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "resolve_needs", VALUEFUNC(_wrap_BackendBuilder_resolve_needs), -1);
   28529           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "recommend_plugin", VALUEFUNC(_wrap_BackendBuilder_recommend_plugin), -1);
   28530           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "fill_plugins", VALUEFUNC(_wrap_BackendBuilder_fill_plugins), -1);
   28531           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "backend_config=", VALUEFUNC(_wrap_BackendBuilder_backend_confige___), -1);
   28532           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "backend_config", VALUEFUNC(_wrap_BackendBuilder_backend_config), -1);
   28533           6 :   rb_define_method(SwigClassBackendBuilder.mImpl, "to_add", VALUEFUNC(_wrap_BackendBuilder_to_add), -1);
   28534           6 :   rb_include_module(SwigClassBackendBuilder.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__BackendInterface->clientdata)->mImpl);
   28535           6 :   SwigClassBackendBuilder.mark = 0;
   28536           6 :   SwigClassBackendBuilder.destroy = (void (*)(void *)) free_kdb_tools_BackendBuilder;
   28537           6 :   SwigClassBackendBuilder.trackObjects = 0;
   28538           6 :   rb_include_module(SwigClassBackendBuilder.klass, SwigClassBackendBuilder.mImpl);
   28539             :   
   28540           6 :   SwigClassGlobalPluginsBuilder.klass = rb_define_class_under(mKdbtools, "GlobalPluginsBuilder", rb_cObject);
   28541           6 :   SwigClassGlobalPluginsBuilder.mImpl = rb_define_module_under(SwigClassGlobalPluginsBuilder.klass, "Impl");
   28542           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__GlobalPluginsBuilder, (void *) &SwigClassGlobalPluginsBuilder);
   28543           6 :   rb_define_alloc_func(SwigClassGlobalPluginsBuilder.klass, _wrap_GlobalPluginsBuilder_allocate);
   28544           6 :   rb_define_method(SwigClassGlobalPluginsBuilder.klass, "initialize", VALUEFUNC(_wrap_new_GlobalPluginsBuilder), -1);
   28545           6 :   rb_define_method(SwigClassGlobalPluginsBuilder.mImpl, "serialize", VALUEFUNC(_wrap_GlobalPluginsBuilder_serialize), -1);
   28546           6 :   rb_include_module(SwigClassGlobalPluginsBuilder.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__BackendBuilder->clientdata)->mImpl);
   28547           6 :   SwigClassGlobalPluginsBuilder.mark = 0;
   28548           6 :   SwigClassGlobalPluginsBuilder.destroy = (void (*)(void *)) free_kdb_tools_GlobalPluginsBuilder;
   28549           6 :   SwigClassGlobalPluginsBuilder.trackObjects = 0;
   28550           6 :   rb_include_module(SwigClassGlobalPluginsBuilder.klass, SwigClassGlobalPluginsBuilder.mImpl);
   28551             :   
   28552           6 :   SwigClassMountBackendBuilder.klass = rb_define_class_under(mKdbtools, "MountBackendBuilder", rb_cObject);
   28553           6 :   SwigClassMountBackendBuilder.mImpl = rb_define_module_under(SwigClassMountBackendBuilder.klass, "Impl");
   28554           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__MountBackendBuilder, (void *) &SwigClassMountBackendBuilder);
   28555           6 :   rb_define_alloc_func(SwigClassMountBackendBuilder.klass, _wrap_MountBackendBuilder_allocate);
   28556           6 :   rb_define_method(SwigClassMountBackendBuilder.klass, "initialize", VALUEFUNC(_wrap_new_MountBackendBuilder), -1);
   28557           6 :   rb_include_module(SwigClassMountBackendBuilder.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__MountBackendInterface->clientdata)->mImpl);
   28558           6 :   rb_include_module(SwigClassMountBackendBuilder.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__BackendBuilder->clientdata)->mImpl);
   28559           6 :   SwigClassMountBackendBuilder.mark = 0;
   28560           6 :   SwigClassMountBackendBuilder.destroy = (void (*)(void *)) free_kdb_tools_MountBackendBuilder;
   28561           6 :   SwigClassMountBackendBuilder.trackObjects = 0;
   28562           6 :   rb_include_module(SwigClassMountBackendBuilder.klass, SwigClassMountBackendBuilder.mImpl);
   28563             :   
   28564           6 :   SwigClassSpecBackendBuilderMap.klass = rb_define_class_under(mKdbtools, "SpecBackendBuilderMap", rb_cObject);
   28565           6 :   SwigClassSpecBackendBuilderMap.mImpl = rb_define_module_under(SwigClassSpecBackendBuilderMap.klass, "Impl");
   28566           6 :   SWIG_TypeClientData(SWIGTYPE_p_std__mapT_kdb__Key_kdb__tools__SpecBackendBuilder_std__lessT_kdb__Key_t_std__allocatorT_std__pairT_kdb__Key_const_kdb__tools__SpecBackendBuilder_t_t_t, (void *) &SwigClassSpecBackendBuilderMap);
   28567           6 :   rb_include_module(SwigClassSpecBackendBuilderMap.klass, rb_eval_string("Enumerable"));
   28568           6 :   rb_define_alloc_func(SwigClassSpecBackendBuilderMap.klass, _wrap_SpecBackendBuilderMap_allocate);
   28569           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.klass, "initialize", VALUEFUNC(_wrap_new_SpecBackendBuilderMap), -1);
   28570           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "dup", VALUEFUNC(_wrap_SpecBackendBuilderMap_dup), -1);
   28571           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "__delete__", VALUEFUNC(_wrap_SpecBackendBuilderMap___delete__), -1);
   28572           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "has_key", VALUEFUNC(_wrap_SpecBackendBuilderMap_has_key), -1);
   28573           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "keys", VALUEFUNC(_wrap_SpecBackendBuilderMap_keys), -1);
   28574           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "each", VALUEFUNC(_wrap_SpecBackendBuilderMap_each), -1);
   28575           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "select", VALUEFUNC(_wrap_SpecBackendBuilderMap_select), -1);
   28576           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "values_at", VALUEFUNC(_wrap_SpecBackendBuilderMap_values_at), -1);
   28577           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "each_key", VALUEFUNC(_wrap_SpecBackendBuilderMap_each_key), -1);
   28578           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "values", VALUEFUNC(_wrap_SpecBackendBuilderMap_values), -1);
   28579           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "each_value", VALUEFUNC(_wrap_SpecBackendBuilderMap_each_value), -1);
   28580           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "entries", VALUEFUNC(_wrap_SpecBackendBuilderMap_entries), -1);
   28581           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "__contains__", VALUEFUNC(_wrap_SpecBackendBuilderMap___contains__), -1);
   28582           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "key_iterator", VALUEFUNC(_wrap_SpecBackendBuilderMap_key_iterator), -1);
   28583           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "value_iterator", VALUEFUNC(_wrap_SpecBackendBuilderMap_value_iterator), -1);
   28584           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "[]", VALUEFUNC(_wrap_SpecBackendBuilderMap___getitem__), -1);
   28585           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "[]=", VALUEFUNC(_wrap_SpecBackendBuilderMap___setitem__), -1);
   28586           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "inspect", VALUEFUNC(_wrap_SpecBackendBuilderMap_inspect), -1);
   28587           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "to_a", VALUEFUNC(_wrap_SpecBackendBuilderMap_to_a), -1);
   28588           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "to_s", VALUEFUNC(_wrap_SpecBackendBuilderMap_to_s), -1);
   28589           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "empty", VALUEFUNC(_wrap_SpecBackendBuilderMap_empty), -1);
   28590           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "size", VALUEFUNC(_wrap_SpecBackendBuilderMap_size), -1);
   28591           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "swap", VALUEFUNC(_wrap_SpecBackendBuilderMap_swap), -1);
   28592           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "clear", VALUEFUNC(_wrap_SpecBackendBuilderMap_clear), -1);
   28593           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "get_allocator", VALUEFUNC(_wrap_SpecBackendBuilderMap_get_allocator), -1);
   28594           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "erase", VALUEFUNC(_wrap_SpecBackendBuilderMap_erase), -1);
   28595           6 :   rb_define_method(SwigClassSpecBackendBuilderMap.mImpl, "count", VALUEFUNC(_wrap_SpecBackendBuilderMap_count), -1);
   28596           6 :   SwigClassSpecBackendBuilderMap.mark = 0;
   28597           6 :   SwigClassSpecBackendBuilderMap.destroy = (void (*)(void *)) free_std_map_Sl_kdb_Key_Sc_kdb_tools_SpecBackendBuilder_Sg_;
   28598           6 :   SwigClassSpecBackendBuilderMap.trackObjects = 0;
   28599           6 :   rb_include_module(SwigClassSpecBackendBuilderMap.klass, SwigClassSpecBackendBuilderMap.mImpl);
   28600             :   
   28601           6 :   SwigClassSpecBackendBuilder.klass = rb_define_class_under(mKdbtools, "SpecBackendBuilder", rb_cObject);
   28602           6 :   SwigClassSpecBackendBuilder.mImpl = rb_define_module_under(SwigClassSpecBackendBuilder.klass, "Impl");
   28603           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__SpecBackendBuilder, (void *) &SwigClassSpecBackendBuilder);
   28604           6 :   rb_define_alloc_func(SwigClassSpecBackendBuilder.klass, _wrap_SpecBackendBuilder_allocate);
   28605           6 :   rb_define_method(SwigClassSpecBackendBuilder.klass, "initialize", VALUEFUNC(_wrap_new_SpecBackendBuilder), -1);
   28606           6 :   rb_define_method(SwigClassSpecBackendBuilder.mImpl, "nodes=", VALUEFUNC(_wrap_SpecBackendBuilder_nodes_set), -1);
   28607           6 :   rb_define_method(SwigClassSpecBackendBuilder.mImpl, "nodes", VALUEFUNC(_wrap_SpecBackendBuilder_nodes_get), -1);
   28608           6 :   rb_include_module(SwigClassSpecBackendBuilder.mImpl, ((swig_class *) SWIGTYPE_p_kdb__tools__MountBackendBuilder->clientdata)->mImpl);
   28609           6 :   SwigClassSpecBackendBuilder.mark = 0;
   28610           6 :   SwigClassSpecBackendBuilder.destroy = (void (*)(void *)) free_kdb_tools_SpecBackendBuilder;
   28611           6 :   SwigClassSpecBackendBuilder.trackObjects = 0;
   28612           6 :   rb_include_module(SwigClassSpecBackendBuilder.klass, SwigClassSpecBackendBuilder.mImpl);
   28613             :   
   28614           6 :   SwigClassSpecReader.klass = rb_define_class_under(mKdbtools, "SpecReader", rb_cObject);
   28615           6 :   SwigClassSpecReader.mImpl = rb_define_module_under(SwigClassSpecReader.klass, "Impl");
   28616           6 :   SWIG_TypeClientData(SWIGTYPE_p_kdb__tools__SpecReader, (void *) &SwigClassSpecReader);
   28617           6 :   rb_define_alloc_func(SwigClassSpecReader.klass, _wrap_SpecReader_allocate);
   28618           6 :   rb_define_method(SwigClassSpecReader.klass, "initialize", VALUEFUNC(_wrap_new_SpecReader), -1);
   28619           6 :   rb_define_method(SwigClassSpecReader.mImpl, "get_backends", VALUEFUNC(_wrap_SpecReader_get_backends), -1);
   28620           6 :   rb_define_method(SwigClassSpecReader.mImpl, "read_specification", VALUEFUNC(_wrap_SpecReader_read_specification), -1);
   28621           6 :   SwigClassSpecReader.mark = 0;
   28622           6 :   SwigClassSpecReader.destroy = (void (*)(void *)) free_kdb_tools_SpecReader;
   28623           6 :   SwigClassSpecReader.trackObjects = 0;
   28624           6 :   rb_include_module(SwigClassSpecReader.klass, SwigClassSpecReader.mImpl);
   28625          24 : }
   28626             : 

Generated by: LCOV version 1.13