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 :
|