Line data Source code
1 : /* ----------------------------------------------------------------------------
2 : * This file was automatically generated by SWIG (http://www.swig.org).
3 : * Version 3.0.10
4 : *
5 : * This file is not intended to be easily readable and contains a number of
6 : * coding conventions designed to improve portability and efficiency. Do not make
7 : * changes to this file unless you know what you are doing--modify the SWIG
8 : * interface file instead.
9 : * ----------------------------------------------------------------------------- */
10 :
11 :
12 : #ifndef SWIGPYTHON
13 : #define SWIGPYTHON
14 : #endif
15 :
16 : #define SWIG_PYTHON_NO_BUILD_NONE
17 : #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
18 : #define SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
19 :
20 :
21 : #ifdef __cplusplus
22 : /* SwigValueWrapper is described in swig.swg */
23 : template<typename T> class SwigValueWrapper {
24 : struct SwigMovePointer {
25 : T *ptr;
26 : SwigMovePointer(T *p) : ptr(p) { }
27 : ~SwigMovePointer() { delete ptr; }
28 : SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
29 : } pointer;
30 : SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
31 : SwigValueWrapper(const SwigValueWrapper<T>& rhs);
32 : public:
33 : SwigValueWrapper() : pointer(0) { }
34 : SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
35 : operator T&() const { return *pointer.ptr; }
36 : T *operator&() { return pointer.ptr; }
37 : };
38 :
39 : template <typename T> T SwigValueInit() {
40 : return T();
41 : }
42 : #endif
43 :
44 : /* -----------------------------------------------------------------------------
45 : * This section contains generic SWIG labels for method/variable
46 : * declarations/attributes, and other compiler dependent labels.
47 : * ----------------------------------------------------------------------------- */
48 :
49 : /* template workaround for compilers that cannot correctly implement the C++ standard */
50 : #ifndef SWIGTEMPLATEDISAMBIGUATOR
51 : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
52 : # define SWIGTEMPLATEDISAMBIGUATOR template
53 : # elif defined(__HP_aCC)
54 : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
55 : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
56 : # define SWIGTEMPLATEDISAMBIGUATOR template
57 : # else
58 : # define SWIGTEMPLATEDISAMBIGUATOR
59 : # endif
60 : #endif
61 :
62 : /* inline attribute */
63 : #ifndef SWIGINLINE
64 : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
65 : # define SWIGINLINE inline
66 : # else
67 : # define SWIGINLINE
68 : # endif
69 : #endif
70 :
71 : /* attribute recognised by some compilers to avoid 'unused' warnings */
72 : #ifndef SWIGUNUSED
73 : # if defined(__GNUC__)
74 : # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
75 : # define SWIGUNUSED __attribute__ ((__unused__))
76 : # else
77 : # define SWIGUNUSED
78 : # endif
79 : # elif defined(__ICC)
80 : # define SWIGUNUSED __attribute__ ((__unused__))
81 : # else
82 : # define SWIGUNUSED
83 : # endif
84 : #endif
85 :
86 : #ifndef SWIG_MSC_UNSUPPRESS_4505
87 : # if defined(_MSC_VER)
88 : # pragma warning(disable : 4505) /* unreferenced local function has been removed */
89 : # endif
90 : #endif
91 :
92 : #ifndef SWIGUNUSEDPARM
93 : # ifdef __cplusplus
94 : # define SWIGUNUSEDPARM(p)
95 : # else
96 : # define SWIGUNUSEDPARM(p) p SWIGUNUSED
97 : # endif
98 : #endif
99 :
100 : /* internal SWIG method */
101 : #ifndef SWIGINTERN
102 : # define SWIGINTERN static SWIGUNUSED
103 : #endif
104 :
105 : /* internal inline SWIG method */
106 : #ifndef SWIGINTERNINLINE
107 : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
108 : #endif
109 :
110 : /* exporting methods */
111 : #if defined(__GNUC__)
112 : # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
113 : # ifndef GCC_HASCLASSVISIBILITY
114 : # define GCC_HASCLASSVISIBILITY
115 : # endif
116 : # endif
117 : #endif
118 :
119 : #ifndef SWIGEXPORT
120 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
121 : # if defined(STATIC_LINKED)
122 : # define SWIGEXPORT
123 : # else
124 : # define SWIGEXPORT __declspec(dllexport)
125 : # endif
126 : # else
127 : # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
128 : # define SWIGEXPORT __attribute__ ((visibility("default")))
129 : # else
130 : # define SWIGEXPORT
131 : # endif
132 : # endif
133 : #endif
134 :
135 : /* calling conventions for Windows */
136 : #ifndef SWIGSTDCALL
137 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
138 : # define SWIGSTDCALL __stdcall
139 : # else
140 : # define SWIGSTDCALL
141 : # endif
142 : #endif
143 :
144 : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
145 : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
146 : # define _CRT_SECURE_NO_DEPRECATE
147 : #endif
148 :
149 : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
150 : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
151 : # define _SCL_SECURE_NO_DEPRECATE
152 : #endif
153 :
154 : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
155 : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
156 : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
157 : #endif
158 :
159 : /* Intel's compiler complains if a variable which was never initialised is
160 : * cast to void, which is a common idiom which we use to indicate that we
161 : * are aware a variable isn't used. So we just silence that warning.
162 : * See: https://github.com/swig/swig/issues/192 for more discussion.
163 : */
164 : #ifdef __INTEL_COMPILER
165 : # pragma warning disable 592
166 : #endif
167 :
168 :
169 : #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
170 : /* Use debug wrappers with the Python release dll */
171 : # undef _DEBUG
172 : # include <Python.h>
173 : # define _DEBUG
174 : #else
175 : # include <Python.h>
176 : #endif
177 :
178 : /* -----------------------------------------------------------------------------
179 : * swigrun.swg
180 : *
181 : * This file contains generic C API SWIG runtime support for pointer
182 : * type checking.
183 : * ----------------------------------------------------------------------------- */
184 :
185 : /* This should only be incremented when either the layout of swig_type_info changes,
186 : or for whatever reason, the runtime changes incompatibly */
187 : #define SWIG_RUNTIME_VERSION "4"
188 :
189 : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
190 : #ifdef SWIG_TYPE_TABLE
191 : # define SWIG_QUOTE_STRING(x) #x
192 : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
193 : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
194 : #else
195 : # define SWIG_TYPE_TABLE_NAME
196 : #endif
197 :
198 : /*
199 : You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
200 : creating a static or dynamic library from the SWIG runtime code.
201 : In 99.9% of the cases, SWIG just needs to declare them as 'static'.
202 :
203 : But only do this if strictly necessary, ie, if you have problems
204 : with your compiler or suchlike.
205 : */
206 :
207 : #ifndef SWIGRUNTIME
208 : # define SWIGRUNTIME SWIGINTERN
209 : #endif
210 :
211 : #ifndef SWIGRUNTIMEINLINE
212 : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
213 : #endif
214 :
215 : /* Generic buffer size */
216 : #ifndef SWIG_BUFFER_SIZE
217 : # define SWIG_BUFFER_SIZE 1024
218 : #endif
219 :
220 : /* Flags for pointer conversions */
221 : #define SWIG_POINTER_DISOWN 0x1
222 : #define SWIG_CAST_NEW_MEMORY 0x2
223 :
224 : /* Flags for new pointer objects */
225 : #define SWIG_POINTER_OWN 0x1
226 :
227 :
228 : /*
229 : Flags/methods for returning states.
230 :
231 : The SWIG conversion methods, as ConvertPtr, return an integer
232 : that tells if the conversion was successful or not. And if not,
233 : an error code can be returned (see swigerrors.swg for the codes).
234 :
235 : Use the following macros/flags to set or process the returning
236 : states.
237 :
238 : In old versions of SWIG, code such as the following was usually written:
239 :
240 : if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
241 : // success code
242 : } else {
243 : //fail code
244 : }
245 :
246 : Now you can be more explicit:
247 :
248 : int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
249 : if (SWIG_IsOK(res)) {
250 : // success code
251 : } else {
252 : // fail code
253 : }
254 :
255 : which is the same really, but now you can also do
256 :
257 : Type *ptr;
258 : int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
259 : if (SWIG_IsOK(res)) {
260 : // success code
261 : if (SWIG_IsNewObj(res) {
262 : ...
263 : delete *ptr;
264 : } else {
265 : ...
266 : }
267 : } else {
268 : // fail code
269 : }
270 :
271 : I.e., now SWIG_ConvertPtr can return new objects and you can
272 : identify the case and take care of the deallocation. Of course that
273 : also requires SWIG_ConvertPtr to return new result values, such as
274 :
275 : int SWIG_ConvertPtr(obj, ptr,...) {
276 : if (<obj is ok>) {
277 : if (<need new object>) {
278 : *ptr = <ptr to new allocated object>;
279 : return SWIG_NEWOBJ;
280 : } else {
281 : *ptr = <ptr to old object>;
282 : return SWIG_OLDOBJ;
283 : }
284 : } else {
285 : return SWIG_BADOBJ;
286 : }
287 : }
288 :
289 : Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
290 : more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
291 : SWIG errors code.
292 :
293 : Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
294 : allows to return the 'cast rank', for example, if you have this
295 :
296 : int food(double)
297 : int fooi(int);
298 :
299 : and you call
300 :
301 : food(1) // cast rank '1' (1 -> 1.0)
302 : fooi(1) // cast rank '0'
303 :
304 : just use the SWIG_AddCast()/SWIG_CheckState()
305 : */
306 :
307 : #define SWIG_OK (0)
308 : #define SWIG_ERROR (-1)
309 : #define SWIG_IsOK(r) (r >= 0)
310 : #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
311 :
312 : /* The CastRankLimit says how many bits are used for the cast rank */
313 : #define SWIG_CASTRANKLIMIT (1 << 8)
314 : /* The NewMask denotes the object was created (using new/malloc) */
315 : #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
316 : /* The TmpMask is for in/out typemaps that use temporal objects */
317 : #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
318 : /* Simple returning values */
319 : #define SWIG_BADOBJ (SWIG_ERROR)
320 : #define SWIG_OLDOBJ (SWIG_OK)
321 : #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
322 : #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
323 : /* Check, add and del mask methods */
324 : #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
325 : #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
326 : #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
327 : #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
328 : #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
329 : #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
330 :
331 : /* Cast-Rank Mode */
332 : #if defined(SWIG_CASTRANK_MODE)
333 : # ifndef SWIG_TypeRank
334 : # define SWIG_TypeRank unsigned long
335 : # endif
336 : # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
337 : # define SWIG_MAXCASTRANK (2)
338 : # endif
339 : # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
340 : # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
341 : SWIGINTERNINLINE int SWIG_AddCast(int r) {
342 : return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
343 : }
344 : SWIGINTERNINLINE int SWIG_CheckState(int r) {
345 : return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
346 : }
347 : #else /* no cast-rank mode */
348 : # define SWIG_AddCast(r) (r)
349 : # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
350 : #endif
351 :
352 :
353 : #include <string.h>
354 :
355 : #ifdef __cplusplus
356 : extern "C" {
357 : #endif
358 :
359 : typedef void *(*swig_converter_func)(void *, int *);
360 : typedef struct swig_type_info *(*swig_dycast_func)(void **);
361 :
362 : /* Structure to store information on one type */
363 : typedef struct swig_type_info {
364 : const char *name; /* mangled name of this type */
365 : const char *str; /* human readable name of this type */
366 : swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
367 : struct swig_cast_info *cast; /* linked list of types that can cast into this type */
368 : void *clientdata; /* language specific type data */
369 : int owndata; /* flag if the structure owns the clientdata */
370 : } swig_type_info;
371 :
372 : /* Structure to store a type and conversion function used for casting */
373 : typedef struct swig_cast_info {
374 : swig_type_info *type; /* pointer to type that is equivalent to this type */
375 : swig_converter_func converter; /* function to cast the void pointers */
376 : struct swig_cast_info *next; /* pointer to next cast in linked list */
377 : struct swig_cast_info *prev; /* pointer to the previous cast */
378 : } swig_cast_info;
379 :
380 : /* Structure used to store module information
381 : * Each module generates one structure like this, and the runtime collects
382 : * all of these structures and stores them in a circularly linked list.*/
383 : typedef struct swig_module_info {
384 : swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
385 : size_t size; /* Number of types in this module */
386 : struct swig_module_info *next; /* Pointer to next element in circularly linked list */
387 : swig_type_info **type_initial; /* Array of initially generated type structures */
388 : swig_cast_info **cast_initial; /* Array of initially generated casting structures */
389 : void *clientdata; /* Language specific module data */
390 : } swig_module_info;
391 :
392 : /*
393 : Compare two type names skipping the space characters, therefore
394 : "char*" == "char *" and "Class<int>" == "Class<int >", etc.
395 :
396 : Return 0 when the two name types are equivalent, as in
397 : strncmp, but skipping ' '.
398 : */
399 : SWIGRUNTIME int
400 21 : SWIG_TypeNameComp(const char *f1, const char *l1,
401 : const char *f2, const char *l2) {
402 115 : for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
403 68 : while ((*f1 == ' ') && (f1 != l1)) ++f1;
404 70 : while ((*f2 == ' ') && (f2 != l2)) ++f2;
405 67 : if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
406 : }
407 1 : return (int)((l1 - f1) - (l2 - f2));
408 : }
409 :
410 : /*
411 : Check type equivalence in a name list like <name1>|<name2>|...
412 : Return 0 if equal, -1 if nb < tb, 1 if nb > tb
413 : */
414 : SWIGRUNTIME int
415 12 : SWIG_TypeCmp(const char *nb, const char *tb) {
416 12 : int equiv = 1;
417 12 : const char* te = tb + strlen(tb);
418 12 : const char* ne = nb;
419 33 : while (equiv != 0 && *ne) {
420 593 : for (nb = ne; *ne; ++ne) {
421 295 : if (*ne == '|') break;
422 : }
423 21 : equiv = SWIG_TypeNameComp(nb, ne, tb, te);
424 21 : if (*ne) ++ne;
425 : }
426 12 : return equiv;
427 : }
428 :
429 : /*
430 : Check type equivalence in a name list like <name1>|<name2>|...
431 : Return 0 if not equal, 1 if equal
432 : */
433 : SWIGRUNTIME int
434 : SWIG_TypeEquiv(const char *nb, const char *tb) {
435 12 : return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
436 : }
437 :
438 : /*
439 : Check the typename
440 : */
441 : SWIGRUNTIME swig_cast_info *
442 3 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
443 3 : if (ty) {
444 3 : swig_cast_info *iter = ty->cast;
445 9 : while (iter) {
446 3 : if (strcmp(iter->type->name, c) == 0) {
447 0 : if (iter == ty->cast)
448 : return iter;
449 : /* Move iter to the top of the linked list */
450 0 : iter->prev->next = iter->next;
451 0 : if (iter->next)
452 0 : iter->next->prev = iter->prev;
453 0 : iter->next = ty->cast;
454 0 : iter->prev = 0;
455 0 : if (ty->cast) ty->cast->prev = iter;
456 0 : ty->cast = iter;
457 0 : return iter;
458 : }
459 3 : iter = iter->next;
460 : }
461 : }
462 : return 0;
463 : }
464 :
465 : /*
466 : Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
467 : */
468 : SWIGRUNTIME swig_cast_info *
469 : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
470 : if (ty) {
471 : swig_cast_info *iter = ty->cast;
472 : while (iter) {
473 : if (iter->type == from) {
474 : if (iter == ty->cast)
475 : return iter;
476 : /* Move iter to the top of the linked list */
477 : iter->prev->next = iter->next;
478 : if (iter->next)
479 : iter->next->prev = iter->prev;
480 : iter->next = ty->cast;
481 : iter->prev = 0;
482 : if (ty->cast) ty->cast->prev = iter;
483 : ty->cast = iter;
484 : return iter;
485 : }
486 : iter = iter->next;
487 : }
488 : }
489 : return 0;
490 : }
491 :
492 : /*
493 : Cast a pointer up an inheritance hierarchy
494 : */
495 : SWIGRUNTIMEINLINE void *
496 : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
497 0 : return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
498 : }
499 :
500 : /*
501 : Dynamic pointer casting. Down an inheritance hierarchy
502 : */
503 : SWIGRUNTIME swig_type_info *
504 : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
505 : swig_type_info *lastty = ty;
506 : if (!ty || !ty->dcast) return ty;
507 : while (ty && (ty->dcast)) {
508 : ty = (*ty->dcast)(ptr);
509 : if (ty) lastty = ty;
510 : }
511 : return lastty;
512 : }
513 :
514 : /*
515 : Return the name associated with this type
516 : */
517 : SWIGRUNTIMEINLINE const char *
518 : SWIG_TypeName(const swig_type_info *ty) {
519 : return ty->name;
520 : }
521 :
522 : /*
523 : Return the pretty name associated with this type,
524 : that is an unmangled type name in a form presentable to the user.
525 : */
526 : SWIGRUNTIME const char *
527 : SWIG_TypePrettyName(const swig_type_info *type) {
528 : /* The "str" field contains the equivalent pretty names of the
529 : type, separated by vertical-bar characters. We choose
530 : to print the last name, as it is often (?) the most
531 : specific. */
532 0 : if (!type) return NULL;
533 0 : if (type->str != NULL) {
534 : const char *last_name = type->str;
535 : const char *s;
536 0 : for (s = type->str; *s; s++)
537 0 : if (*s == '|') last_name = s+1;
538 : return last_name;
539 : }
540 : else
541 0 : return type->name;
542 : }
543 :
544 : /*
545 : Set the clientdata field for a type
546 : */
547 : SWIGRUNTIME void
548 36 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
549 36 : swig_cast_info *cast = ti->cast;
550 : /* if (ti->clientdata == clientdata) return; */
551 36 : ti->clientdata = clientdata;
552 :
553 105 : while (cast) {
554 69 : if (!cast->converter) {
555 36 : swig_type_info *tc = cast->type;
556 36 : if (!tc->clientdata) {
557 0 : SWIG_TypeClientData(tc, clientdata);
558 : }
559 : }
560 69 : cast = cast->next;
561 : }
562 36 : }
563 : SWIGRUNTIME void
564 : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
565 36 : SWIG_TypeClientData(ti, clientdata);
566 36 : ti->owndata = 1;
567 : }
568 :
569 : /*
570 : Search for a swig_type_info structure only by mangled name
571 : Search is a O(log #types)
572 :
573 : We start searching at module start, and finish searching when start == end.
574 : Note: if start == end at the beginning of the function, we go all the way around
575 : the circular list.
576 : */
577 : SWIGRUNTIME swig_type_info *
578 1 : SWIG_MangledTypeQueryModule(swig_module_info *start,
579 : swig_module_info *end,
580 : const char *name) {
581 1 : swig_module_info *iter = start;
582 : do {
583 1 : if (iter->size) {
584 1 : size_t l = 0;
585 1 : size_t r = iter->size - 1;
586 : do {
587 : /* since l+r >= 0, we can (>> 1) instead (/ 2) */
588 5 : size_t i = (l + r) >> 1;
589 5 : const char *iname = iter->types[i]->name;
590 5 : if (iname) {
591 5 : int compare = strcmp(name, iname);
592 5 : if (compare == 0) {
593 : return iter->types[i];
594 5 : } else if (compare < 0) {
595 0 : if (i) {
596 0 : r = i - 1;
597 : } else {
598 : break;
599 : }
600 5 : } else if (compare > 0) {
601 5 : l = i + 1;
602 : }
603 : } else {
604 : break; /* should never happen */
605 : }
606 5 : } while (l <= r);
607 : }
608 1 : iter = iter->next;
609 1 : } while (iter != end);
610 : return 0;
611 : }
612 :
613 : /*
614 : Search for a swig_type_info structure for either a mangled name or a human readable name.
615 : It first searches the mangled names of the types, which is a O(log #types)
616 : If a type is not found it then searches the human readable names, which is O(#types).
617 :
618 : We start searching at module start, and finish searching when start == end.
619 : Note: if start == end at the beginning of the function, we go all the way around
620 : the circular list.
621 : */
622 : SWIGRUNTIME swig_type_info *
623 1 : SWIG_TypeQueryModule(swig_module_info *start,
624 : swig_module_info *end,
625 : const char *name) {
626 : /* STEP 1: Search the name field using binary search */
627 1 : swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
628 1 : if (ret) {
629 : return ret;
630 : } else {
631 : /* STEP 2: If the type hasn't been found, do a complete search
632 : of the str field (the human readable name) */
633 : swig_module_info *iter = start;
634 : do {
635 1 : size_t i = 0;
636 23 : for (; i < iter->size; ++i) {
637 24 : if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
638 : return iter->types[i];
639 : }
640 0 : iter = iter->next;
641 0 : } while (iter != end);
642 : }
643 :
644 : /* neither found a match */
645 : return 0;
646 : }
647 :
648 : /*
649 : Pack binary data into a string
650 : */
651 : SWIGRUNTIME char *
652 : SWIG_PackData(char *c, void *ptr, size_t sz) {
653 : static const char hex[17] = "0123456789abcdef";
654 0 : const unsigned char *u = (unsigned char *) ptr;
655 0 : const unsigned char *eu = u + sz;
656 0 : for (; u != eu; ++u) {
657 0 : unsigned char uu = *u;
658 0 : *(c++) = hex[(uu & 0xf0) >> 4];
659 0 : *(c++) = hex[uu & 0xf];
660 : }
661 : return c;
662 : }
663 :
664 : /*
665 : Unpack binary data from a string
666 : */
667 : SWIGRUNTIME const char *
668 0 : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
669 0 : unsigned char *u = (unsigned char *) ptr;
670 0 : const unsigned char *eu = u + sz;
671 0 : for (; u != eu; ++u) {
672 0 : char d = *(c++);
673 : unsigned char uu;
674 0 : if ((d >= '0') && (d <= '9'))
675 0 : uu = (unsigned char)((d - '0') << 4);
676 0 : else if ((d >= 'a') && (d <= 'f'))
677 0 : uu = (unsigned char)((d - ('a'-10)) << 4);
678 : else
679 : return (char *) 0;
680 0 : d = *(c++);
681 0 : if ((d >= '0') && (d <= '9'))
682 0 : uu |= (unsigned char)(d - '0');
683 0 : else if ((d >= 'a') && (d <= 'f'))
684 0 : uu |= (unsigned char)(d - ('a'-10));
685 : else
686 : return (char *) 0;
687 0 : *u = uu;
688 : }
689 : return c;
690 : }
691 :
692 : /*
693 : Pack 'void *' into a string buffer.
694 : */
695 : SWIGRUNTIME char *
696 0 : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
697 0 : char *r = buff;
698 0 : if ((2*sizeof(void *) + 2) > bsz) return 0;
699 0 : *(r++) = '_';
700 0 : r = SWIG_PackData(r,&ptr,sizeof(void *));
701 0 : if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
702 0 : strcpy(r,name);
703 0 : return buff;
704 : }
705 :
706 : SWIGRUNTIME const char *
707 0 : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
708 0 : if (*c != '_') {
709 0 : if (strcmp(c,"NULL") == 0) {
710 0 : *ptr = (void *) 0;
711 0 : return name;
712 : } else {
713 : return 0;
714 : }
715 : }
716 0 : return SWIG_UnpackData(++c,ptr,sizeof(void *));
717 : }
718 :
719 : SWIGRUNTIME char *
720 0 : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
721 0 : char *r = buff;
722 0 : size_t lname = (name ? strlen(name) : 0);
723 0 : if ((2*sz + 2 + lname) > bsz) return 0;
724 0 : *(r++) = '_';
725 0 : r = SWIG_PackData(r,ptr,sz);
726 0 : if (lname) {
727 0 : strncpy(r,name,lname+1);
728 : } else {
729 0 : *r = 0;
730 : }
731 : return buff;
732 : }
733 :
734 : SWIGRUNTIME const char *
735 : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
736 : if (*c != '_') {
737 : if (strcmp(c,"NULL") == 0) {
738 : memset(ptr,0,sz);
739 : return name;
740 : } else {
741 : return 0;
742 : }
743 : }
744 : return SWIG_UnpackData(++c,ptr,sz);
745 : }
746 :
747 : #ifdef __cplusplus
748 : }
749 : #endif
750 :
751 : /* Errors in SWIG */
752 : #define SWIG_UnknownError -1
753 : #define SWIG_IOError -2
754 : #define SWIG_RuntimeError -3
755 : #define SWIG_IndexError -4
756 : #define SWIG_TypeError -5
757 : #define SWIG_DivisionByZero -6
758 : #define SWIG_OverflowError -7
759 : #define SWIG_SyntaxError -8
760 : #define SWIG_ValueError -9
761 : #define SWIG_SystemError -10
762 : #define SWIG_AttributeError -11
763 : #define SWIG_MemoryError -12
764 : #define SWIG_NullReferenceError -13
765 :
766 :
767 :
768 : /* Compatibility macros for Python 3 */
769 : #if PY_VERSION_HEX >= 0x03000000
770 :
771 : #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
772 : #define PyInt_Check(x) PyLong_Check(x)
773 : #define PyInt_AsLong(x) PyLong_AsLong(x)
774 : #define PyInt_FromLong(x) PyLong_FromLong(x)
775 : #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
776 : #define PyString_Check(name) PyBytes_Check(name)
777 : #define PyString_FromString(x) PyUnicode_FromString(x)
778 : #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
779 : #define PyString_AsString(str) PyBytes_AsString(str)
780 : #define PyString_Size(str) PyBytes_Size(str)
781 : #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
782 : #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
783 : #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
784 : #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
785 :
786 : #endif
787 :
788 : #ifndef Py_TYPE
789 : # define Py_TYPE(op) ((op)->ob_type)
790 : #endif
791 :
792 : /* SWIG APIs for compatibility of both Python 2 & 3 */
793 :
794 : #if PY_VERSION_HEX >= 0x03000000
795 : # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
796 : #else
797 : # define SWIG_Python_str_FromFormat PyString_FromFormat
798 : #endif
799 :
800 :
801 : /* Warning: This function will allocate a new string in Python 3,
802 : * so please call SWIG_Python_str_DelForPy3(x) to free the space.
803 : */
804 : SWIGINTERN char*
805 : SWIG_Python_str_AsChar(PyObject *str)
806 : {
807 : #if PY_VERSION_HEX >= 0x03000000
808 : char *cstr;
809 : char *newstr;
810 : Py_ssize_t len;
811 : str = PyUnicode_AsUTF8String(str);
812 : PyBytes_AsStringAndSize(str, &cstr, &len);
813 : newstr = (char *) malloc(len+1);
814 : memcpy(newstr, cstr, len+1);
815 : Py_XDECREF(str);
816 : return newstr;
817 : #else
818 0 : return PyString_AsString(str);
819 : #endif
820 : }
821 :
822 : #if PY_VERSION_HEX >= 0x03000000
823 : # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
824 : #else
825 : # define SWIG_Python_str_DelForPy3(x)
826 : #endif
827 :
828 :
829 : SWIGINTERN PyObject*
830 : SWIG_Python_str_FromChar(const char *c)
831 : {
832 : #if PY_VERSION_HEX >= 0x03000000
833 : return PyUnicode_FromString(c);
834 : #else
835 4 : return PyString_FromString(c);
836 : #endif
837 : }
838 :
839 : /* Add PyOS_snprintf for old Pythons */
840 : #if PY_VERSION_HEX < 0x02020000
841 : # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
842 : # define PyOS_snprintf _snprintf
843 : # else
844 : # define PyOS_snprintf snprintf
845 : # endif
846 : #endif
847 :
848 : /* A crude PyString_FromFormat implementation for old Pythons */
849 : #if PY_VERSION_HEX < 0x02020000
850 :
851 : #ifndef SWIG_PYBUFFER_SIZE
852 : # define SWIG_PYBUFFER_SIZE 1024
853 : #endif
854 :
855 : static PyObject *
856 : PyString_FromFormat(const char *fmt, ...) {
857 : va_list ap;
858 : char buf[SWIG_PYBUFFER_SIZE * 2];
859 : int res;
860 : va_start(ap, fmt);
861 : res = vsnprintf(buf, sizeof(buf), fmt, ap);
862 : va_end(ap);
863 : return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
864 : }
865 : #endif
866 :
867 : #ifndef PyObject_DEL
868 : # define PyObject_DEL PyObject_Del
869 : #endif
870 :
871 : /* A crude PyExc_StopIteration exception for old Pythons */
872 : #if PY_VERSION_HEX < 0x02020000
873 : # ifndef PyExc_StopIteration
874 : # define PyExc_StopIteration PyExc_RuntimeError
875 : # endif
876 : # ifndef PyObject_GenericGetAttr
877 : # define PyObject_GenericGetAttr 0
878 : # endif
879 : #endif
880 :
881 : /* Py_NotImplemented is defined in 2.1 and up. */
882 : #if PY_VERSION_HEX < 0x02010000
883 : # ifndef Py_NotImplemented
884 : # define Py_NotImplemented PyExc_RuntimeError
885 : # endif
886 : #endif
887 :
888 : /* A crude PyString_AsStringAndSize implementation for old Pythons */
889 : #if PY_VERSION_HEX < 0x02010000
890 : # ifndef PyString_AsStringAndSize
891 : # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
892 : # endif
893 : #endif
894 :
895 : /* PySequence_Size for old Pythons */
896 : #if PY_VERSION_HEX < 0x02000000
897 : # ifndef PySequence_Size
898 : # define PySequence_Size PySequence_Length
899 : # endif
900 : #endif
901 :
902 : /* PyBool_FromLong for old Pythons */
903 : #if PY_VERSION_HEX < 0x02030000
904 : static
905 : PyObject *PyBool_FromLong(long ok)
906 : {
907 : PyObject *result = ok ? Py_True : Py_False;
908 : Py_INCREF(result);
909 : return result;
910 : }
911 : #endif
912 :
913 : /* Py_ssize_t for old Pythons */
914 : /* This code is as recommended by: */
915 : /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
916 : #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
917 : typedef int Py_ssize_t;
918 : # define PY_SSIZE_T_MAX INT_MAX
919 : # define PY_SSIZE_T_MIN INT_MIN
920 : typedef inquiry lenfunc;
921 : typedef intargfunc ssizeargfunc;
922 : typedef intintargfunc ssizessizeargfunc;
923 : typedef intobjargproc ssizeobjargproc;
924 : typedef intintobjargproc ssizessizeobjargproc;
925 : typedef getreadbufferproc readbufferproc;
926 : typedef getwritebufferproc writebufferproc;
927 : typedef getsegcountproc segcountproc;
928 : typedef getcharbufferproc charbufferproc;
929 : static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
930 : {
931 : long result = 0;
932 : PyObject *i = PyNumber_Int(x);
933 : if (i) {
934 : result = PyInt_AsLong(i);
935 : Py_DECREF(i);
936 : }
937 : return result;
938 : }
939 : #endif
940 :
941 : #if PY_VERSION_HEX < 0x02050000
942 : #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
943 : #endif
944 :
945 : #if PY_VERSION_HEX < 0x02040000
946 : #define Py_VISIT(op) \
947 : do { \
948 : if (op) { \
949 : int vret = visit((op), arg); \
950 : if (vret) \
951 : return vret; \
952 : } \
953 : } while (0)
954 : #endif
955 :
956 : #if PY_VERSION_HEX < 0x02030000
957 : typedef struct {
958 : PyTypeObject type;
959 : PyNumberMethods as_number;
960 : PyMappingMethods as_mapping;
961 : PySequenceMethods as_sequence;
962 : PyBufferProcs as_buffer;
963 : PyObject *name, *slots;
964 : } PyHeapTypeObject;
965 : #endif
966 :
967 : #if PY_VERSION_HEX < 0x02030000
968 : typedef destructor freefunc;
969 : #endif
970 :
971 : #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
972 : (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
973 : (PY_MAJOR_VERSION > 3))
974 : # define SWIGPY_USE_CAPSULE
975 : # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
976 : #endif
977 :
978 : #if PY_VERSION_HEX < 0x03020000
979 : #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
980 : #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
981 : #endif
982 :
983 : /* -----------------------------------------------------------------------------
984 : * error manipulation
985 : * ----------------------------------------------------------------------------- */
986 :
987 : SWIGRUNTIME PyObject*
988 0 : SWIG_Python_ErrorType(int code) {
989 0 : PyObject* type = 0;
990 0 : switch(code) {
991 : case SWIG_MemoryError:
992 0 : type = PyExc_MemoryError;
993 0 : break;
994 : case SWIG_IOError:
995 0 : type = PyExc_IOError;
996 0 : break;
997 : case SWIG_RuntimeError:
998 0 : type = PyExc_RuntimeError;
999 0 : break;
1000 : case SWIG_IndexError:
1001 0 : type = PyExc_IndexError;
1002 0 : break;
1003 : case SWIG_TypeError:
1004 0 : type = PyExc_TypeError;
1005 0 : break;
1006 : case SWIG_DivisionByZero:
1007 0 : type = PyExc_ZeroDivisionError;
1008 0 : break;
1009 : case SWIG_OverflowError:
1010 0 : type = PyExc_OverflowError;
1011 0 : break;
1012 : case SWIG_SyntaxError:
1013 0 : type = PyExc_SyntaxError;
1014 0 : break;
1015 : case SWIG_ValueError:
1016 0 : type = PyExc_ValueError;
1017 0 : break;
1018 : case SWIG_SystemError:
1019 0 : type = PyExc_SystemError;
1020 0 : break;
1021 : case SWIG_AttributeError:
1022 0 : type = PyExc_AttributeError;
1023 0 : break;
1024 : default:
1025 0 : type = PyExc_RuntimeError;
1026 : }
1027 0 : return type;
1028 : }
1029 :
1030 :
1031 : SWIGRUNTIME void
1032 : SWIG_Python_AddErrorMsg(const char* mesg)
1033 : {
1034 : PyObject *type = 0;
1035 : PyObject *value = 0;
1036 : PyObject *traceback = 0;
1037 :
1038 : if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1039 : if (value) {
1040 : char *tmp;
1041 : PyObject *old_str = PyObject_Str(value);
1042 : PyErr_Clear();
1043 : Py_XINCREF(type);
1044 :
1045 : PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1046 : SWIG_Python_str_DelForPy3(tmp);
1047 : Py_DECREF(old_str);
1048 : Py_DECREF(value);
1049 : } else {
1050 : PyErr_SetString(PyExc_RuntimeError, mesg);
1051 : }
1052 : }
1053 :
1054 : #if defined(SWIG_PYTHON_NO_THREADS)
1055 : # if defined(SWIG_PYTHON_THREADS)
1056 : # undef SWIG_PYTHON_THREADS
1057 : # endif
1058 : #endif
1059 : #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1060 : # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1061 : # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1062 : # define SWIG_PYTHON_USE_GIL
1063 : # endif
1064 : # endif
1065 : # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1066 : # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1067 : # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1068 : # endif
1069 : # ifdef __cplusplus /* C++ code */
1070 : class SWIG_Python_Thread_Block {
1071 : bool status;
1072 : PyGILState_STATE state;
1073 : public:
1074 : void end() { if (status) { PyGILState_Release(state); status = false;} }
1075 : SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1076 : ~SWIG_Python_Thread_Block() { end(); }
1077 : };
1078 : class SWIG_Python_Thread_Allow {
1079 : bool status;
1080 : PyThreadState *save;
1081 : public:
1082 : void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1083 : SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1084 : ~SWIG_Python_Thread_Allow() { end(); }
1085 : };
1086 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1087 : # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1088 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1089 : # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1090 : # else /* C code */
1091 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1092 : # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1093 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1094 : # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1095 : # endif
1096 : # else /* Old thread way, not implemented, user must provide it */
1097 : # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1098 : # define SWIG_PYTHON_INITIALIZE_THREADS
1099 : # endif
1100 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1101 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1102 : # endif
1103 : # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1104 : # define SWIG_PYTHON_THREAD_END_BLOCK
1105 : # endif
1106 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1107 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1108 : # endif
1109 : # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1110 : # define SWIG_PYTHON_THREAD_END_ALLOW
1111 : # endif
1112 : # endif
1113 : #else /* No thread support */
1114 : # define SWIG_PYTHON_INITIALIZE_THREADS
1115 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1116 : # define SWIG_PYTHON_THREAD_END_BLOCK
1117 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1118 : # define SWIG_PYTHON_THREAD_END_ALLOW
1119 : #endif
1120 :
1121 : /* -----------------------------------------------------------------------------
1122 : * Python API portion that goes into the runtime
1123 : * ----------------------------------------------------------------------------- */
1124 :
1125 : #ifdef __cplusplus
1126 : extern "C" {
1127 : #endif
1128 :
1129 : /* -----------------------------------------------------------------------------
1130 : * Constant declarations
1131 : * ----------------------------------------------------------------------------- */
1132 :
1133 : /* Constant Types */
1134 : #define SWIG_PY_POINTER 4
1135 : #define SWIG_PY_BINARY 5
1136 :
1137 : /* Constant information structure */
1138 : typedef struct swig_const_info {
1139 : int type;
1140 : char *name;
1141 : long lvalue;
1142 : double dvalue;
1143 : void *pvalue;
1144 : swig_type_info **ptype;
1145 : } swig_const_info;
1146 :
1147 :
1148 : /* -----------------------------------------------------------------------------
1149 : * Wrapper of PyInstanceMethod_New() used in Python 3
1150 : * It is exported to the generated module, used for -fastproxy
1151 : * ----------------------------------------------------------------------------- */
1152 : #if PY_VERSION_HEX >= 0x03000000
1153 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1154 : {
1155 : return PyInstanceMethod_New(func);
1156 : }
1157 : #else
1158 0 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1159 : {
1160 0 : return NULL;
1161 : }
1162 : #endif
1163 :
1164 : #ifdef __cplusplus
1165 : }
1166 : #endif
1167 :
1168 :
1169 : /* -----------------------------------------------------------------------------
1170 : * pyrun.swg
1171 : *
1172 : * This file contains the runtime support for Python modules
1173 : * and includes code for managing global variables and pointer
1174 : * type checking.
1175 : *
1176 : * ----------------------------------------------------------------------------- */
1177 :
1178 : /* Common SWIG API */
1179 :
1180 : /* for raw pointers */
1181 : #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1182 : #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1183 : #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1184 :
1185 : #ifdef SWIGPYTHON_BUILTIN
1186 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1187 : #else
1188 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1189 : #endif
1190 :
1191 : #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1192 :
1193 : #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1194 : #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1195 : #define swig_owntype int
1196 :
1197 : /* for raw packed data */
1198 : #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1199 : #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1200 :
1201 : /* for class or struct pointers */
1202 : #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1203 : #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1204 :
1205 : /* for C or C++ function pointers */
1206 : #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1207 : #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1208 :
1209 : /* for C++ member pointers, ie, member methods */
1210 : #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1211 : #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1212 :
1213 :
1214 : /* Runtime API */
1215 :
1216 : #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1217 : #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1218 : #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1219 :
1220 : #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1221 : #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1222 : #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1223 : #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1224 : #define SWIG_fail goto fail
1225 :
1226 :
1227 : /* Runtime API implementation */
1228 :
1229 : /* Error manipulation */
1230 :
1231 : SWIGINTERN void
1232 6 : SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1233 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1234 6 : PyErr_SetObject(errtype, obj);
1235 6 : Py_DECREF(obj);
1236 : SWIG_PYTHON_THREAD_END_BLOCK;
1237 6 : }
1238 :
1239 : SWIGINTERN void
1240 : SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1241 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1242 0 : PyErr_SetString(errtype, msg);
1243 : SWIG_PYTHON_THREAD_END_BLOCK;
1244 : }
1245 :
1246 : #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1247 :
1248 : /* Set a constant value */
1249 :
1250 : #if defined(SWIGPYTHON_BUILTIN)
1251 :
1252 : SWIGINTERN void
1253 : SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1254 : PyObject *s = PyString_InternFromString(key);
1255 : PyList_Append(seq, s);
1256 : Py_DECREF(s);
1257 : }
1258 :
1259 : SWIGINTERN void
1260 : SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1261 : #if PY_VERSION_HEX < 0x02030000
1262 : PyDict_SetItemString(d, (char *)name, obj);
1263 : #else
1264 : PyDict_SetItemString(d, name, obj);
1265 : #endif
1266 : Py_DECREF(obj);
1267 : if (public_interface)
1268 : SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1269 : }
1270 :
1271 : #else
1272 :
1273 : SWIGINTERN void
1274 174 : SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1275 : #if PY_VERSION_HEX < 0x02030000
1276 : PyDict_SetItemString(d, (char *)name, obj);
1277 : #else
1278 174 : PyDict_SetItemString(d, name, obj);
1279 : #endif
1280 174 : Py_DECREF(obj);
1281 174 : }
1282 :
1283 : #endif
1284 :
1285 : /* Append a value to the result obj */
1286 :
1287 : SWIGINTERN PyObject*
1288 : SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1289 : #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1290 : if (!result) {
1291 : result = obj;
1292 : } else if (result == Py_None) {
1293 : Py_DECREF(result);
1294 : result = obj;
1295 : } else {
1296 : if (!PyList_Check(result)) {
1297 : PyObject *o2 = result;
1298 : result = PyList_New(1);
1299 : PyList_SetItem(result, 0, o2);
1300 : }
1301 : PyList_Append(result,obj);
1302 : Py_DECREF(obj);
1303 : }
1304 : return result;
1305 : #else
1306 : PyObject* o2;
1307 : PyObject* o3;
1308 : if (!result) {
1309 : result = obj;
1310 : } else if (result == Py_None) {
1311 : Py_DECREF(result);
1312 : result = obj;
1313 : } else {
1314 : if (!PyTuple_Check(result)) {
1315 : o2 = result;
1316 : result = PyTuple_New(1);
1317 : PyTuple_SET_ITEM(result, 0, o2);
1318 : }
1319 : o3 = PyTuple_New(1);
1320 : PyTuple_SET_ITEM(o3, 0, obj);
1321 : o2 = result;
1322 : result = PySequence_Concat(o2, o3);
1323 : Py_DECREF(o2);
1324 : Py_DECREF(o3);
1325 : }
1326 : return result;
1327 : #endif
1328 : }
1329 :
1330 : /* Unpack the argument tuple */
1331 :
1332 : SWIGINTERN Py_ssize_t
1333 475 : SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1334 : {
1335 475 : if (!args) {
1336 0 : if (!min && !max) {
1337 : return 1;
1338 : } else {
1339 0 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1340 0 : name, (min == max ? "" : "at least "), (int)min);
1341 0 : return 0;
1342 : }
1343 : }
1344 475 : if (!PyTuple_Check(args)) {
1345 0 : if (min <= 1 && max >= 1) {
1346 : Py_ssize_t i;
1347 0 : objs[0] = args;
1348 0 : for (i = 1; i < max; ++i) {
1349 0 : objs[i] = 0;
1350 : }
1351 : return 2;
1352 : }
1353 0 : PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1354 0 : return 0;
1355 : } else {
1356 475 : Py_ssize_t l = PyTuple_GET_SIZE(args);
1357 475 : if (l < min) {
1358 0 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1359 0 : name, (min == max ? "" : "at least "), (int)min, (int)l);
1360 0 : return 0;
1361 475 : } else if (l > max) {
1362 0 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1363 0 : name, (min == max ? "" : "at most "), (int)max, (int)l);
1364 0 : return 0;
1365 : } else {
1366 : Py_ssize_t i;
1367 2249 : for (i = 0; i < l; ++i) {
1368 887 : objs[i] = PyTuple_GET_ITEM(args, i);
1369 : }
1370 587 : for (; l < max; ++l) {
1371 56 : objs[l] = 0;
1372 : }
1373 475 : return i + 1;
1374 : }
1375 : }
1376 : }
1377 :
1378 : /* A functor is a function object with one single object argument */
1379 : #if PY_VERSION_HEX >= 0x02020000
1380 : #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1381 : #else
1382 : #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1383 : #endif
1384 :
1385 : /*
1386 : Helper for static pointer initialization for both C and C++ code, for example
1387 : static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1388 : */
1389 : #ifdef __cplusplus
1390 : #define SWIG_STATIC_POINTER(var) var
1391 : #else
1392 : #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1393 : #endif
1394 :
1395 : /* -----------------------------------------------------------------------------
1396 : * Pointer declarations
1397 : * ----------------------------------------------------------------------------- */
1398 :
1399 : /* Flags for new pointer objects */
1400 : #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1401 : #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1402 :
1403 : #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1404 :
1405 : #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1406 : #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1407 :
1408 : #ifdef __cplusplus
1409 : extern "C" {
1410 : #endif
1411 :
1412 : /* How to access Py_None */
1413 : #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1414 : # ifndef SWIG_PYTHON_NO_BUILD_NONE
1415 : # ifndef SWIG_PYTHON_BUILD_NONE
1416 : # define SWIG_PYTHON_BUILD_NONE
1417 : # endif
1418 : # endif
1419 : #endif
1420 :
1421 : #ifdef SWIG_PYTHON_BUILD_NONE
1422 : # ifdef Py_None
1423 : # undef Py_None
1424 : # define Py_None SWIG_Py_None()
1425 : # endif
1426 : SWIGRUNTIMEINLINE PyObject *
1427 : _SWIG_Py_None(void)
1428 : {
1429 : PyObject *none = Py_BuildValue((char*)"");
1430 : Py_DECREF(none);
1431 : return none;
1432 : }
1433 : SWIGRUNTIME PyObject *
1434 : SWIG_Py_None(void)
1435 : {
1436 : static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1437 : return none;
1438 : }
1439 : #endif
1440 :
1441 : /* The python void return value */
1442 :
1443 : SWIGRUNTIMEINLINE PyObject *
1444 : SWIG_Py_Void(void)
1445 : {
1446 420 : PyObject *none = Py_None;
1447 420 : Py_INCREF(none);
1448 : return none;
1449 : }
1450 :
1451 : /* SwigPyClientData */
1452 :
1453 : typedef struct {
1454 : PyObject *klass;
1455 : PyObject *newraw;
1456 : PyObject *newargs;
1457 : PyObject *destroy;
1458 : int delargs;
1459 : int implicitconv;
1460 : PyTypeObject *pytype;
1461 : } SwigPyClientData;
1462 :
1463 : SWIGRUNTIMEINLINE int
1464 : SWIG_Python_CheckImplicit(swig_type_info *ty)
1465 : {
1466 : SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1467 : return data ? data->implicitconv : 0;
1468 : }
1469 :
1470 : SWIGRUNTIMEINLINE PyObject *
1471 : SWIG_Python_ExceptionType(swig_type_info *desc) {
1472 1 : SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1473 1 : PyObject *klass = data ? data->klass : 0;
1474 1 : return (klass ? klass : PyExc_RuntimeError);
1475 : }
1476 :
1477 :
1478 : SWIGRUNTIME SwigPyClientData *
1479 36 : SwigPyClientData_New(PyObject* obj)
1480 : {
1481 36 : if (!obj) {
1482 : return 0;
1483 : } else {
1484 36 : SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1485 : /* the klass element */
1486 36 : data->klass = obj;
1487 36 : Py_INCREF(data->klass);
1488 : /* the newraw method and newargs arguments used to create a new raw instance */
1489 36 : if (PyClass_Check(obj)) {
1490 0 : data->newraw = 0;
1491 0 : data->newargs = obj;
1492 0 : Py_INCREF(obj);
1493 : } else {
1494 : #if (PY_VERSION_HEX < 0x02020000)
1495 : data->newraw = 0;
1496 : #else
1497 36 : data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1498 : #endif
1499 36 : if (data->newraw) {
1500 36 : Py_INCREF(data->newraw);
1501 36 : data->newargs = PyTuple_New(1);
1502 36 : PyTuple_SetItem(data->newargs, 0, obj);
1503 : } else {
1504 0 : data->newargs = obj;
1505 : }
1506 36 : Py_INCREF(data->newargs);
1507 : }
1508 : /* the destroy method, aka as the C++ delete method */
1509 36 : data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1510 36 : if (PyErr_Occurred()) {
1511 0 : PyErr_Clear();
1512 0 : data->destroy = 0;
1513 : }
1514 36 : if (data->destroy) {
1515 : int flags;
1516 36 : Py_INCREF(data->destroy);
1517 36 : flags = PyCFunction_GET_FLAGS(data->destroy);
1518 : #ifdef METH_O
1519 36 : data->delargs = !(flags & (METH_O));
1520 : #else
1521 : data->delargs = 0;
1522 : #endif
1523 : } else {
1524 0 : data->delargs = 0;
1525 : }
1526 36 : data->implicitconv = 0;
1527 36 : data->pytype = 0;
1528 36 : return data;
1529 : }
1530 : }
1531 :
1532 : SWIGRUNTIME void
1533 36 : SwigPyClientData_Del(SwigPyClientData *data) {
1534 36 : Py_XDECREF(data->newraw);
1535 36 : Py_XDECREF(data->newargs);
1536 36 : Py_XDECREF(data->destroy);
1537 36 : }
1538 :
1539 : /* =============== SwigPyObject =====================*/
1540 :
1541 : typedef struct {
1542 : PyObject_HEAD
1543 : void *ptr;
1544 : swig_type_info *ty;
1545 : int own;
1546 : PyObject *next;
1547 : #ifdef SWIGPYTHON_BUILTIN
1548 : PyObject *dict;
1549 : #endif
1550 : } SwigPyObject;
1551 :
1552 :
1553 : #ifdef SWIGPYTHON_BUILTIN
1554 :
1555 : SWIGRUNTIME PyObject *
1556 : SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1557 : {
1558 : SwigPyObject *sobj = (SwigPyObject *)v;
1559 :
1560 : if (!sobj->dict)
1561 : sobj->dict = PyDict_New();
1562 :
1563 : Py_INCREF(sobj->dict);
1564 : return sobj->dict;
1565 : }
1566 :
1567 : #endif
1568 :
1569 : SWIGRUNTIME PyObject *
1570 0 : SwigPyObject_long(SwigPyObject *v)
1571 : {
1572 0 : return PyLong_FromVoidPtr(v->ptr);
1573 : }
1574 :
1575 : SWIGRUNTIME PyObject *
1576 0 : SwigPyObject_format(const char* fmt, SwigPyObject *v)
1577 : {
1578 0 : PyObject *res = NULL;
1579 0 : PyObject *args = PyTuple_New(1);
1580 0 : if (args) {
1581 0 : if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1582 0 : PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1583 0 : if (ofmt) {
1584 : #if PY_VERSION_HEX >= 0x03000000
1585 : res = PyUnicode_Format(ofmt,args);
1586 : #else
1587 0 : res = PyString_Format(ofmt,args);
1588 : #endif
1589 0 : Py_DECREF(ofmt);
1590 : }
1591 0 : Py_DECREF(args);
1592 : }
1593 : }
1594 0 : return res;
1595 : }
1596 :
1597 : SWIGRUNTIME PyObject *
1598 0 : SwigPyObject_oct(SwigPyObject *v)
1599 : {
1600 0 : return SwigPyObject_format("%o",v);
1601 : }
1602 :
1603 : SWIGRUNTIME PyObject *
1604 0 : SwigPyObject_hex(SwigPyObject *v)
1605 : {
1606 0 : return SwigPyObject_format("%x",v);
1607 : }
1608 :
1609 : SWIGRUNTIME PyObject *
1610 : #ifdef METH_NOARGS
1611 0 : SwigPyObject_repr(SwigPyObject *v)
1612 : #else
1613 : SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1614 : #endif
1615 : {
1616 0 : const char *name = SWIG_TypePrettyName(v->ty);
1617 0 : PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1618 0 : if (v->next) {
1619 : # ifdef METH_NOARGS
1620 0 : PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1621 : # else
1622 : PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1623 : # endif
1624 : # if PY_VERSION_HEX >= 0x03000000
1625 : PyObject *joined = PyUnicode_Concat(repr, nrep);
1626 : Py_DecRef(repr);
1627 : Py_DecRef(nrep);
1628 : repr = joined;
1629 : # else
1630 0 : PyString_ConcatAndDel(&repr,nrep);
1631 : # endif
1632 : }
1633 0 : return repr;
1634 : }
1635 :
1636 : SWIGRUNTIME int
1637 0 : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1638 : {
1639 2 : void *i = v->ptr;
1640 2 : void *j = w->ptr;
1641 2 : return (i < j) ? -1 : ((i > j) ? 1 : 0);
1642 : }
1643 :
1644 : /* Added for Python 3.x, would it also be useful for Python 2.x? */
1645 : SWIGRUNTIME PyObject*
1646 2 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1647 : {
1648 : PyObject* res;
1649 2 : if( op != Py_EQ && op != Py_NE ) {
1650 0 : Py_INCREF(Py_NotImplemented);
1651 0 : return Py_NotImplemented;
1652 : }
1653 2 : res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1654 2 : return res;
1655 : }
1656 :
1657 :
1658 : SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1659 :
1660 : #ifdef SWIGPYTHON_BUILTIN
1661 : static swig_type_info *SwigPyObject_stype = 0;
1662 : SWIGRUNTIME PyTypeObject*
1663 : SwigPyObject_type(void) {
1664 : SwigPyClientData *cd;
1665 : assert(SwigPyObject_stype);
1666 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1667 : assert(cd);
1668 : assert(cd->pytype);
1669 : return cd->pytype;
1670 : }
1671 : #else
1672 : SWIGRUNTIME PyTypeObject*
1673 1781 : SwigPyObject_type(void) {
1674 1781 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1675 1781 : return type;
1676 : }
1677 : #endif
1678 :
1679 : SWIGRUNTIMEINLINE int
1680 1347 : SwigPyObject_Check(PyObject *op) {
1681 : #ifdef SWIGPYTHON_BUILTIN
1682 : PyTypeObject *target_tp = SwigPyObject_type();
1683 : if (PyType_IsSubtype(op->ob_type, target_tp))
1684 : return 1;
1685 : return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1686 : #else
1687 1347 : return (Py_TYPE(op) == SwigPyObject_type())
1688 1347 : || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1689 : #endif
1690 : }
1691 :
1692 : SWIGRUNTIME PyObject *
1693 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1694 :
1695 : SWIGRUNTIME void
1696 214 : SwigPyObject_dealloc(PyObject *v)
1697 : {
1698 214 : SwigPyObject *sobj = (SwigPyObject *) v;
1699 214 : PyObject *next = sobj->next;
1700 214 : if (sobj->own == SWIG_POINTER_OWN) {
1701 198 : swig_type_info *ty = sobj->ty;
1702 198 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1703 198 : PyObject *destroy = data ? data->destroy : 0;
1704 198 : if (destroy) {
1705 : /* destroy is always a VARARGS method */
1706 : PyObject *res;
1707 :
1708 : /* PyObject_CallFunction() has the potential to silently drop
1709 : the active active exception. In cases of unnamed temporary
1710 : variable or where we just finished iterating over a generator
1711 : StopIteration will be active right now, and this needs to
1712 : remain true upon return from SwigPyObject_dealloc. So save
1713 : and restore. */
1714 :
1715 198 : PyObject *val = NULL, *type = NULL, *tb = NULL;
1716 198 : PyErr_Fetch(&val, &type, &tb);
1717 :
1718 198 : if (data->delargs) {
1719 : /* we need to create a temporary object to carry the destroy operation */
1720 0 : PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1721 0 : res = SWIG_Python_CallFunctor(destroy, tmp);
1722 0 : Py_DECREF(tmp);
1723 : } else {
1724 198 : PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1725 198 : PyObject *mself = PyCFunction_GET_SELF(destroy);
1726 198 : res = ((*meth)(mself, v));
1727 : }
1728 198 : if (!res)
1729 0 : PyErr_WriteUnraisable(destroy);
1730 :
1731 198 : PyErr_Restore(val, type, tb);
1732 :
1733 198 : Py_XDECREF(res);
1734 : }
1735 : #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1736 : else {
1737 0 : const char *name = SWIG_TypePrettyName(ty);
1738 0 : printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1739 : }
1740 : #endif
1741 : }
1742 214 : Py_XDECREF(next);
1743 214 : PyObject_DEL(v);
1744 214 : }
1745 :
1746 : SWIGRUNTIME PyObject*
1747 0 : SwigPyObject_append(PyObject* v, PyObject* next)
1748 : {
1749 0 : SwigPyObject *sobj = (SwigPyObject *) v;
1750 : #ifndef METH_O
1751 : PyObject *tmp = 0;
1752 : if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1753 : next = tmp;
1754 : #endif
1755 0 : if (!SwigPyObject_Check(next)) {
1756 0 : PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1757 0 : return NULL;
1758 : }
1759 0 : sobj->next = next;
1760 0 : Py_INCREF(next);
1761 0 : return SWIG_Py_Void();
1762 : }
1763 :
1764 : SWIGRUNTIME PyObject*
1765 : #ifdef METH_NOARGS
1766 0 : SwigPyObject_next(PyObject* v)
1767 : #else
1768 : SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1769 : #endif
1770 : {
1771 0 : SwigPyObject *sobj = (SwigPyObject *) v;
1772 0 : if (sobj->next) {
1773 0 : Py_INCREF(sobj->next);
1774 0 : return sobj->next;
1775 : } else {
1776 0 : return SWIG_Py_Void();
1777 : }
1778 : }
1779 :
1780 : SWIGINTERN PyObject*
1781 : #ifdef METH_NOARGS
1782 0 : SwigPyObject_disown(PyObject *v)
1783 : #else
1784 : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1785 : #endif
1786 : {
1787 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1788 0 : sobj->own = 0;
1789 0 : return SWIG_Py_Void();
1790 : }
1791 :
1792 : SWIGINTERN PyObject*
1793 : #ifdef METH_NOARGS
1794 0 : SwigPyObject_acquire(PyObject *v)
1795 : #else
1796 : SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1797 : #endif
1798 : {
1799 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1800 0 : sobj->own = SWIG_POINTER_OWN;
1801 0 : return SWIG_Py_Void();
1802 : }
1803 :
1804 : SWIGINTERN PyObject*
1805 0 : SwigPyObject_own(PyObject *v, PyObject *args)
1806 : {
1807 0 : PyObject *val = 0;
1808 : #if (PY_VERSION_HEX < 0x02020000)
1809 : if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1810 : #elif (PY_VERSION_HEX < 0x02050000)
1811 : if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1812 : #else
1813 0 : if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1814 : #endif
1815 : {
1816 : return NULL;
1817 : }
1818 : else
1819 : {
1820 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1821 0 : PyObject *obj = PyBool_FromLong(sobj->own);
1822 0 : if (val) {
1823 : #ifdef METH_NOARGS
1824 0 : if (PyObject_IsTrue(val)) {
1825 : SwigPyObject_acquire(v);
1826 : } else {
1827 : SwigPyObject_disown(v);
1828 : }
1829 : #else
1830 : if (PyObject_IsTrue(val)) {
1831 : SwigPyObject_acquire(v,args);
1832 : } else {
1833 : SwigPyObject_disown(v,args);
1834 : }
1835 : #endif
1836 : }
1837 : return obj;
1838 : }
1839 : }
1840 :
1841 : #ifdef METH_O
1842 : static PyMethodDef
1843 : swigobject_methods[] = {
1844 : {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1845 : {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1846 : {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1847 : {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1848 : {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1849 : {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1850 : {0, 0, 0, 0}
1851 : };
1852 : #else
1853 : static PyMethodDef
1854 : swigobject_methods[] = {
1855 : {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1856 : {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1857 : {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1858 : {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1859 : {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1860 : {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1861 : {0, 0, 0, 0}
1862 : };
1863 : #endif
1864 :
1865 : #if PY_VERSION_HEX < 0x02020000
1866 : SWIGINTERN PyObject *
1867 : SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1868 : {
1869 : return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1870 : }
1871 : #endif
1872 :
1873 : SWIGRUNTIME PyTypeObject*
1874 3 : SwigPyObject_TypeOnce(void) {
1875 : static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1876 :
1877 : static PyNumberMethods SwigPyObject_as_number = {
1878 : (binaryfunc)0, /*nb_add*/
1879 : (binaryfunc)0, /*nb_subtract*/
1880 : (binaryfunc)0, /*nb_multiply*/
1881 : /* nb_divide removed in Python 3 */
1882 : #if PY_VERSION_HEX < 0x03000000
1883 : (binaryfunc)0, /*nb_divide*/
1884 : #endif
1885 : (binaryfunc)0, /*nb_remainder*/
1886 : (binaryfunc)0, /*nb_divmod*/
1887 : (ternaryfunc)0,/*nb_power*/
1888 : (unaryfunc)0, /*nb_negative*/
1889 : (unaryfunc)0, /*nb_positive*/
1890 : (unaryfunc)0, /*nb_absolute*/
1891 : (inquiry)0, /*nb_nonzero*/
1892 : 0, /*nb_invert*/
1893 : 0, /*nb_lshift*/
1894 : 0, /*nb_rshift*/
1895 : 0, /*nb_and*/
1896 : 0, /*nb_xor*/
1897 : 0, /*nb_or*/
1898 : #if PY_VERSION_HEX < 0x03000000
1899 : 0, /*nb_coerce*/
1900 : #endif
1901 : (unaryfunc)SwigPyObject_long, /*nb_int*/
1902 : #if PY_VERSION_HEX < 0x03000000
1903 : (unaryfunc)SwigPyObject_long, /*nb_long*/
1904 : #else
1905 : 0, /*nb_reserved*/
1906 : #endif
1907 : (unaryfunc)0, /*nb_float*/
1908 : #if PY_VERSION_HEX < 0x03000000
1909 : (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1910 : (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1911 : #endif
1912 : #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1913 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1914 : #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1915 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1916 : #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1917 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1918 : #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1919 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1920 : #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1921 : 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1922 : #endif
1923 : };
1924 :
1925 : static PyTypeObject swigpyobject_type;
1926 : static int type_init = 0;
1927 3 : if (!type_init) {
1928 : const PyTypeObject tmp = {
1929 : /* PyObject header changed in Python 3 */
1930 : #if PY_VERSION_HEX >= 0x03000000
1931 : PyVarObject_HEAD_INIT(NULL, 0)
1932 : #else
1933 : PyObject_HEAD_INIT(NULL)
1934 : 0, /* ob_size */
1935 : #endif
1936 : (char *)"SwigPyObject", /* tp_name */
1937 : sizeof(SwigPyObject), /* tp_basicsize */
1938 : 0, /* tp_itemsize */
1939 : (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1940 : 0, /* tp_print */
1941 : #if PY_VERSION_HEX < 0x02020000
1942 : (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1943 : #else
1944 : (getattrfunc)0, /* tp_getattr */
1945 : #endif
1946 : (setattrfunc)0, /* tp_setattr */
1947 : #if PY_VERSION_HEX >= 0x03000000
1948 : 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1949 : #else
1950 : (cmpfunc)SwigPyObject_compare, /* tp_compare */
1951 : #endif
1952 : (reprfunc)SwigPyObject_repr, /* tp_repr */
1953 : &SwigPyObject_as_number, /* tp_as_number */
1954 : 0, /* tp_as_sequence */
1955 : 0, /* tp_as_mapping */
1956 : (hashfunc)0, /* tp_hash */
1957 : (ternaryfunc)0, /* tp_call */
1958 : 0, /* tp_str */
1959 : PyObject_GenericGetAttr, /* tp_getattro */
1960 : 0, /* tp_setattro */
1961 : 0, /* tp_as_buffer */
1962 : Py_TPFLAGS_DEFAULT, /* tp_flags */
1963 : swigobject_doc, /* tp_doc */
1964 : 0, /* tp_traverse */
1965 : 0, /* tp_clear */
1966 : (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1967 : 0, /* tp_weaklistoffset */
1968 : #if PY_VERSION_HEX >= 0x02020000
1969 : 0, /* tp_iter */
1970 : 0, /* tp_iternext */
1971 : swigobject_methods, /* tp_methods */
1972 : 0, /* tp_members */
1973 : 0, /* tp_getset */
1974 : 0, /* tp_base */
1975 : 0, /* tp_dict */
1976 : 0, /* tp_descr_get */
1977 : 0, /* tp_descr_set */
1978 : 0, /* tp_dictoffset */
1979 : 0, /* tp_init */
1980 : 0, /* tp_alloc */
1981 : 0, /* tp_new */
1982 : 0, /* tp_free */
1983 : 0, /* tp_is_gc */
1984 : 0, /* tp_bases */
1985 : 0, /* tp_mro */
1986 : 0, /* tp_cache */
1987 : 0, /* tp_subclasses */
1988 : 0, /* tp_weaklist */
1989 : #endif
1990 : #if PY_VERSION_HEX >= 0x02030000
1991 : 0, /* tp_del */
1992 : #endif
1993 : #if PY_VERSION_HEX >= 0x02060000
1994 : 0, /* tp_version_tag */
1995 : #endif
1996 : #if PY_VERSION_HEX >= 0x03040000
1997 : 0, /* tp_finalize */
1998 : #endif
1999 : #ifdef COUNT_ALLOCS
2000 : 0, /* tp_allocs */
2001 : 0, /* tp_frees */
2002 : 0, /* tp_maxalloc */
2003 : #if PY_VERSION_HEX >= 0x02050000
2004 : 0, /* tp_prev */
2005 : #endif
2006 : 0 /* tp_next */
2007 : #endif
2008 3 : };
2009 3 : swigpyobject_type = tmp;
2010 3 : type_init = 1;
2011 : #if PY_VERSION_HEX < 0x02020000
2012 : swigpyobject_type.ob_type = &PyType_Type;
2013 : #else
2014 3 : if (PyType_Ready(&swigpyobject_type) < 0)
2015 0 : return NULL;
2016 : #endif
2017 : }
2018 : return &swigpyobject_type;
2019 : }
2020 :
2021 : SWIGRUNTIME PyObject *
2022 217 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2023 : {
2024 217 : SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2025 217 : if (sobj) {
2026 217 : sobj->ptr = ptr;
2027 217 : sobj->ty = ty;
2028 217 : sobj->own = own;
2029 217 : sobj->next = 0;
2030 : }
2031 217 : return (PyObject *)sobj;
2032 : }
2033 :
2034 : /* -----------------------------------------------------------------------------
2035 : * Implements a simple Swig Packed type, and use it instead of string
2036 : * ----------------------------------------------------------------------------- */
2037 :
2038 : typedef struct {
2039 : PyObject_HEAD
2040 : void *pack;
2041 : swig_type_info *ty;
2042 : size_t size;
2043 : } SwigPyPacked;
2044 :
2045 : SWIGRUNTIME int
2046 0 : SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2047 : {
2048 : char result[SWIG_BUFFER_SIZE];
2049 0 : fputs("<Swig Packed ", fp);
2050 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2051 0 : fputs("at ", fp);
2052 0 : fputs(result, fp);
2053 : }
2054 0 : fputs(v->ty->name,fp);
2055 0 : fputs(">", fp);
2056 0 : return 0;
2057 : }
2058 :
2059 : SWIGRUNTIME PyObject *
2060 0 : SwigPyPacked_repr(SwigPyPacked *v)
2061 : {
2062 : char result[SWIG_BUFFER_SIZE];
2063 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2064 0 : return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2065 : } else {
2066 0 : return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2067 : }
2068 : }
2069 :
2070 : SWIGRUNTIME PyObject *
2071 0 : SwigPyPacked_str(SwigPyPacked *v)
2072 : {
2073 : char result[SWIG_BUFFER_SIZE];
2074 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2075 0 : return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2076 : } else {
2077 0 : return SWIG_Python_str_FromChar(v->ty->name);
2078 : }
2079 : }
2080 :
2081 : SWIGRUNTIME int
2082 0 : SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2083 : {
2084 0 : size_t i = v->size;
2085 0 : size_t j = w->size;
2086 0 : int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2087 0 : return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2088 : }
2089 :
2090 : SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2091 :
2092 : SWIGRUNTIME PyTypeObject*
2093 0 : SwigPyPacked_type(void) {
2094 0 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2095 0 : return type;
2096 : }
2097 :
2098 : SWIGRUNTIMEINLINE int
2099 0 : SwigPyPacked_Check(PyObject *op) {
2100 0 : return ((op)->ob_type == SwigPyPacked_TypeOnce())
2101 0 : || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2102 : }
2103 :
2104 : SWIGRUNTIME void
2105 0 : SwigPyPacked_dealloc(PyObject *v)
2106 : {
2107 0 : if (SwigPyPacked_Check(v)) {
2108 0 : SwigPyPacked *sobj = (SwigPyPacked *) v;
2109 0 : free(sobj->pack);
2110 : }
2111 0 : PyObject_DEL(v);
2112 0 : }
2113 :
2114 : SWIGRUNTIME PyTypeObject*
2115 0 : SwigPyPacked_TypeOnce(void) {
2116 : static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2117 : static PyTypeObject swigpypacked_type;
2118 : static int type_init = 0;
2119 0 : if (!type_init) {
2120 : const PyTypeObject tmp = {
2121 : /* PyObject header changed in Python 3 */
2122 : #if PY_VERSION_HEX>=0x03000000
2123 : PyVarObject_HEAD_INIT(NULL, 0)
2124 : #else
2125 : PyObject_HEAD_INIT(NULL)
2126 : 0, /* ob_size */
2127 : #endif
2128 : (char *)"SwigPyPacked", /* tp_name */
2129 : sizeof(SwigPyPacked), /* tp_basicsize */
2130 : 0, /* tp_itemsize */
2131 : (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2132 : (printfunc)SwigPyPacked_print, /* tp_print */
2133 : (getattrfunc)0, /* tp_getattr */
2134 : (setattrfunc)0, /* tp_setattr */
2135 : #if PY_VERSION_HEX>=0x03000000
2136 : 0, /* tp_reserved in 3.0.1 */
2137 : #else
2138 : (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2139 : #endif
2140 : (reprfunc)SwigPyPacked_repr, /* tp_repr */
2141 : 0, /* tp_as_number */
2142 : 0, /* tp_as_sequence */
2143 : 0, /* tp_as_mapping */
2144 : (hashfunc)0, /* tp_hash */
2145 : (ternaryfunc)0, /* tp_call */
2146 : (reprfunc)SwigPyPacked_str, /* tp_str */
2147 : PyObject_GenericGetAttr, /* tp_getattro */
2148 : 0, /* tp_setattro */
2149 : 0, /* tp_as_buffer */
2150 : Py_TPFLAGS_DEFAULT, /* tp_flags */
2151 : swigpacked_doc, /* tp_doc */
2152 : 0, /* tp_traverse */
2153 : 0, /* tp_clear */
2154 : 0, /* tp_richcompare */
2155 : 0, /* tp_weaklistoffset */
2156 : #if PY_VERSION_HEX >= 0x02020000
2157 : 0, /* tp_iter */
2158 : 0, /* tp_iternext */
2159 : 0, /* tp_methods */
2160 : 0, /* tp_members */
2161 : 0, /* tp_getset */
2162 : 0, /* tp_base */
2163 : 0, /* tp_dict */
2164 : 0, /* tp_descr_get */
2165 : 0, /* tp_descr_set */
2166 : 0, /* tp_dictoffset */
2167 : 0, /* tp_init */
2168 : 0, /* tp_alloc */
2169 : 0, /* tp_new */
2170 : 0, /* tp_free */
2171 : 0, /* tp_is_gc */
2172 : 0, /* tp_bases */
2173 : 0, /* tp_mro */
2174 : 0, /* tp_cache */
2175 : 0, /* tp_subclasses */
2176 : 0, /* tp_weaklist */
2177 : #endif
2178 : #if PY_VERSION_HEX >= 0x02030000
2179 : 0, /* tp_del */
2180 : #endif
2181 : #if PY_VERSION_HEX >= 0x02060000
2182 : 0, /* tp_version_tag */
2183 : #endif
2184 : #if PY_VERSION_HEX >= 0x03040000
2185 : 0, /* tp_finalize */
2186 : #endif
2187 : #ifdef COUNT_ALLOCS
2188 : 0, /* tp_allocs */
2189 : 0, /* tp_frees */
2190 : 0, /* tp_maxalloc */
2191 : #if PY_VERSION_HEX >= 0x02050000
2192 : 0, /* tp_prev */
2193 : #endif
2194 : 0 /* tp_next */
2195 : #endif
2196 0 : };
2197 0 : swigpypacked_type = tmp;
2198 0 : type_init = 1;
2199 : #if PY_VERSION_HEX < 0x02020000
2200 : swigpypacked_type.ob_type = &PyType_Type;
2201 : #else
2202 0 : if (PyType_Ready(&swigpypacked_type) < 0)
2203 0 : return NULL;
2204 : #endif
2205 : }
2206 : return &swigpypacked_type;
2207 : }
2208 :
2209 : SWIGRUNTIME PyObject *
2210 0 : SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2211 : {
2212 0 : SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2213 0 : if (sobj) {
2214 0 : void *pack = malloc(size);
2215 0 : if (pack) {
2216 0 : memcpy(pack, ptr, size);
2217 0 : sobj->pack = pack;
2218 0 : sobj->ty = ty;
2219 0 : sobj->size = size;
2220 : } else {
2221 0 : PyObject_DEL((PyObject *) sobj);
2222 0 : sobj = 0;
2223 : }
2224 : }
2225 0 : return (PyObject *) sobj;
2226 : }
2227 :
2228 : SWIGRUNTIME swig_type_info *
2229 : SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2230 : {
2231 : if (SwigPyPacked_Check(obj)) {
2232 : SwigPyPacked *sobj = (SwigPyPacked *)obj;
2233 : if (sobj->size != size) return 0;
2234 : memcpy(ptr, sobj->pack, size);
2235 : return sobj->ty;
2236 : } else {
2237 : return 0;
2238 : }
2239 : }
2240 :
2241 : /* -----------------------------------------------------------------------------
2242 : * pointers/data manipulation
2243 : * ----------------------------------------------------------------------------- */
2244 :
2245 : SWIGRUNTIMEINLINE PyObject *
2246 : _SWIG_This(void)
2247 : {
2248 3 : return SWIG_Python_str_FromChar("this");
2249 : }
2250 :
2251 : static PyObject *swig_this = NULL;
2252 :
2253 : SWIGRUNTIME PyObject *
2254 : SWIG_This(void)
2255 : {
2256 746 : if (swig_this == NULL)
2257 3 : swig_this = _SWIG_This();
2258 746 : return swig_this;
2259 : }
2260 :
2261 : /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2262 :
2263 : /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2264 : #if PY_VERSION_HEX>=0x03000000
2265 : #define SWIG_PYTHON_SLOW_GETSET_THIS
2266 : #endif
2267 :
2268 : SWIGRUNTIME SwigPyObject *
2269 873 : SWIG_Python_GetSwigThis(PyObject *pyobj)
2270 : {
2271 : PyObject *obj;
2272 :
2273 873 : if (SwigPyObject_Check(pyobj))
2274 : return (SwigPyObject *) pyobj;
2275 :
2276 : #ifdef SWIGPYTHON_BUILTIN
2277 : (void)obj;
2278 : # ifdef PyWeakref_CheckProxy
2279 : if (PyWeakref_CheckProxy(pyobj)) {
2280 : pyobj = PyWeakref_GET_OBJECT(pyobj);
2281 : if (pyobj && SwigPyObject_Check(pyobj))
2282 : return (SwigPyObject*) pyobj;
2283 : }
2284 : # endif
2285 : return NULL;
2286 : #else
2287 :
2288 671 : obj = 0;
2289 :
2290 : #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2291 671 : if (PyInstance_Check(pyobj)) {
2292 0 : obj = _PyInstance_Lookup(pyobj, SWIG_This());
2293 : } else {
2294 671 : PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2295 671 : if (dictptr != NULL) {
2296 615 : PyObject *dict = *dictptr;
2297 1089 : obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2298 : } else {
2299 : #ifdef PyWeakref_CheckProxy
2300 56 : if (PyWeakref_CheckProxy(pyobj)) {
2301 0 : PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2302 0 : return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2303 : }
2304 : #endif
2305 56 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2306 56 : if (obj) {
2307 0 : Py_DECREF(obj);
2308 : } else {
2309 56 : if (PyErr_Occurred()) PyErr_Clear();
2310 : return 0;
2311 : }
2312 : }
2313 : }
2314 : #else
2315 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2316 : if (obj) {
2317 : Py_DECREF(obj);
2318 : } else {
2319 : if (PyErr_Occurred()) PyErr_Clear();
2320 : return 0;
2321 : }
2322 : #endif
2323 615 : if (obj && !SwigPyObject_Check(obj)) {
2324 : /* a PyObject is called 'this', try to get the 'real this'
2325 : SwigPyObject from it */
2326 : return SWIG_Python_GetSwigThis(obj);
2327 : }
2328 : return (SwigPyObject *)obj;
2329 : #endif
2330 : }
2331 :
2332 : /* Acquire a pointer value */
2333 :
2334 : SWIGRUNTIME int
2335 : SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2336 : if (own == SWIG_POINTER_OWN) {
2337 : SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2338 : if (sobj) {
2339 : int oldown = sobj->own;
2340 : sobj->own = own;
2341 : return oldown;
2342 : }
2343 : }
2344 : return 0;
2345 : }
2346 :
2347 : /* Convert a pointer value */
2348 :
2349 : SWIGRUNTIME int
2350 732 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2351 : int res;
2352 : SwigPyObject *sobj;
2353 732 : int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2354 :
2355 732 : if (!obj)
2356 : return SWIG_ERROR;
2357 732 : if (obj == Py_None && !implicit_conv) {
2358 0 : if (ptr)
2359 0 : *ptr = 0;
2360 : return SWIG_OK;
2361 : }
2362 :
2363 732 : res = SWIG_ERROR;
2364 :
2365 732 : sobj = SWIG_Python_GetSwigThis(obj);
2366 732 : if (own)
2367 0 : *own = 0;
2368 735 : while (sobj) {
2369 676 : void *vptr = sobj->ptr;
2370 676 : if (ty) {
2371 676 : swig_type_info *to = sobj->ty;
2372 676 : if (to == ty) {
2373 : /* no type cast needed */
2374 673 : if (ptr) *ptr = vptr;
2375 : break;
2376 : } else {
2377 3 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2378 3 : if (!tc) {
2379 3 : sobj = (SwigPyObject *)sobj->next;
2380 : } else {
2381 0 : if (ptr) {
2382 0 : int newmemory = 0;
2383 0 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2384 0 : if (newmemory == SWIG_CAST_NEW_MEMORY) {
2385 : assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2386 0 : if (own)
2387 0 : *own = *own | SWIG_CAST_NEW_MEMORY;
2388 : }
2389 : }
2390 : break;
2391 : }
2392 : }
2393 : } else {
2394 0 : if (ptr) *ptr = vptr;
2395 : break;
2396 : }
2397 : }
2398 732 : if (sobj) {
2399 673 : if (own)
2400 0 : *own = *own | sobj->own;
2401 673 : if (flags & SWIG_POINTER_DISOWN) {
2402 198 : sobj->own = 0;
2403 : }
2404 : res = SWIG_OK;
2405 : } else {
2406 59 : if (implicit_conv) {
2407 0 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2408 0 : if (data && !data->implicitconv) {
2409 0 : PyObject *klass = data->klass;
2410 0 : if (klass) {
2411 : PyObject *impconv;
2412 0 : data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2413 0 : impconv = SWIG_Python_CallFunctor(klass, obj);
2414 0 : data->implicitconv = 0;
2415 0 : if (PyErr_Occurred()) {
2416 0 : PyErr_Clear();
2417 0 : impconv = 0;
2418 : }
2419 0 : if (impconv) {
2420 0 : SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2421 0 : if (iobj) {
2422 : void *vptr;
2423 0 : res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2424 0 : if (SWIG_IsOK(res)) {
2425 0 : if (ptr) {
2426 0 : *ptr = vptr;
2427 : /* transfer the ownership to 'ptr' */
2428 0 : iobj->own = 0;
2429 0 : res = SWIG_AddCast(res);
2430 0 : res = SWIG_AddNewMask(res);
2431 : } else {
2432 : res = SWIG_AddCast(res);
2433 : }
2434 : }
2435 : }
2436 0 : Py_DECREF(impconv);
2437 : }
2438 : }
2439 : }
2440 : }
2441 59 : if (!SWIG_IsOK(res) && obj == Py_None) {
2442 0 : if (ptr)
2443 0 : *ptr = 0;
2444 0 : if (PyErr_Occurred())
2445 0 : PyErr_Clear();
2446 : res = SWIG_OK;
2447 : }
2448 : }
2449 : return res;
2450 : }
2451 :
2452 : /* Convert a function ptr value */
2453 :
2454 : SWIGRUNTIME int
2455 0 : SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2456 0 : if (!PyCFunction_Check(obj)) {
2457 0 : return SWIG_ConvertPtr(obj, ptr, ty, 0);
2458 : } else {
2459 0 : void *vptr = 0;
2460 :
2461 : /* here we get the method pointer for callbacks */
2462 0 : const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2463 0 : const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2464 0 : if (desc)
2465 0 : desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2466 0 : if (!desc)
2467 : return SWIG_ERROR;
2468 0 : if (ty) {
2469 0 : swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2470 0 : if (tc) {
2471 0 : int newmemory = 0;
2472 0 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2473 : assert(!newmemory); /* newmemory handling not yet implemented */
2474 : } else {
2475 : return SWIG_ERROR;
2476 : }
2477 : } else {
2478 0 : *ptr = vptr;
2479 : }
2480 : return SWIG_OK;
2481 : }
2482 : }
2483 :
2484 : /* Convert a packed value value */
2485 :
2486 : SWIGRUNTIME int
2487 : SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2488 : swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2489 : if (!to) return SWIG_ERROR;
2490 : if (ty) {
2491 : if (to != ty) {
2492 : /* check type cast? */
2493 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2494 : if (!tc) return SWIG_ERROR;
2495 : }
2496 : }
2497 : return SWIG_OK;
2498 : }
2499 :
2500 : /* -----------------------------------------------------------------------------
2501 : * Create a new pointer object
2502 : * ----------------------------------------------------------------------------- */
2503 :
2504 : /*
2505 : Create a new instance object, without calling __init__, and set the
2506 : 'this' attribute.
2507 : */
2508 :
2509 : SWIGRUNTIME PyObject*
2510 70 : SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2511 : {
2512 : #if (PY_VERSION_HEX >= 0x02020000)
2513 70 : PyObject *inst = 0;
2514 70 : PyObject *newraw = data->newraw;
2515 70 : if (newraw) {
2516 70 : inst = PyObject_Call(newraw, data->newargs, NULL);
2517 70 : if (inst) {
2518 : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2519 70 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2520 70 : if (dictptr != NULL) {
2521 70 : PyObject *dict = *dictptr;
2522 70 : if (dict == NULL) {
2523 70 : dict = PyDict_New();
2524 70 : *dictptr = dict;
2525 70 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2526 : }
2527 : }
2528 : #else
2529 : PyObject *key = SWIG_This();
2530 : PyObject_SetAttr(inst, key, swig_this);
2531 : #endif
2532 : }
2533 : } else {
2534 : #if PY_VERSION_HEX >= 0x03000000
2535 : inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2536 : if (inst) {
2537 : PyObject_SetAttr(inst, SWIG_This(), swig_this);
2538 : Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2539 : }
2540 : #else
2541 0 : PyObject *dict = PyDict_New();
2542 0 : if (dict) {
2543 0 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2544 0 : inst = PyInstance_NewRaw(data->newargs, dict);
2545 0 : Py_DECREF(dict);
2546 : }
2547 : #endif
2548 : }
2549 70 : return inst;
2550 : #else
2551 : #if (PY_VERSION_HEX >= 0x02010000)
2552 : PyObject *inst = 0;
2553 : PyObject *dict = PyDict_New();
2554 : if (dict) {
2555 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2556 : inst = PyInstance_NewRaw(data->newargs, dict);
2557 : Py_DECREF(dict);
2558 : }
2559 : return (PyObject *) inst;
2560 : #else
2561 : PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2562 : if (inst == NULL) {
2563 : return NULL;
2564 : }
2565 : inst->in_class = (PyClassObject *)data->newargs;
2566 : Py_INCREF(inst->in_class);
2567 : inst->in_dict = PyDict_New();
2568 : if (inst->in_dict == NULL) {
2569 : Py_DECREF(inst);
2570 : return NULL;
2571 : }
2572 : #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2573 : inst->in_weakreflist = NULL;
2574 : #endif
2575 : #ifdef Py_TPFLAGS_GC
2576 : PyObject_GC_Init(inst);
2577 : #endif
2578 : PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2579 : return (PyObject *) inst;
2580 : #endif
2581 : #endif
2582 : }
2583 :
2584 : SWIGRUNTIME void
2585 141 : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2586 : {
2587 : PyObject *dict;
2588 : #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2589 141 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2590 141 : if (dictptr != NULL) {
2591 141 : dict = *dictptr;
2592 141 : if (dict == NULL) {
2593 141 : dict = PyDict_New();
2594 141 : *dictptr = dict;
2595 : }
2596 141 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2597 141 : return;
2598 : }
2599 : #endif
2600 0 : dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2601 0 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2602 0 : Py_DECREF(dict);
2603 : }
2604 :
2605 :
2606 : SWIGINTERN PyObject *
2607 141 : SWIG_Python_InitShadowInstance(PyObject *args) {
2608 : PyObject *obj[2];
2609 141 : if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2610 : return NULL;
2611 : } else {
2612 141 : SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2613 141 : if (sthis) {
2614 0 : SwigPyObject_append((PyObject*) sthis, obj[1]);
2615 : } else {
2616 141 : SWIG_Python_SetSwigThis(obj[0], obj[1]);
2617 : }
2618 141 : return SWIG_Py_Void();
2619 : }
2620 : }
2621 :
2622 : /* Create a new pointer object */
2623 :
2624 : SWIGRUNTIME PyObject *
2625 217 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2626 : SwigPyClientData *clientdata;
2627 : PyObject * robj;
2628 : int own;
2629 :
2630 217 : if (!ptr)
2631 0 : return SWIG_Py_Void();
2632 :
2633 217 : clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2634 217 : own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2635 217 : if (clientdata && clientdata->pytype) {
2636 : SwigPyObject *newobj;
2637 0 : if (flags & SWIG_BUILTIN_TP_INIT) {
2638 0 : newobj = (SwigPyObject*) self;
2639 0 : if (newobj->ptr) {
2640 0 : PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2641 0 : while (newobj->next)
2642 : newobj = (SwigPyObject *) newobj->next;
2643 0 : newobj->next = next_self;
2644 0 : newobj = (SwigPyObject *)next_self;
2645 : #ifdef SWIGPYTHON_BUILTIN
2646 : newobj->dict = 0;
2647 : #endif
2648 : }
2649 : } else {
2650 0 : newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2651 : #ifdef SWIGPYTHON_BUILTIN
2652 : newobj->dict = 0;
2653 : #endif
2654 : }
2655 0 : if (newobj) {
2656 0 : newobj->ptr = ptr;
2657 0 : newobj->ty = type;
2658 0 : newobj->own = own;
2659 0 : newobj->next = 0;
2660 0 : return (PyObject*) newobj;
2661 : }
2662 0 : return SWIG_Py_Void();
2663 : }
2664 :
2665 : assert(!(flags & SWIG_BUILTIN_TP_INIT));
2666 :
2667 217 : robj = SwigPyObject_New(ptr, type, own);
2668 217 : if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2669 70 : PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2670 70 : Py_DECREF(robj);
2671 : robj = inst;
2672 : }
2673 : return robj;
2674 : }
2675 :
2676 : /* Create a new packed object */
2677 :
2678 : SWIGRUNTIMEINLINE PyObject *
2679 : SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2680 0 : return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2681 : }
2682 :
2683 : /* -----------------------------------------------------------------------------*
2684 : * Get type list
2685 : * -----------------------------------------------------------------------------*/
2686 :
2687 : #ifdef SWIG_LINK_RUNTIME
2688 : void *SWIG_ReturnGlobalTypeList(void *);
2689 : #endif
2690 :
2691 : SWIGRUNTIME swig_module_info *
2692 4 : SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2693 : static void *type_pointer = (void *)0;
2694 : /* first check if module already created */
2695 4 : if (!type_pointer) {
2696 : #ifdef SWIG_LINK_RUNTIME
2697 : type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2698 : #else
2699 : # ifdef SWIGPY_USE_CAPSULE
2700 4 : type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2701 : # else
2702 : type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2703 : (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2704 : # endif
2705 4 : if (PyErr_Occurred()) {
2706 3 : PyErr_Clear();
2707 3 : type_pointer = (void *)0;
2708 : }
2709 : #endif
2710 : }
2711 4 : return (swig_module_info *) type_pointer;
2712 : }
2713 :
2714 : #if PY_MAJOR_VERSION < 2
2715 : /* PyModule_AddObject function was introduced in Python 2.0. The following function
2716 : is copied out of Python/modsupport.c in python version 2.3.4 */
2717 : SWIGINTERN int
2718 : PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2719 : {
2720 : PyObject *dict;
2721 : if (!PyModule_Check(m)) {
2722 : PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2723 : return SWIG_ERROR;
2724 : }
2725 : if (!o) {
2726 : PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2727 : return SWIG_ERROR;
2728 : }
2729 :
2730 : dict = PyModule_GetDict(m);
2731 : if (dict == NULL) {
2732 : /* Internal error -- modules must have a dict! */
2733 : PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2734 : PyModule_GetName(m));
2735 : return SWIG_ERROR;
2736 : }
2737 : if (PyDict_SetItemString(dict, name, o))
2738 : return SWIG_ERROR;
2739 : Py_DECREF(o);
2740 : return SWIG_OK;
2741 : }
2742 : #endif
2743 :
2744 : SWIGRUNTIME void
2745 : #ifdef SWIGPY_USE_CAPSULE
2746 3 : SWIG_Python_DestroyModule(PyObject *obj)
2747 : #else
2748 : SWIG_Python_DestroyModule(void *vptr)
2749 : #endif
2750 : {
2751 : #ifdef SWIGPY_USE_CAPSULE
2752 3 : swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2753 : #else
2754 : swig_module_info *swig_module = (swig_module_info *) vptr;
2755 : #endif
2756 3 : swig_type_info **types = swig_module->types;
2757 : size_t i;
2758 96 : for (i =0; i < swig_module->size; ++i) {
2759 93 : swig_type_info *ty = types[i];
2760 93 : if (ty->owndata) {
2761 36 : SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2762 36 : if (data) SwigPyClientData_Del(data);
2763 : }
2764 : }
2765 5 : Py_DECREF(SWIG_This());
2766 3 : swig_this = NULL;
2767 3 : }
2768 :
2769 : SWIGRUNTIME void
2770 3 : SWIG_Python_SetModule(swig_module_info *swig_module) {
2771 : #if PY_VERSION_HEX >= 0x03000000
2772 : /* Add a dummy module object into sys.modules */
2773 : PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2774 : #else
2775 : static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2776 3 : PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2777 : #endif
2778 : #ifdef SWIGPY_USE_CAPSULE
2779 3 : PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2780 3 : if (pointer && module) {
2781 3 : PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2782 : } else {
2783 0 : Py_XDECREF(pointer);
2784 : }
2785 : #else
2786 : PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2787 : if (pointer && module) {
2788 : PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2789 : } else {
2790 : Py_XDECREF(pointer);
2791 : }
2792 : #endif
2793 3 : }
2794 :
2795 : /* The python cached type query */
2796 : SWIGRUNTIME PyObject *
2797 1 : SWIG_Python_TypeCache(void) {
2798 1 : static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2799 1 : return cache;
2800 : }
2801 :
2802 : SWIGRUNTIME swig_type_info *
2803 1 : SWIG_Python_TypeQuery(const char *type)
2804 : {
2805 1 : PyObject *cache = SWIG_Python_TypeCache();
2806 1 : PyObject *key = SWIG_Python_str_FromChar(type);
2807 1 : PyObject *obj = PyDict_GetItem(cache, key);
2808 : swig_type_info *descriptor;
2809 1 : if (obj) {
2810 : #ifdef SWIGPY_USE_CAPSULE
2811 0 : descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2812 : #else
2813 : descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2814 : #endif
2815 : } else {
2816 1 : swig_module_info *swig_module = SWIG_GetModule(0);
2817 1 : descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2818 1 : if (descriptor) {
2819 : #ifdef SWIGPY_USE_CAPSULE
2820 1 : obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2821 : #else
2822 : obj = PyCObject_FromVoidPtr(descriptor, NULL);
2823 : #endif
2824 1 : PyDict_SetItem(cache, key, obj);
2825 1 : Py_DECREF(obj);
2826 : }
2827 : }
2828 1 : Py_DECREF(key);
2829 1 : return descriptor;
2830 : }
2831 :
2832 : /*
2833 : For backward compatibility only
2834 : */
2835 : #define SWIG_POINTER_EXCEPTION 0
2836 : #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2837 : #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2838 :
2839 : SWIGRUNTIME int
2840 : SWIG_Python_AddErrMesg(const char* mesg, int infront)
2841 : {
2842 : if (PyErr_Occurred()) {
2843 : PyObject *type = 0;
2844 : PyObject *value = 0;
2845 : PyObject *traceback = 0;
2846 : PyErr_Fetch(&type, &value, &traceback);
2847 : if (value) {
2848 : char *tmp;
2849 : PyObject *old_str = PyObject_Str(value);
2850 : Py_XINCREF(type);
2851 : PyErr_Clear();
2852 : if (infront) {
2853 : PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2854 : } else {
2855 : PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2856 : }
2857 : SWIG_Python_str_DelForPy3(tmp);
2858 : Py_DECREF(old_str);
2859 : }
2860 : return 1;
2861 : } else {
2862 : return 0;
2863 : }
2864 : }
2865 :
2866 : SWIGRUNTIME int
2867 : SWIG_Python_ArgFail(int argnum)
2868 : {
2869 : if (PyErr_Occurred()) {
2870 : /* add information about failing argument */
2871 : char mesg[256];
2872 : PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2873 : return SWIG_Python_AddErrMesg(mesg, 1);
2874 : } else {
2875 : return 0;
2876 : }
2877 : }
2878 :
2879 : SWIGRUNTIMEINLINE const char *
2880 : SwigPyObject_GetDesc(PyObject *self)
2881 : {
2882 : SwigPyObject *v = (SwigPyObject *)self;
2883 : swig_type_info *ty = v ? v->ty : 0;
2884 : return ty ? ty->str : "";
2885 : }
2886 :
2887 : SWIGRUNTIME void
2888 : SWIG_Python_TypeError(const char *type, PyObject *obj)
2889 : {
2890 : if (type) {
2891 : #if defined(SWIG_COBJECT_TYPES)
2892 : if (obj && SwigPyObject_Check(obj)) {
2893 : const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2894 : if (otype) {
2895 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2896 : type, otype);
2897 : return;
2898 : }
2899 : } else
2900 : #endif
2901 : {
2902 : const char *otype = (obj ? obj->ob_type->tp_name : 0);
2903 : if (otype) {
2904 : PyObject *str = PyObject_Str(obj);
2905 : const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2906 : if (cstr) {
2907 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2908 : type, otype, cstr);
2909 : SWIG_Python_str_DelForPy3(cstr);
2910 : } else {
2911 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2912 : type, otype);
2913 : }
2914 : Py_XDECREF(str);
2915 : return;
2916 : }
2917 : }
2918 : PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2919 : } else {
2920 : PyErr_Format(PyExc_TypeError, "unexpected type is received");
2921 : }
2922 : }
2923 :
2924 :
2925 : /* Convert a pointer value, signal an exception on a type mismatch */
2926 : SWIGRUNTIME void *
2927 : SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2928 : void *result;
2929 : if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2930 : PyErr_Clear();
2931 : #if SWIG_POINTER_EXCEPTION
2932 : if (flags) {
2933 : SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2934 : SWIG_Python_ArgFail(argnum);
2935 : }
2936 : #endif
2937 : }
2938 : return result;
2939 : }
2940 :
2941 : #ifdef SWIGPYTHON_BUILTIN
2942 : SWIGRUNTIME int
2943 : SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2944 : PyTypeObject *tp = obj->ob_type;
2945 : PyObject *descr;
2946 : PyObject *encoded_name;
2947 : descrsetfunc f;
2948 : int res = -1;
2949 :
2950 : # ifdef Py_USING_UNICODE
2951 : if (PyString_Check(name)) {
2952 : name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2953 : if (!name)
2954 : return -1;
2955 : } else if (!PyUnicode_Check(name))
2956 : # else
2957 : if (!PyString_Check(name))
2958 : # endif
2959 : {
2960 : PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2961 : return -1;
2962 : } else {
2963 : Py_INCREF(name);
2964 : }
2965 :
2966 : if (!tp->tp_dict) {
2967 : if (PyType_Ready(tp) < 0)
2968 : goto done;
2969 : }
2970 :
2971 : descr = _PyType_Lookup(tp, name);
2972 : f = NULL;
2973 : if (descr != NULL)
2974 : f = descr->ob_type->tp_descr_set;
2975 : if (!f) {
2976 : if (PyString_Check(name)) {
2977 : encoded_name = name;
2978 : Py_INCREF(name);
2979 : } else {
2980 : encoded_name = PyUnicode_AsUTF8String(name);
2981 : }
2982 : PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2983 : Py_DECREF(encoded_name);
2984 : } else {
2985 : res = f(descr, obj, value);
2986 : }
2987 :
2988 : done:
2989 : Py_DECREF(name);
2990 : return res;
2991 : }
2992 : #endif
2993 :
2994 :
2995 : #ifdef __cplusplus
2996 : }
2997 : #endif
2998 :
2999 :
3000 :
3001 : #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3002 :
3003 : #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
3004 :
3005 :
3006 :
3007 : #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
3008 :
3009 :
3010 : /* -------- TYPES TABLE (BEGIN) -------- */
3011 :
3012 : #define SWIGTYPE_p_Key swig_types[0]
3013 : #define SWIGTYPE_p__Key swig_types[1]
3014 : #define SWIGTYPE_p__KeySet swig_types[2]
3015 : #define SWIGTYPE_p_char swig_types[3]
3016 : #define SWIGTYPE_p_f___void swig_types[4]
3017 : #define SWIGTYPE_p_f_p__KeySet_p__Key_p__Key_option_t__p__Key swig_types[5]
3018 : #define SWIGTYPE_p_int swig_types[6]
3019 : #define SWIGTYPE_p_kdb__ContractException swig_types[7]
3020 : #define SWIGTYPE_p_kdb__Exception swig_types[8]
3021 : #define SWIGTYPE_p_kdb__KDB swig_types[9]
3022 : #define SWIGTYPE_p_kdb__KDBException swig_types[10]
3023 : #define SWIGTYPE_p_kdb__Key swig_types[11]
3024 : #define SWIGTYPE_p_kdb__KeyException swig_types[12]
3025 : #define SWIGTYPE_p_kdb__KeyInvalidName swig_types[13]
3026 : #define SWIGTYPE_p_kdb__KeyNotFoundException swig_types[14]
3027 : #define SWIGTYPE_p_kdb__KeySet swig_types[15]
3028 : #define SWIGTYPE_p_kdb__KeyTypeConversion swig_types[16]
3029 : #define SWIGTYPE_p_kdb__KeyTypeMismatch swig_types[17]
3030 : #define SWIGTYPE_p_long_long swig_types[18]
3031 : #define SWIGTYPE_p_option_t swig_types[19]
3032 : #define SWIGTYPE_p_p_PyObject swig_types[20]
3033 : #define SWIGTYPE_p_short swig_types[21]
3034 : #define SWIGTYPE_p_signed_char swig_types[22]
3035 : #define SWIGTYPE_p_std__exception swig_types[23]
3036 : #define SWIGTYPE_p_std__invalid_argument swig_types[24]
3037 : #define SWIGTYPE_p_swig__SwigPyIterator swig_types[25]
3038 : #define SWIGTYPE_p_unsigned_char swig_types[26]
3039 : #define SWIGTYPE_p_unsigned_int swig_types[27]
3040 : #define SWIGTYPE_p_unsigned_long_long swig_types[28]
3041 : #define SWIGTYPE_p_unsigned_short swig_types[29]
3042 : #define SWIGTYPE_p_void swig_types[30]
3043 : static swig_type_info *swig_types[32];
3044 : static swig_module_info swig_module = {swig_types, 31, 0, 0, 0, 0};
3045 : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3046 : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3047 :
3048 : /* -------- TYPES TABLE (END) -------- */
3049 :
3050 : #if (PY_VERSION_HEX <= 0x02000000)
3051 : # if !defined(SWIG_PYTHON_CLASSIC)
3052 : # error "This python version requires swig to be run with the '-classic' option"
3053 : # endif
3054 : #endif
3055 : #if (PY_VERSION_HEX <= 0x02020000)
3056 : # error "This python version requires swig to be run with the '-nomodern' option"
3057 : #endif
3058 : #if (PY_VERSION_HEX <= 0x02020000)
3059 : # error "This python version requires swig to be run with the '-nomodernargs' option"
3060 : #endif
3061 : #ifndef METH_O
3062 : # error "This python version requires swig to be run with the '-nofastunpack' option"
3063 : #endif
3064 : #ifdef SWIG_TypeQuery
3065 : # undef SWIG_TypeQuery
3066 : #endif
3067 : #define SWIG_TypeQuery SWIG_Python_TypeQuery
3068 :
3069 : /*-----------------------------------------------
3070 : @(target):= _kdb.so
3071 : ------------------------------------------------*/
3072 : #if PY_VERSION_HEX >= 0x03000000
3073 : # define SWIG_init PyInit__kdb
3074 :
3075 : #else
3076 : # define SWIG_init init_kdb
3077 :
3078 : #endif
3079 : #define SWIG_name "_kdb"
3080 :
3081 : #define SWIGVERSION 0x030010
3082 : #define SWIG_VERSION SWIGVERSION
3083 :
3084 :
3085 : #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
3086 : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
3087 :
3088 :
3089 : #include <stdexcept>
3090 :
3091 :
3092 : namespace swig {
3093 : class SwigPtr_PyObject {
3094 : protected:
3095 : PyObject *_obj;
3096 :
3097 : public:
3098 : SwigPtr_PyObject() :_obj(0)
3099 : {
3100 : }
3101 :
3102 0 : SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
3103 : {
3104 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3105 0 : Py_XINCREF(_obj);
3106 : SWIG_PYTHON_THREAD_END_BLOCK;
3107 : }
3108 :
3109 7 : SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
3110 : {
3111 : if (initial_ref) {
3112 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3113 7 : Py_XINCREF(_obj);
3114 : SWIG_PYTHON_THREAD_END_BLOCK;
3115 : }
3116 : }
3117 :
3118 : SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
3119 : {
3120 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3121 : Py_XINCREF(item._obj);
3122 : Py_XDECREF(_obj);
3123 : _obj = item._obj;
3124 : SWIG_PYTHON_THREAD_END_BLOCK;
3125 : return *this;
3126 : }
3127 :
3128 : ~SwigPtr_PyObject()
3129 : {
3130 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3131 0 : Py_XDECREF(_obj);
3132 : SWIG_PYTHON_THREAD_END_BLOCK;
3133 : }
3134 :
3135 : operator PyObject *() const
3136 : {
3137 : return _obj;
3138 : }
3139 :
3140 : PyObject *operator->() const
3141 : {
3142 : return _obj;
3143 : }
3144 : };
3145 : }
3146 :
3147 :
3148 : namespace swig {
3149 : struct SwigVar_PyObject : SwigPtr_PyObject {
3150 : SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
3151 :
3152 : SwigVar_PyObject & operator = (PyObject* obj)
3153 : {
3154 : Py_XDECREF(_obj);
3155 : _obj = obj;
3156 : return *this;
3157 : }
3158 : };
3159 : }
3160 :
3161 :
3162 : #include <stdexcept>
3163 :
3164 :
3165 : #if defined(__GNUC__)
3166 : # if __GNUC__ == 2 && __GNUC_MINOR <= 96
3167 : # define SWIG_STD_NOMODERN_STL
3168 : # endif
3169 : #endif
3170 :
3171 :
3172 : #include <string>
3173 :
3174 :
3175 : #include <stddef.h>
3176 :
3177 :
3178 : #include <iostream>
3179 :
3180 : #if PY_VERSION_HEX >= 0x03020000
3181 : # define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
3182 : #else
3183 : # define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
3184 : #endif
3185 :
3186 :
3187 : namespace swig {
3188 : struct stop_iteration {
3189 : };
3190 :
3191 0 : struct SwigPyIterator {
3192 : private:
3193 : SwigPtr_PyObject _seq;
3194 :
3195 : protected:
3196 14 : SwigPyIterator(PyObject *seq) : _seq(seq)
3197 : {
3198 : }
3199 :
3200 : public:
3201 0 : virtual ~SwigPyIterator() {}
3202 :
3203 : // Access iterator method, required by Python
3204 : virtual PyObject *value() const = 0;
3205 :
3206 : // Forward iterator method, required by Python
3207 : virtual SwigPyIterator *incr(size_t n = 1) = 0;
3208 :
3209 : // Backward iterator method, very common in C++, but not required in Python
3210 0 : virtual SwigPyIterator *decr(size_t /*n*/ = 1)
3211 : {
3212 0 : throw stop_iteration();
3213 : }
3214 :
3215 : // Random access iterator methods, but not required in Python
3216 0 : virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
3217 : {
3218 0 : throw std::invalid_argument("operation not supported");
3219 : }
3220 :
3221 0 : virtual bool equal (const SwigPyIterator &/*x*/) const
3222 : {
3223 0 : throw std::invalid_argument("operation not supported");
3224 : }
3225 :
3226 : // C++ common/needed methods
3227 : virtual SwigPyIterator *copy() const = 0;
3228 :
3229 : PyObject *next()
3230 : {
3231 : SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3232 19 : PyObject *obj = value();
3233 14 : incr();
3234 : SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3235 : return obj;
3236 : }
3237 :
3238 : /* Make an alias for Python 3.x */
3239 : PyObject *__next__()
3240 : {
3241 : return next();
3242 : }
3243 :
3244 : PyObject *previous()
3245 : {
3246 : SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
3247 0 : decr();
3248 0 : PyObject *obj = value();
3249 : SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
3250 : return obj;
3251 : }
3252 :
3253 : SwigPyIterator *advance(ptrdiff_t n)
3254 : {
3255 0 : return (n > 0) ? incr(n) : decr(-n);
3256 : }
3257 :
3258 : bool operator == (const SwigPyIterator& x) const
3259 : {
3260 0 : return equal(x);
3261 : }
3262 :
3263 : bool operator != (const SwigPyIterator& x) const
3264 : {
3265 0 : return ! operator==(x);
3266 : }
3267 :
3268 : SwigPyIterator& operator += (ptrdiff_t n)
3269 : {
3270 0 : return *advance(n);
3271 : }
3272 :
3273 : SwigPyIterator& operator -= (ptrdiff_t n)
3274 : {
3275 0 : return *advance(-n);
3276 : }
3277 :
3278 0 : SwigPyIterator* operator + (ptrdiff_t n) const
3279 : {
3280 0 : return copy()->advance(n);
3281 : }
3282 :
3283 0 : SwigPyIterator* operator - (ptrdiff_t n) const
3284 : {
3285 0 : return copy()->advance(-n);
3286 : }
3287 :
3288 : ptrdiff_t operator - (const SwigPyIterator& x) const
3289 : {
3290 0 : return x.distance(*this);
3291 : }
3292 :
3293 : static swig_type_info* descriptor() {
3294 : static int init = 0;
3295 : static swig_type_info* desc = 0;
3296 : if (!init) {
3297 : desc = SWIG_TypeQuery("swig::SwigPyIterator *");
3298 : init = 1;
3299 : }
3300 : return desc;
3301 : }
3302 : };
3303 :
3304 : #if defined(SWIGPYTHON_BUILTIN)
3305 : inline PyObject* make_output_iterator_builtin (PyObject *pyself)
3306 : {
3307 : Py_INCREF(pyself);
3308 : return pyself;
3309 : }
3310 : #endif
3311 : }
3312 :
3313 :
3314 : SWIGINTERN int
3315 : SWIG_AsVal_double (PyObject *obj, double *val)
3316 : {
3317 : int res = SWIG_TypeError;
3318 : if (PyFloat_Check(obj)) {
3319 : if (val) *val = PyFloat_AsDouble(obj);
3320 : return SWIG_OK;
3321 : #if PY_VERSION_HEX < 0x03000000
3322 : } else if (PyInt_Check(obj)) {
3323 : if (val) *val = PyInt_AsLong(obj);
3324 : return SWIG_OK;
3325 : #endif
3326 : } else if (PyLong_Check(obj)) {
3327 : double v = PyLong_AsDouble(obj);
3328 : if (!PyErr_Occurred()) {
3329 : if (val) *val = v;
3330 : return SWIG_OK;
3331 : } else {
3332 : PyErr_Clear();
3333 : }
3334 : }
3335 : #ifdef SWIG_PYTHON_CAST_MODE
3336 : {
3337 : int dispatch = 0;
3338 : double d = PyFloat_AsDouble(obj);
3339 : if (!PyErr_Occurred()) {
3340 : if (val) *val = d;
3341 : return SWIG_AddCast(SWIG_OK);
3342 : } else {
3343 : PyErr_Clear();
3344 : }
3345 : if (!dispatch) {
3346 : long v = PyLong_AsLong(obj);
3347 : if (!PyErr_Occurred()) {
3348 : if (val) *val = v;
3349 : return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3350 : } else {
3351 : PyErr_Clear();
3352 : }
3353 : }
3354 : }
3355 : #endif
3356 : return res;
3357 : }
3358 :
3359 :
3360 : #include <float.h>
3361 :
3362 :
3363 : #include <math.h>
3364 :
3365 :
3366 : SWIGINTERNINLINE int
3367 : SWIG_CanCastAsInteger(double *d, double min, double max) {
3368 : double x = *d;
3369 : if ((min <= x && x <= max)) {
3370 : double fx = floor(x);
3371 : double cx = ceil(x);
3372 : double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3373 : if ((errno == EDOM) || (errno == ERANGE)) {
3374 : errno = 0;
3375 : } else {
3376 : double summ, reps, diff;
3377 : if (rd < x) {
3378 : diff = x - rd;
3379 : } else if (rd > x) {
3380 : diff = rd - x;
3381 : } else {
3382 : return 1;
3383 : }
3384 : summ = rd + x;
3385 : reps = diff/summ;
3386 : if (reps < 8*DBL_EPSILON) {
3387 : *d = rd;
3388 : return 1;
3389 : }
3390 : }
3391 : }
3392 : return 0;
3393 : }
3394 :
3395 :
3396 : SWIGINTERN int
3397 15 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3398 : {
3399 : #if PY_VERSION_HEX < 0x03000000
3400 15 : if (PyInt_Check(obj)) {
3401 15 : long v = PyInt_AsLong(obj);
3402 15 : if (v >= 0) {
3403 15 : if (val) *val = v;
3404 : return SWIG_OK;
3405 : } else {
3406 : return SWIG_OverflowError;
3407 : }
3408 : } else
3409 : #endif
3410 0 : if (PyLong_Check(obj)) {
3411 0 : unsigned long v = PyLong_AsUnsignedLong(obj);
3412 0 : if (!PyErr_Occurred()) {
3413 0 : if (val) *val = v;
3414 : return SWIG_OK;
3415 : } else {
3416 0 : PyErr_Clear();
3417 0 : return SWIG_OverflowError;
3418 : }
3419 : }
3420 : #ifdef SWIG_PYTHON_CAST_MODE
3421 : {
3422 : int dispatch = 0;
3423 : unsigned long v = PyLong_AsUnsignedLong(obj);
3424 : if (!PyErr_Occurred()) {
3425 : if (val) *val = v;
3426 : return SWIG_AddCast(SWIG_OK);
3427 : } else {
3428 : PyErr_Clear();
3429 : }
3430 : if (!dispatch) {
3431 : double d;
3432 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3433 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3434 : if (val) *val = (unsigned long)(d);
3435 : return res;
3436 : }
3437 : }
3438 : }
3439 : #endif
3440 : return SWIG_TypeError;
3441 : }
3442 :
3443 :
3444 : #include <limits.h>
3445 : #if !defined(SWIG_NO_LLONG_MAX)
3446 : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3447 : # define LLONG_MAX __LONG_LONG_MAX__
3448 : # define LLONG_MIN (-LLONG_MAX - 1LL)
3449 : # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3450 : # endif
3451 : #endif
3452 :
3453 :
3454 : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
3455 : # define SWIG_LONG_LONG_AVAILABLE
3456 : #endif
3457 :
3458 :
3459 : #ifdef SWIG_LONG_LONG_AVAILABLE
3460 : SWIGINTERN int
3461 : SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
3462 : {
3463 : int res = SWIG_TypeError;
3464 : if (PyLong_Check(obj)) {
3465 : unsigned long long v = PyLong_AsUnsignedLongLong(obj);
3466 : if (!PyErr_Occurred()) {
3467 : if (val) *val = v;
3468 : return SWIG_OK;
3469 : } else {
3470 : PyErr_Clear();
3471 : res = SWIG_OverflowError;
3472 : }
3473 : } else {
3474 : unsigned long v;
3475 : res = SWIG_AsVal_unsigned_SS_long (obj,&v);
3476 : if (SWIG_IsOK(res)) {
3477 : if (val) *val = v;
3478 : return res;
3479 : }
3480 : }
3481 : #ifdef SWIG_PYTHON_CAST_MODE
3482 : {
3483 : const double mant_max = 1LL << DBL_MANT_DIG;
3484 : double d;
3485 : res = SWIG_AsVal_double (obj,&d);
3486 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
3487 : if (val) *val = (unsigned long long)(d);
3488 : return SWIG_AddCast(res);
3489 : }
3490 : res = SWIG_TypeError;
3491 : }
3492 : #endif
3493 : return res;
3494 : }
3495 : #endif
3496 :
3497 :
3498 : SWIGINTERNINLINE int
3499 : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3500 : {
3501 15 : int res = SWIG_TypeError;
3502 : #ifdef SWIG_LONG_LONG_AVAILABLE
3503 : if (sizeof(size_t) <= sizeof(unsigned long)) {
3504 : #endif
3505 : unsigned long v;
3506 15 : res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3507 15 : if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3508 : #ifdef SWIG_LONG_LONG_AVAILABLE
3509 : } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
3510 : unsigned long long v;
3511 : res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
3512 : if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3513 : }
3514 : #endif
3515 : return res;
3516 : }
3517 :
3518 :
3519 : #define SWIG_From_long PyInt_FromLong
3520 :
3521 :
3522 : #ifdef SWIG_LONG_LONG_AVAILABLE
3523 : SWIGINTERNINLINE PyObject*
3524 : SWIG_From_long_SS_long (long long value)
3525 : {
3526 : return ((value < LONG_MIN) || (value > LONG_MAX)) ?
3527 : PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
3528 : }
3529 : #endif
3530 :
3531 :
3532 : SWIGINTERNINLINE PyObject *
3533 : SWIG_From_ptrdiff_t (ptrdiff_t value)
3534 : {
3535 : #ifdef SWIG_LONG_LONG_AVAILABLE
3536 : if (sizeof(ptrdiff_t) <= sizeof(long)) {
3537 : #endif
3538 0 : return SWIG_From_long (static_cast< long >(value));
3539 : #ifdef SWIG_LONG_LONG_AVAILABLE
3540 : } else {
3541 : /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
3542 : return SWIG_From_long_SS_long (static_cast< long long >(value));
3543 : }
3544 : #endif
3545 : }
3546 :
3547 :
3548 : SWIGINTERNINLINE PyObject*
3549 : SWIG_From_bool (bool value)
3550 : {
3551 122 : return PyBool_FromLong(value ? 1 : 0);
3552 : }
3553 :
3554 :
3555 : SWIGINTERN int
3556 140 : SWIG_AsVal_long (PyObject *obj, long* val)
3557 : {
3558 : #if PY_VERSION_HEX < 0x03000000
3559 140 : if (PyInt_Check(obj)) {
3560 134 : if (val) *val = PyInt_AsLong(obj);
3561 : return SWIG_OK;
3562 : } else
3563 : #endif
3564 6 : if (PyLong_Check(obj)) {
3565 0 : long v = PyLong_AsLong(obj);
3566 0 : if (!PyErr_Occurred()) {
3567 0 : if (val) *val = v;
3568 : return SWIG_OK;
3569 : } else {
3570 0 : PyErr_Clear();
3571 0 : return SWIG_OverflowError;
3572 : }
3573 : }
3574 : #ifdef SWIG_PYTHON_CAST_MODE
3575 : {
3576 : int dispatch = 0;
3577 : long v = PyInt_AsLong(obj);
3578 : if (!PyErr_Occurred()) {
3579 : if (val) *val = v;
3580 : return SWIG_AddCast(SWIG_OK);
3581 : } else {
3582 : PyErr_Clear();
3583 : }
3584 : if (!dispatch) {
3585 : double d;
3586 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3587 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3588 : if (val) *val = (long)(d);
3589 : return res;
3590 : }
3591 : }
3592 : }
3593 : #endif
3594 : return SWIG_TypeError;
3595 : }
3596 :
3597 :
3598 : #ifdef SWIG_LONG_LONG_AVAILABLE
3599 : SWIGINTERN int
3600 : SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
3601 : {
3602 : int res = SWIG_TypeError;
3603 : if (PyLong_Check(obj)) {
3604 : long long v = PyLong_AsLongLong(obj);
3605 : if (!PyErr_Occurred()) {
3606 : if (val) *val = v;
3607 : return SWIG_OK;
3608 : } else {
3609 : PyErr_Clear();
3610 : res = SWIG_OverflowError;
3611 : }
3612 : } else {
3613 : long v;
3614 : res = SWIG_AsVal_long (obj,&v);
3615 : if (SWIG_IsOK(res)) {
3616 : if (val) *val = v;
3617 : return res;
3618 : }
3619 : }
3620 : #ifdef SWIG_PYTHON_CAST_MODE
3621 : {
3622 : const double mant_max = 1LL << DBL_MANT_DIG;
3623 : const double mant_min = -mant_max;
3624 : double d;
3625 : res = SWIG_AsVal_double (obj,&d);
3626 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
3627 : if (val) *val = (long long)(d);
3628 : return SWIG_AddCast(res);
3629 : }
3630 : res = SWIG_TypeError;
3631 : }
3632 : #endif
3633 : return res;
3634 : }
3635 : #endif
3636 :
3637 :
3638 : SWIGINTERNINLINE int
3639 : SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
3640 : {
3641 0 : int res = SWIG_TypeError;
3642 : #ifdef SWIG_LONG_LONG_AVAILABLE
3643 : if (sizeof(ptrdiff_t) <= sizeof(long)) {
3644 : #endif
3645 : long v;
3646 0 : res = SWIG_AsVal_long (obj, val ? &v : 0);
3647 0 : if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
3648 : #ifdef SWIG_LONG_LONG_AVAILABLE
3649 : } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
3650 : long long v;
3651 : res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
3652 : if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
3653 : }
3654 : #endif
3655 : return res;
3656 : }
3657 :
3658 :
3659 : #include <algorithm>
3660 :
3661 :
3662 : #include <vector>
3663 :
3664 :
3665 : #include <utility>
3666 :
3667 :
3668 : #include <map>
3669 :
3670 :
3671 : #include <algorithm>
3672 :
3673 :
3674 : #include <stdint.h> // Use the C99 official header
3675 :
3676 :
3677 : extern "C" {
3678 : #include "kdbconfig.h"
3679 : #include "kdb.h"
3680 : }
3681 :
3682 : #include "keyexcept.hpp"
3683 : #include "kdbexcept.hpp"
3684 : #include "key.hpp"
3685 : #include "keyset.hpp"
3686 : #include "kdb.hpp"
3687 : using namespace kdb;
3688 :
3689 :
3690 : SWIGINTERN swig_type_info*
3691 : SWIG_pchar_descriptor(void)
3692 : {
3693 : static int init = 0;
3694 : static swig_type_info* info = 0;
3695 0 : if (!init) {
3696 0 : info = SWIG_TypeQuery("_p_char");
3697 0 : init = 1;
3698 : }
3699 0 : return info;
3700 : }
3701 :
3702 :
3703 : SWIGINTERNINLINE PyObject *
3704 41 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3705 : {
3706 41 : if (carray) {
3707 41 : if (size > INT_MAX) {
3708 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3709 0 : return pchar_descriptor ?
3710 : SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3711 : } else {
3712 : #if PY_VERSION_HEX >= 0x03000000
3713 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3714 : return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
3715 : #else
3716 : #if PY_VERSION_HEX >= 0x03010000
3717 : return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
3718 : #else
3719 : return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
3720 : #endif
3721 : #endif
3722 : #else
3723 41 : return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
3724 : #endif
3725 : }
3726 : } else {
3727 0 : return SWIG_Py_Void();
3728 : }
3729 : }
3730 :
3731 :
3732 : SWIGINTERNINLINE PyObject *
3733 0 : SWIG_FromCharPtr(const char *cptr)
3734 : {
3735 15 : return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3736 : }
3737 :
3738 :
3739 : SWIGINTERNINLINE PyObject *
3740 : SWIG_From_short (short value)
3741 : {
3742 9 : return SWIG_From_long (value);
3743 : }
3744 :
3745 :
3746 : SWIGINTERNINLINE PyObject*
3747 : SWIG_From_int (int value)
3748 : {
3749 150 : return PyInt_FromLong((long) value);
3750 : }
3751 :
3752 :
3753 : #define KEY_EXCEPTIONS \
3754 : KDB_CATCH_EX(kdb, KeyTypeMismatch) \
3755 : KDB_CATCH_EX(kdb, KeyInvalidName) \
3756 : KDB_CATCH_EX(kdb, KeyTypeConversion) \
3757 : KDB_CATCH_EX(kdb, KeyException) \
3758 : KDB_CATCH_EX(kdb, Exception)
3759 :
3760 : #define KDB_EXCEPTIONS \
3761 : KDB_CATCH_EX(kdb, KDBException) \
3762 : KDB_CATCH_EX(kdb, Exception)
3763 :
3764 :
3765 : #define KDB_CATCH_EX(namespace, exception) \
3766 : catch(const namespace::exception &e) \
3767 : { \
3768 : SWIG_Python_Raise(SWIG_NewPointerObj(new namespace::exception(e), \
3769 : SWIGTYPE_p_##namespace##__##exception, SWIG_POINTER_OWN), \
3770 : #exception, SWIGTYPE_p_##namespace##__##exception); \
3771 : SWIG_fail; \
3772 : }
3773 :
3774 :
3775 : SWIGINTERN int
3776 176 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3777 : {
3778 : #if PY_VERSION_HEX>=0x03000000
3779 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3780 : if (PyBytes_Check(obj))
3781 : #else
3782 : if (PyUnicode_Check(obj))
3783 : #endif
3784 : #else
3785 176 : if (PyString_Check(obj))
3786 : #endif
3787 : {
3788 : char *cstr; Py_ssize_t len;
3789 : #if PY_VERSION_HEX>=0x03000000
3790 : #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3791 : if (!alloc && cptr) {
3792 : /* We can't allow converting without allocation, since the internal
3793 : representation of string in Python 3 is UCS-2/UCS-4 but we require
3794 : a UTF-8 representation.
3795 : TODO(bhy) More detailed explanation */
3796 : return SWIG_RuntimeError;
3797 : }
3798 : obj = PyUnicode_AsUTF8String(obj);
3799 : if(alloc) *alloc = SWIG_NEWOBJ;
3800 : #endif
3801 : PyBytes_AsStringAndSize(obj, &cstr, &len);
3802 : #else
3803 176 : PyString_AsStringAndSize(obj, &cstr, &len);
3804 : #endif
3805 176 : if (cptr) {
3806 176 : if (alloc) {
3807 : /*
3808 : In python the user should not be able to modify the inner
3809 : string representation. To warranty that, if you define
3810 : SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3811 : buffer is always returned.
3812 :
3813 : The default behavior is just to return the pointer value,
3814 : so, be careful.
3815 : */
3816 : #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3817 : if (*alloc != SWIG_OLDOBJ)
3818 : #else
3819 176 : if (*alloc == SWIG_NEWOBJ)
3820 : #endif
3821 : {
3822 0 : *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3823 0 : *alloc = SWIG_NEWOBJ;
3824 : } else {
3825 176 : *cptr = cstr;
3826 176 : *alloc = SWIG_OLDOBJ;
3827 : }
3828 : } else {
3829 : #if PY_VERSION_HEX>=0x03000000
3830 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3831 : *cptr = PyBytes_AsString(obj);
3832 : #else
3833 : assert(0); /* Should never reach here with Unicode strings in Python 3 */
3834 : #endif
3835 : #else
3836 0 : *cptr = SWIG_Python_str_AsChar(obj);
3837 : #endif
3838 : }
3839 : }
3840 176 : if (psize) *psize = len + 1;
3841 : #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3842 : Py_XDECREF(obj);
3843 : #endif
3844 : return SWIG_OK;
3845 : } else {
3846 : #if defined(SWIG_PYTHON_2_UNICODE)
3847 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3848 : #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3849 : #endif
3850 : #if PY_VERSION_HEX<0x03000000
3851 : if (PyUnicode_Check(obj)) {
3852 : char *cstr; Py_ssize_t len;
3853 : if (!alloc && cptr) {
3854 : return SWIG_RuntimeError;
3855 : }
3856 : obj = PyUnicode_AsUTF8String(obj);
3857 : if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3858 : if (cptr) {
3859 : if (alloc) *alloc = SWIG_NEWOBJ;
3860 : *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3861 : }
3862 : if (psize) *psize = len + 1;
3863 :
3864 : Py_XDECREF(obj);
3865 : return SWIG_OK;
3866 : } else {
3867 : Py_XDECREF(obj);
3868 : }
3869 : }
3870 : #endif
3871 : #endif
3872 :
3873 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3874 0 : if (pchar_descriptor) {
3875 0 : void* vptr = 0;
3876 0 : if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3877 0 : if (cptr) *cptr = (char *) vptr;
3878 0 : if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3879 0 : if (alloc) *alloc = SWIG_OLDOBJ;
3880 0 : return SWIG_OK;
3881 : }
3882 : }
3883 : }
3884 : return SWIG_TypeError;
3885 : }
3886 :
3887 :
3888 : SWIGINTERN int
3889 70 : SWIG_AsPtr_std_string (PyObject * obj, std::string **val)
3890 : {
3891 70 : char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
3892 70 : if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
3893 70 : if (buf) {
3894 280 : if (val) *val = new std::string(buf, size - 1);
3895 70 : if (alloc == SWIG_NEWOBJ) delete[] buf;
3896 : return SWIG_NEWOBJ;
3897 : } else {
3898 0 : if (val) *val = 0;
3899 : return SWIG_OLDOBJ;
3900 : }
3901 : } else {
3902 : static int init = 0;
3903 : static swig_type_info* descriptor = 0;
3904 0 : if (!init) {
3905 0 : descriptor = SWIG_TypeQuery("std::string" " *");
3906 0 : init = 1;
3907 : }
3908 0 : if (descriptor) {
3909 : std::string *vptr;
3910 0 : int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
3911 0 : if (SWIG_IsOK(res) && val) *val = vptr;
3912 : return res;
3913 : }
3914 : }
3915 : return SWIG_ERROR;
3916 : }
3917 :
3918 :
3919 : SWIGINTERN int
3920 : SWIG_AsVal_bool (PyObject *obj, bool *val)
3921 : {
3922 : int r;
3923 0 : if (!PyBool_Check(obj))
3924 : return SWIG_ERROR;
3925 0 : r = PyObject_IsTrue(obj);
3926 0 : if (r == -1)
3927 : return SWIG_ERROR;
3928 0 : if (val) *val = r ? true : false;
3929 : return SWIG_OK;
3930 : }
3931 :
3932 :
3933 : namespace swig {
3934 : template <class Type>
3935 : struct noconst_traits {
3936 : typedef Type noconst_type;
3937 : };
3938 :
3939 : template <class Type>
3940 : struct noconst_traits<const Type> {
3941 : typedef Type noconst_type;
3942 : };
3943 :
3944 : /*
3945 : type categories
3946 : */
3947 : struct pointer_category { };
3948 : struct value_category { };
3949 :
3950 : /*
3951 : General traits that provides type_name and type_info
3952 : */
3953 : template <class Type> struct traits { };
3954 :
3955 : template <class Type>
3956 : inline const char* type_name() {
3957 : return traits<typename noconst_traits<Type >::noconst_type >::type_name();
3958 : }
3959 :
3960 : template <class Type>
3961 : struct traits_info {
3962 : static swig_type_info *type_query(std::string name) {
3963 1 : name += " *";
3964 1 : return SWIG_TypeQuery(name.c_str());
3965 : }
3966 8 : static swig_type_info *type_info() {
3967 12 : static swig_type_info *info = type_query(type_name<Type>());
3968 8 : return info;
3969 : }
3970 : };
3971 :
3972 : template <class Type>
3973 : inline swig_type_info *type_info() {
3974 8 : return traits_info<Type>::type_info();
3975 : }
3976 :
3977 : /*
3978 : Partial specialization for pointers
3979 : */
3980 : template <class Type> struct traits <Type *> {
3981 : typedef pointer_category category;
3982 : static std::string make_ptr_name(const char* name) {
3983 : std::string ptrname = name;
3984 : ptrname += " *";
3985 : return ptrname;
3986 : }
3987 : static const char* type_name() {
3988 : static std::string name = make_ptr_name(swig::type_name<Type>());
3989 : return name.c_str();
3990 : }
3991 : };
3992 :
3993 : template <class Type, class Category>
3994 : struct traits_as { };
3995 :
3996 : template <class Type, class Category>
3997 : struct traits_check { };
3998 :
3999 : }
4000 :
4001 :
4002 : namespace swig {
4003 : /*
4004 : Traits that provides the from method
4005 : */
4006 : template <class Type> struct traits_from_ptr {
4007 : static PyObject *from(Type *val, int owner = 0) {
4008 8 : return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
4009 : }
4010 : };
4011 :
4012 : template <class Type> struct traits_from {
4013 8 : static PyObject *from(const Type& val) {
4014 24 : return traits_from_ptr<Type>::from(new Type(val), 1);
4015 : }
4016 : };
4017 :
4018 : template <class Type> struct traits_from<Type *> {
4019 : static PyObject *from(Type* val) {
4020 : return traits_from_ptr<Type>::from(val, 0);
4021 : }
4022 : };
4023 :
4024 : template <class Type> struct traits_from<const Type *> {
4025 : static PyObject *from(const Type* val) {
4026 : return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
4027 : }
4028 : };
4029 :
4030 :
4031 : template <class Type>
4032 : inline PyObject *from(const Type& val) {
4033 16 : return traits_from<Type>::from(val);
4034 : }
4035 :
4036 : template <class Type>
4037 : inline PyObject *from_ptr(Type* val, int owner) {
4038 : return traits_from_ptr<Type>::from(val, owner);
4039 : }
4040 :
4041 : /*
4042 : Traits that provides the asval/as/check method
4043 : */
4044 : template <class Type>
4045 : struct traits_asptr {
4046 : static int asptr(PyObject *obj, Type **val) {
4047 : Type *p;
4048 : int res = SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0);
4049 : if (SWIG_IsOK(res)) {
4050 : if (val) *val = p;
4051 : }
4052 : return res;
4053 : }
4054 : };
4055 :
4056 : template <class Type>
4057 : inline int asptr(PyObject *obj, Type **vptr) {
4058 : return traits_asptr<Type>::asptr(obj, vptr);
4059 : }
4060 :
4061 : template <class Type>
4062 : struct traits_asval {
4063 : static int asval(PyObject *obj, Type *val) {
4064 : if (val) {
4065 : Type *p = 0;
4066 : int res = traits_asptr<Type>::asptr(obj, &p);
4067 : if (!SWIG_IsOK(res)) return res;
4068 : if (p) {
4069 : typedef typename noconst_traits<Type>::noconst_type noconst_type;
4070 : *(const_cast<noconst_type*>(val)) = *p;
4071 : if (SWIG_IsNewObj(res)){
4072 : delete p;
4073 : res = SWIG_DelNewMask(res);
4074 : }
4075 : return res;
4076 : } else {
4077 : return SWIG_ERROR;
4078 : }
4079 : } else {
4080 : return traits_asptr<Type>::asptr(obj, (Type **)(0));
4081 : }
4082 : }
4083 : };
4084 :
4085 : template <class Type> struct traits_asval<Type*> {
4086 : static int asval(PyObject *obj, Type **val) {
4087 : if (val) {
4088 : typedef typename noconst_traits<Type>::noconst_type noconst_type;
4089 : noconst_type *p = 0;
4090 : int res = traits_asptr<noconst_type>::asptr(obj, &p);
4091 : if (SWIG_IsOK(res)) {
4092 : *(const_cast<noconst_type**>(val)) = p;
4093 : }
4094 : return res;
4095 : } else {
4096 : return traits_asptr<Type>::asptr(obj, (Type **)(0));
4097 : }
4098 : }
4099 : };
4100 :
4101 : template <class Type>
4102 : inline int asval(PyObject *obj, Type *val) {
4103 : return traits_asval<Type>::asval(obj, val);
4104 : }
4105 :
4106 : template <class Type>
4107 : struct traits_as<Type, value_category> {
4108 : static Type as(PyObject *obj, bool throw_error) {
4109 : Type v;
4110 : int res = asval(obj, &v);
4111 : if (!obj || !SWIG_IsOK(res)) {
4112 : if (!PyErr_Occurred()) {
4113 : ::SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
4114 : }
4115 : if (throw_error) throw std::invalid_argument("bad type");
4116 : }
4117 : return v;
4118 : }
4119 : };
4120 :
4121 : template <class Type>
4122 : struct traits_as<Type, pointer_category> {
4123 : static Type as(PyObject *obj, bool throw_error) {
4124 : Type *v = 0;
4125 : int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
4126 : if (SWIG_IsOK(res) && v) {
4127 : if (SWIG_IsNewObj(res)) {
4128 : Type r(*v);
4129 : delete v;
4130 : return r;
4131 : } else {
4132 : return *v;
4133 : }
4134 : } else {
4135 : // Uninitialized return value, no Type() constructor required.
4136 : static Type *v_def = (Type*) malloc(sizeof(Type));
4137 : if (!PyErr_Occurred()) {
4138 : SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
4139 : }
4140 : if (throw_error) throw std::invalid_argument("bad type");
4141 : memset(v_def,0,sizeof(Type));
4142 : return *v_def;
4143 : }
4144 : }
4145 : };
4146 :
4147 : template <class Type>
4148 : struct traits_as<Type*, pointer_category> {
4149 : static Type* as(PyObject *obj, bool throw_error) {
4150 : Type *v = 0;
4151 : int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
4152 : if (SWIG_IsOK(res)) {
4153 : return v;
4154 : } else {
4155 : if (!PyErr_Occurred()) {
4156 : SWIG_Error(SWIG_TypeError, swig::type_name<Type>());
4157 : }
4158 : if (throw_error) throw std::invalid_argument("bad type");
4159 : return 0;
4160 : }
4161 : }
4162 : };
4163 :
4164 : template <class Type>
4165 : inline Type as(PyObject *obj, bool te = false) {
4166 : return traits_as<Type, typename traits<Type>::category>::as(obj, te);
4167 : }
4168 :
4169 : template <class Type>
4170 : struct traits_check<Type, value_category> {
4171 : static bool check(PyObject *obj) {
4172 : int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
4173 : return SWIG_IsOK(res) ? true : false;
4174 : }
4175 : };
4176 :
4177 : template <class Type>
4178 : struct traits_check<Type, pointer_category> {
4179 : static bool check(PyObject *obj) {
4180 : int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
4181 : return SWIG_IsOK(res) ? true : false;
4182 : }
4183 : };
4184 :
4185 : template <class Type>
4186 : inline bool check(PyObject *obj) {
4187 : return traits_check<Type, typename traits<Type>::category>::check(obj);
4188 : }
4189 : }
4190 :
4191 :
4192 : #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
4193 : # if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
4194 : # define SWIG_STD_NOITERATOR_TRAITS_STL
4195 : # endif
4196 : #endif
4197 :
4198 : #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
4199 : #include <iterator>
4200 : #else
4201 : namespace std {
4202 : template <class Iterator>
4203 : struct iterator_traits {
4204 : typedef ptrdiff_t difference_type;
4205 : typedef typename Iterator::value_type value_type;
4206 : };
4207 :
4208 : template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
4209 : struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
4210 : typedef Distance difference_type;
4211 : typedef T value_type;
4212 : };
4213 :
4214 : template <class T>
4215 : struct iterator_traits<T*> {
4216 : typedef T value_type;
4217 : typedef ptrdiff_t difference_type;
4218 : };
4219 :
4220 : template<typename _InputIterator>
4221 : inline typename iterator_traits<_InputIterator>::difference_type
4222 : distance(_InputIterator __first, _InputIterator __last)
4223 : {
4224 : typename iterator_traits<_InputIterator>::difference_type __n = 0;
4225 : while (__first != __last) {
4226 : ++__first; ++__n;
4227 : }
4228 : return __n;
4229 : }
4230 : }
4231 : #endif
4232 :
4233 :
4234 : namespace swig {
4235 : template<typename OutIterator>
4236 0 : class SwigPyIterator_T : public SwigPyIterator
4237 : {
4238 : public:
4239 : typedef OutIterator out_iterator;
4240 : typedef typename std::iterator_traits<out_iterator>::value_type value_type;
4241 : typedef SwigPyIterator_T<out_iterator> self_type;
4242 :
4243 7 : SwigPyIterator_T(out_iterator curr, PyObject *seq)
4244 14 : : SwigPyIterator(seq), current(curr)
4245 : {
4246 : }
4247 :
4248 : const out_iterator& get_current() const
4249 : {
4250 : return current;
4251 : }
4252 :
4253 :
4254 0 : bool equal (const SwigPyIterator &iter) const
4255 : {
4256 0 : const self_type *iters = dynamic_cast<const self_type *>(&iter);
4257 0 : if (iters) {
4258 0 : return (current == iters->get_current());
4259 : } else {
4260 0 : throw std::invalid_argument("bad iterator type");
4261 : }
4262 : }
4263 :
4264 0 : ptrdiff_t distance(const SwigPyIterator &iter) const
4265 : {
4266 0 : const self_type *iters = dynamic_cast<const self_type *>(&iter);
4267 0 : if (iters) {
4268 0 : return std::distance(current, iters->get_current());
4269 : } else {
4270 0 : throw std::invalid_argument("bad iterator type");
4271 : }
4272 : }
4273 :
4274 : protected:
4275 : out_iterator current;
4276 : };
4277 :
4278 : template <class ValueType>
4279 : struct from_oper
4280 : {
4281 : typedef const ValueType& argument_type;
4282 : typedef PyObject *result_type;
4283 : result_type operator()(argument_type v) const
4284 : {
4285 16 : return swig::from(v);
4286 : }
4287 : };
4288 :
4289 : template<typename OutIterator,
4290 : typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4291 : typename FromOper = from_oper<ValueType> >
4292 : class SwigPyIteratorOpen_T : public SwigPyIterator_T<OutIterator>
4293 : {
4294 : public:
4295 : FromOper from;
4296 : typedef OutIterator out_iterator;
4297 : typedef ValueType value_type;
4298 : typedef SwigPyIterator_T<out_iterator> base;
4299 : typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
4300 :
4301 : SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
4302 : : SwigPyIterator_T<OutIterator>(curr, seq)
4303 : {
4304 : }
4305 :
4306 : PyObject *value() const {
4307 : return from(static_cast<const value_type&>(*(base::current)));
4308 : }
4309 :
4310 : SwigPyIterator *copy() const
4311 : {
4312 : return new self_type(*this);
4313 : }
4314 :
4315 : SwigPyIterator *incr(size_t n = 1)
4316 : {
4317 : while (n--) {
4318 : ++base::current;
4319 : }
4320 : return this;
4321 : }
4322 :
4323 : SwigPyIterator *decr(size_t n = 1)
4324 : {
4325 : while (n--) {
4326 : --base::current;
4327 : }
4328 : return this;
4329 : }
4330 : };
4331 :
4332 : template<typename OutIterator,
4333 : typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
4334 : typename FromOper = from_oper<ValueType> >
4335 0 : class SwigPyIteratorClosed_T : public SwigPyIterator_T<OutIterator>
4336 : {
4337 : public:
4338 : FromOper from;
4339 : typedef OutIterator out_iterator;
4340 : typedef ValueType value_type;
4341 : typedef SwigPyIterator_T<out_iterator> base;
4342 : typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
4343 :
4344 7 : SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
4345 14 : : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
4346 : {
4347 : }
4348 :
4349 21 : PyObject *value() const {
4350 42 : if (base::current == end) {
4351 5 : throw stop_iteration();
4352 : } else {
4353 64 : return from(static_cast<const value_type&>(*(base::current)));
4354 : }
4355 : }
4356 :
4357 0 : SwigPyIterator *copy() const
4358 : {
4359 0 : return new self_type(*this);
4360 : }
4361 :
4362 14 : SwigPyIterator *incr(size_t n = 1)
4363 : {
4364 28 : while (n--) {
4365 28 : if (base::current == end) {
4366 0 : throw stop_iteration();
4367 : } else {
4368 14 : ++base::current;
4369 : }
4370 : }
4371 14 : return this;
4372 : }
4373 :
4374 0 : SwigPyIterator *decr(size_t n = 1)
4375 : {
4376 0 : while (n--) {
4377 0 : if (base::current == begin) {
4378 0 : throw stop_iteration();
4379 : } else {
4380 0 : --base::current;
4381 : }
4382 : }
4383 0 : return this;
4384 : }
4385 :
4386 : private:
4387 : out_iterator begin;
4388 : out_iterator end;
4389 : };
4390 :
4391 : template<typename OutIter>
4392 : inline SwigPyIterator*
4393 7 : make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
4394 : {
4395 14 : return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
4396 : }
4397 :
4398 : template<typename OutIter>
4399 : inline SwigPyIterator*
4400 : make_output_iterator(const OutIter& current, PyObject *seq = 0)
4401 : {
4402 : return new SwigPyIteratorOpen_T<OutIter>(current, seq);
4403 : }
4404 :
4405 : }
4406 :
4407 :
4408 : SWIGINTERN int
4409 : SWIG_AsVal_std_string (PyObject * obj, std::string *val)
4410 : {
4411 : std::string* v = (std::string *) 0;
4412 : int res = SWIG_AsPtr_std_string (obj, &v);
4413 : if (!SWIG_IsOK(res)) return res;
4414 : if (v) {
4415 : if (val) *val = *v;
4416 : if (SWIG_IsNewObj(res)) {
4417 : delete v;
4418 : res = SWIG_DelNewMask(res);
4419 : }
4420 : return res;
4421 : }
4422 : return SWIG_ERROR;
4423 : }
4424 :
4425 :
4426 : SWIGINTERNINLINE PyObject *
4427 : SWIG_From_std_string (const std::string& s)
4428 : {
4429 52 : return SWIG_FromCharPtrAndSize(s.data(), s.size());
4430 : }
4431 :
4432 :
4433 : namespace swig {
4434 : template <> struct traits< std::string > {
4435 : typedef value_category category;
4436 : static const char* type_name() { return"std::string"; }
4437 : };
4438 : template <> struct traits_asval< std::string > {
4439 : typedef std::string value_type;
4440 : static int asval(PyObject *obj, value_type *val) {
4441 : return SWIG_AsVal_std_string (obj, val);
4442 : }
4443 : };
4444 : template <> struct traits_from< std::string > {
4445 : typedef std::string value_type;
4446 : static PyObject *from(const value_type& val) {
4447 8 : return SWIG_From_std_string (val);
4448 : }
4449 : };
4450 : }
4451 :
4452 :
4453 :
4454 :
4455 :
4456 : SWIGINTERN int
4457 : SWIG_AsVal_int (PyObject * obj, int *val)
4458 : {
4459 : long v;
4460 106 : int res = SWIG_AsVal_long (obj, &v);
4461 106 : if (SWIG_IsOK(res)) {
4462 106 : if ((v < INT_MIN || v > INT_MAX)) {
4463 : return SWIG_OverflowError;
4464 : } else {
4465 106 : if (val) *val = static_cast< int >(v);
4466 : }
4467 : }
4468 : return res;
4469 : }
4470 :
4471 106 : SWIGINTERN kdb::Key *new_kdb_Key__SWIG_3(char const *name,int flags=0){
4472 : return new kdb::Key(name,
4473 : KEY_FLAGS, flags,
4474 106 : KEY_END);
4475 : }
4476 : SWIGINTERN int kdb_Key___cmp__(kdb::Key *self,kdb::Key const *o){
4477 0 : return ckdb::keyCmp(self->getKey(), o->getKey());
4478 : }
4479 1 : SWIGINTERN kdb::Key *kdb_Key___copy__(kdb::Key *self){
4480 2 : return new kdb::Key(self->dup());
4481 : }
4482 2 : SWIGINTERN swig::SwigPyIterator *kdb_Key___iter__(kdb::Key *self,PyObject **PYTHON_SELF){
4483 8 : return swig::make_output_iterator(self->begin(), self->begin(),
4484 6 : self->end(), *PYTHON_SELF);
4485 : }
4486 2 : SWIGINTERN swig::SwigPyIterator *kdb_Key___reversed__(kdb::Key *self,PyObject **PYTHON_SELF){
4487 8 : return swig::make_output_iterator(self->rbegin(), self->rbegin(),
4488 6 : self->rend(), *PYTHON_SELF);
4489 : }
4490 :
4491 : namespace swig {
4492 : template <> struct traits< kdb::Key > {
4493 : typedef pointer_category category;
4494 : static const char* type_name() { return"kdb::Key"; }
4495 : };
4496 : }
4497 :
4498 15 : SWIGINTERN kdb::KeySet *new_kdb_KeySet__SWIG_3(size_t alloc){
4499 15 : return new kdb::KeySet(alloc, KS_END);
4500 : }
4501 1 : SWIGINTERN kdb::KeySet *kdb_KeySet___copy__(kdb::KeySet *self){
4502 2 : return new kdb::KeySet(*self);
4503 : }
4504 1 : SWIGINTERN kdb::KeySet *kdb_KeySet___deepcopy__(kdb::KeySet *self,PyObject *memo){
4505 : (void) PyDict_Check(memo);
4506 1 : ssize_t size = self->size();
4507 1 : kdb::KeySet *ks = new kdb::KeySet(size, KS_END);
4508 9 : for (cursor_t cursor = 0; cursor < size; ++cursor)
4509 24 : ks->append(self->at(cursor)->dup());
4510 1 : return ks;
4511 : }
4512 2 : SWIGINTERN swig::SwigPyIterator *kdb_KeySet___iter__(kdb::KeySet *self,PyObject **PYTHON_SELF){
4513 8 : return swig::make_output_iterator(self->begin(), self->begin(),
4514 6 : self->end(), *PYTHON_SELF);
4515 : }
4516 1 : SWIGINTERN swig::SwigPyIterator *kdb_KeySet___reversed__(kdb::KeySet *self,PyObject **PYTHON_SELF){
4517 4 : return swig::make_output_iterator(self->rbegin(), self->rbegin(),
4518 3 : self->rend(), *PYTHON_SELF);
4519 : }
4520 : #ifdef __cplusplus
4521 : extern "C" {
4522 : #endif
4523 0 : SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4524 0 : PyObject *resultobj = 0;
4525 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4526 0 : void *argp1 = 0 ;
4527 0 : int res1 = 0 ;
4528 : PyObject *swig_obj[1] ;
4529 :
4530 0 : if (!args) SWIG_fail;
4531 0 : swig_obj[0] = args;
4532 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
4533 0 : if (!SWIG_IsOK(res1)) {
4534 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
4535 : }
4536 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4537 0 : delete arg1;
4538 0 : resultobj = SWIG_Py_Void();
4539 0 : return resultobj;
4540 : fail:
4541 : return NULL;
4542 : }
4543 :
4544 :
4545 2 : SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4546 2 : PyObject *resultobj = 0;
4547 2 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4548 2 : void *argp1 = 0 ;
4549 2 : int res1 = 0 ;
4550 : PyObject *swig_obj[1] ;
4551 2 : PyObject *result = 0 ;
4552 :
4553 2 : if (!args) SWIG_fail;
4554 2 : swig_obj[0] = args;
4555 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4556 2 : if (!SWIG_IsOK(res1)) {
4557 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
4558 : }
4559 2 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4560 : try {
4561 2 : result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
4562 : }
4563 0 : catch(swig::stop_iteration &_e) {
4564 : {
4565 : (void)_e;
4566 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4567 : SWIG_fail;
4568 : }
4569 : }
4570 :
4571 : resultobj = result;
4572 : return resultobj;
4573 : fail:
4574 : return NULL;
4575 : }
4576 :
4577 :
4578 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4579 0 : PyObject *resultobj = 0;
4580 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4581 : size_t arg2 ;
4582 0 : void *argp1 = 0 ;
4583 0 : int res1 = 0 ;
4584 : size_t val2 ;
4585 0 : int ecode2 = 0 ;
4586 0 : swig::SwigPyIterator *result = 0 ;
4587 :
4588 0 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
4589 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4590 0 : if (!SWIG_IsOK(res1)) {
4591 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
4592 : }
4593 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4594 0 : ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
4595 0 : if (!SWIG_IsOK(ecode2)) {
4596 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
4597 : }
4598 0 : arg2 = static_cast< size_t >(val2);
4599 : try {
4600 0 : result = (swig::SwigPyIterator *)(arg1)->incr(arg2);
4601 : }
4602 0 : catch(swig::stop_iteration &_e) {
4603 : {
4604 : (void)_e;
4605 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4606 : SWIG_fail;
4607 : }
4608 : }
4609 :
4610 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4611 : return resultobj;
4612 : fail:
4613 : return NULL;
4614 : }
4615 :
4616 :
4617 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4618 0 : PyObject *resultobj = 0;
4619 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4620 0 : void *argp1 = 0 ;
4621 0 : int res1 = 0 ;
4622 0 : swig::SwigPyIterator *result = 0 ;
4623 :
4624 0 : if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
4625 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4626 0 : if (!SWIG_IsOK(res1)) {
4627 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
4628 : }
4629 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4630 : try {
4631 0 : result = (swig::SwigPyIterator *)(arg1)->incr();
4632 : }
4633 0 : catch(swig::stop_iteration &_e) {
4634 : {
4635 : (void)_e;
4636 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4637 : SWIG_fail;
4638 : }
4639 : }
4640 :
4641 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4642 : return resultobj;
4643 : fail:
4644 : return NULL;
4645 : }
4646 :
4647 :
4648 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
4649 : Py_ssize_t argc;
4650 : PyObject *argv[3] = {
4651 : 0
4652 0 : };
4653 :
4654 0 : if (!(argc = SWIG_Python_UnpackTuple(args,"SwigPyIterator_incr",0,2,argv))) SWIG_fail;
4655 0 : --argc;
4656 0 : if (argc == 1) {
4657 0 : return _wrap_SwigPyIterator_incr__SWIG_1(self, argc, argv);
4658 : }
4659 0 : if (argc == 2) {
4660 0 : return _wrap_SwigPyIterator_incr__SWIG_0(self, argc, argv);
4661 : }
4662 :
4663 : fail:
4664 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
4665 : " Possible C/C++ prototypes are:\n"
4666 : " swig::SwigPyIterator::incr(size_t)\n"
4667 0 : " swig::SwigPyIterator::incr()\n");
4668 : return 0;
4669 : }
4670 :
4671 :
4672 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4673 0 : PyObject *resultobj = 0;
4674 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4675 : size_t arg2 ;
4676 0 : void *argp1 = 0 ;
4677 0 : int res1 = 0 ;
4678 : size_t val2 ;
4679 0 : int ecode2 = 0 ;
4680 0 : swig::SwigPyIterator *result = 0 ;
4681 :
4682 0 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
4683 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4684 0 : if (!SWIG_IsOK(res1)) {
4685 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
4686 : }
4687 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4688 0 : ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
4689 0 : if (!SWIG_IsOK(ecode2)) {
4690 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
4691 : }
4692 0 : arg2 = static_cast< size_t >(val2);
4693 : try {
4694 0 : result = (swig::SwigPyIterator *)(arg1)->decr(arg2);
4695 : }
4696 0 : catch(swig::stop_iteration &_e) {
4697 : {
4698 : (void)_e;
4699 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4700 : SWIG_fail;
4701 : }
4702 : }
4703 :
4704 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4705 : return resultobj;
4706 : fail:
4707 : return NULL;
4708 : }
4709 :
4710 :
4711 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4712 0 : PyObject *resultobj = 0;
4713 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4714 0 : void *argp1 = 0 ;
4715 0 : int res1 = 0 ;
4716 0 : swig::SwigPyIterator *result = 0 ;
4717 :
4718 0 : if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
4719 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4720 0 : if (!SWIG_IsOK(res1)) {
4721 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
4722 : }
4723 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4724 : try {
4725 0 : result = (swig::SwigPyIterator *)(arg1)->decr();
4726 : }
4727 0 : catch(swig::stop_iteration &_e) {
4728 : {
4729 : (void)_e;
4730 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4731 : SWIG_fail;
4732 : }
4733 : }
4734 :
4735 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4736 : return resultobj;
4737 : fail:
4738 : return NULL;
4739 : }
4740 :
4741 :
4742 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
4743 : Py_ssize_t argc;
4744 : PyObject *argv[3] = {
4745 : 0
4746 0 : };
4747 :
4748 0 : if (!(argc = SWIG_Python_UnpackTuple(args,"SwigPyIterator_decr",0,2,argv))) SWIG_fail;
4749 0 : --argc;
4750 0 : if (argc == 1) {
4751 0 : return _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
4752 : }
4753 0 : if (argc == 2) {
4754 0 : return _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
4755 : }
4756 :
4757 : fail:
4758 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
4759 : " Possible C/C++ prototypes are:\n"
4760 : " swig::SwigPyIterator::decr(size_t)\n"
4761 0 : " swig::SwigPyIterator::decr()\n");
4762 : return 0;
4763 : }
4764 :
4765 :
4766 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4767 0 : PyObject *resultobj = 0;
4768 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4769 0 : swig::SwigPyIterator *arg2 = 0 ;
4770 0 : void *argp1 = 0 ;
4771 0 : int res1 = 0 ;
4772 0 : void *argp2 = 0 ;
4773 0 : int res2 = 0 ;
4774 : PyObject *swig_obj[2] ;
4775 : ptrdiff_t result;
4776 :
4777 0 : if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator_distance",2,2,swig_obj)) SWIG_fail;
4778 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4779 0 : if (!SWIG_IsOK(res1)) {
4780 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
4781 : }
4782 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4783 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
4784 0 : if (!SWIG_IsOK(res2)) {
4785 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
4786 : }
4787 0 : if (!argp2) {
4788 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
4789 : }
4790 0 : arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
4791 : try {
4792 0 : result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
4793 : }
4794 0 : catch(std::invalid_argument &_e) {
4795 0 : SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
4796 : }
4797 :
4798 : resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
4799 : return resultobj;
4800 : fail:
4801 : return NULL;
4802 : }
4803 :
4804 :
4805 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4806 0 : PyObject *resultobj = 0;
4807 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4808 0 : swig::SwigPyIterator *arg2 = 0 ;
4809 0 : void *argp1 = 0 ;
4810 0 : int res1 = 0 ;
4811 0 : void *argp2 = 0 ;
4812 0 : int res2 = 0 ;
4813 : PyObject *swig_obj[2] ;
4814 : bool result;
4815 :
4816 0 : if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator_equal",2,2,swig_obj)) SWIG_fail;
4817 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4818 0 : if (!SWIG_IsOK(res1)) {
4819 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
4820 : }
4821 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4822 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
4823 0 : if (!SWIG_IsOK(res2)) {
4824 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
4825 : }
4826 0 : if (!argp2) {
4827 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
4828 : }
4829 0 : arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
4830 : try {
4831 0 : result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
4832 : }
4833 0 : catch(std::invalid_argument &_e) {
4834 0 : SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
4835 : }
4836 :
4837 : resultobj = SWIG_From_bool(static_cast< bool >(result));
4838 : return resultobj;
4839 : fail:
4840 : return NULL;
4841 : }
4842 :
4843 :
4844 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4845 0 : PyObject *resultobj = 0;
4846 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4847 0 : void *argp1 = 0 ;
4848 0 : int res1 = 0 ;
4849 : PyObject *swig_obj[1] ;
4850 0 : swig::SwigPyIterator *result = 0 ;
4851 :
4852 0 : if (!args) SWIG_fail;
4853 0 : swig_obj[0] = args;
4854 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4855 0 : if (!SWIG_IsOK(res1)) {
4856 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
4857 : }
4858 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4859 0 : result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
4860 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
4861 : return resultobj;
4862 : fail:
4863 : return NULL;
4864 : }
4865 :
4866 :
4867 19 : SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4868 19 : PyObject *resultobj = 0;
4869 19 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4870 19 : void *argp1 = 0 ;
4871 19 : int res1 = 0 ;
4872 : PyObject *swig_obj[1] ;
4873 19 : PyObject *result = 0 ;
4874 :
4875 19 : if (!args) SWIG_fail;
4876 19 : swig_obj[0] = args;
4877 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4878 19 : if (!SWIG_IsOK(res1)) {
4879 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
4880 : }
4881 19 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4882 : try {
4883 : result = (PyObject *)(arg1)->next();
4884 : }
4885 10 : catch(swig::stop_iteration &_e) {
4886 : {
4887 : (void)_e;
4888 5 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4889 : SWIG_fail;
4890 : }
4891 : }
4892 :
4893 : resultobj = result;
4894 : return resultobj;
4895 : fail:
4896 : return NULL;
4897 : }
4898 :
4899 :
4900 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4901 0 : PyObject *resultobj = 0;
4902 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4903 0 : void *argp1 = 0 ;
4904 0 : int res1 = 0 ;
4905 : PyObject *swig_obj[1] ;
4906 0 : PyObject *result = 0 ;
4907 :
4908 0 : if (!args) SWIG_fail;
4909 0 : swig_obj[0] = args;
4910 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4911 0 : if (!SWIG_IsOK(res1)) {
4912 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
4913 : }
4914 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4915 : try {
4916 : result = (PyObject *)(arg1)->__next__();
4917 : }
4918 0 : catch(swig::stop_iteration &_e) {
4919 : {
4920 : (void)_e;
4921 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4922 : SWIG_fail;
4923 : }
4924 : }
4925 :
4926 : resultobj = result;
4927 : return resultobj;
4928 : fail:
4929 : return NULL;
4930 : }
4931 :
4932 :
4933 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4934 0 : PyObject *resultobj = 0;
4935 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4936 0 : void *argp1 = 0 ;
4937 0 : int res1 = 0 ;
4938 : PyObject *swig_obj[1] ;
4939 0 : PyObject *result = 0 ;
4940 :
4941 0 : if (!args) SWIG_fail;
4942 0 : swig_obj[0] = args;
4943 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4944 0 : if (!SWIG_IsOK(res1)) {
4945 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
4946 : }
4947 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4948 : try {
4949 : result = (PyObject *)(arg1)->previous();
4950 : }
4951 0 : catch(swig::stop_iteration &_e) {
4952 : {
4953 : (void)_e;
4954 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4955 : SWIG_fail;
4956 : }
4957 : }
4958 :
4959 : resultobj = result;
4960 : return resultobj;
4961 : fail:
4962 : return NULL;
4963 : }
4964 :
4965 :
4966 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4967 0 : PyObject *resultobj = 0;
4968 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
4969 : ptrdiff_t arg2 ;
4970 0 : void *argp1 = 0 ;
4971 0 : int res1 = 0 ;
4972 : ptrdiff_t val2 ;
4973 0 : int ecode2 = 0 ;
4974 : PyObject *swig_obj[2] ;
4975 0 : swig::SwigPyIterator *result = 0 ;
4976 :
4977 0 : if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator_advance",2,2,swig_obj)) SWIG_fail;
4978 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
4979 0 : if (!SWIG_IsOK(res1)) {
4980 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
4981 : }
4982 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
4983 0 : ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
4984 0 : if (!SWIG_IsOK(ecode2)) {
4985 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
4986 : }
4987 0 : arg2 = static_cast< ptrdiff_t >(val2);
4988 : try {
4989 0 : result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
4990 : }
4991 0 : catch(swig::stop_iteration &_e) {
4992 : {
4993 : (void)_e;
4994 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4995 : SWIG_fail;
4996 : }
4997 : }
4998 :
4999 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5000 : return resultobj;
5001 : fail:
5002 : return NULL;
5003 : }
5004 :
5005 :
5006 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5007 0 : PyObject *resultobj = 0;
5008 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5009 0 : swig::SwigPyIterator *arg2 = 0 ;
5010 0 : void *argp1 = 0 ;
5011 0 : int res1 = 0 ;
5012 0 : void *argp2 = 0 ;
5013 0 : int res2 = 0 ;
5014 : PyObject *swig_obj[2] ;
5015 : bool result;
5016 :
5017 0 : if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator___eq__",2,2,swig_obj)) SWIG_fail;
5018 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5019 0 : if (!SWIG_IsOK(res1)) {
5020 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5021 : }
5022 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5023 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
5024 0 : if (!SWIG_IsOK(res2)) {
5025 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5026 : }
5027 0 : if (!argp2) {
5028 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5029 : }
5030 0 : arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5031 0 : result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
5032 : resultobj = SWIG_From_bool(static_cast< bool >(result));
5033 : return resultobj;
5034 : fail:
5035 : return NULL;
5036 : }
5037 :
5038 :
5039 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5040 0 : PyObject *resultobj = 0;
5041 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5042 0 : swig::SwigPyIterator *arg2 = 0 ;
5043 0 : void *argp1 = 0 ;
5044 0 : int res1 = 0 ;
5045 0 : void *argp2 = 0 ;
5046 0 : int res2 = 0 ;
5047 : PyObject *swig_obj[2] ;
5048 : bool result;
5049 :
5050 0 : if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator___ne__",2,2,swig_obj)) SWIG_fail;
5051 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5052 0 : if (!SWIG_IsOK(res1)) {
5053 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5054 : }
5055 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5056 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
5057 0 : if (!SWIG_IsOK(res2)) {
5058 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5059 : }
5060 0 : if (!argp2) {
5061 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5062 : }
5063 0 : arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5064 0 : result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
5065 : resultobj = SWIG_From_bool(static_cast< bool >(result));
5066 : return resultobj;
5067 : fail:
5068 : return NULL;
5069 : }
5070 :
5071 :
5072 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5073 0 : PyObject *resultobj = 0;
5074 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5075 : ptrdiff_t arg2 ;
5076 0 : void *argp1 = 0 ;
5077 0 : int res1 = 0 ;
5078 : ptrdiff_t val2 ;
5079 0 : int ecode2 = 0 ;
5080 : PyObject *swig_obj[2] ;
5081 0 : swig::SwigPyIterator *result = 0 ;
5082 :
5083 0 : if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator___iadd__",2,2,swig_obj)) SWIG_fail;
5084 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
5085 0 : if (!SWIG_IsOK(res1)) {
5086 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5087 : }
5088 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5089 0 : ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
5090 0 : if (!SWIG_IsOK(ecode2)) {
5091 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
5092 : }
5093 0 : arg2 = static_cast< ptrdiff_t >(val2);
5094 : try {
5095 0 : result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
5096 : }
5097 0 : catch(swig::stop_iteration &_e) {
5098 : {
5099 : (void)_e;
5100 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5101 : SWIG_fail;
5102 : }
5103 : }
5104 :
5105 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
5106 : return resultobj;
5107 : fail:
5108 : return NULL;
5109 : }
5110 :
5111 :
5112 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5113 0 : PyObject *resultobj = 0;
5114 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5115 : ptrdiff_t arg2 ;
5116 0 : void *argp1 = 0 ;
5117 0 : int res1 = 0 ;
5118 : ptrdiff_t val2 ;
5119 0 : int ecode2 = 0 ;
5120 : PyObject *swig_obj[2] ;
5121 0 : swig::SwigPyIterator *result = 0 ;
5122 :
5123 0 : if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator___isub__",2,2,swig_obj)) SWIG_fail;
5124 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN | 0 );
5125 0 : if (!SWIG_IsOK(res1)) {
5126 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'");
5127 : }
5128 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5129 0 : ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
5130 0 : if (!SWIG_IsOK(ecode2)) {
5131 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5132 : }
5133 0 : arg2 = static_cast< ptrdiff_t >(val2);
5134 : try {
5135 0 : result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
5136 : }
5137 0 : catch(swig::stop_iteration &_e) {
5138 : {
5139 : (void)_e;
5140 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5141 : SWIG_fail;
5142 : }
5143 : }
5144 :
5145 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
5146 : return resultobj;
5147 : fail:
5148 : return NULL;
5149 : }
5150 :
5151 :
5152 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5153 0 : PyObject *resultobj = 0;
5154 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5155 : ptrdiff_t arg2 ;
5156 0 : void *argp1 = 0 ;
5157 0 : int res1 = 0 ;
5158 : ptrdiff_t val2 ;
5159 0 : int ecode2 = 0 ;
5160 : PyObject *swig_obj[2] ;
5161 0 : swig::SwigPyIterator *result = 0 ;
5162 :
5163 0 : if (!SWIG_Python_UnpackTuple(args,"SwigPyIterator___add__",2,2,swig_obj)) SWIG_fail;
5164 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5165 0 : if (!SWIG_IsOK(res1)) {
5166 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5167 : }
5168 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5169 0 : ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
5170 0 : if (!SWIG_IsOK(ecode2)) {
5171 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
5172 : }
5173 0 : arg2 = static_cast< ptrdiff_t >(val2);
5174 : try {
5175 0 : result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
5176 : }
5177 0 : catch(swig::stop_iteration &_e) {
5178 : {
5179 : (void)_e;
5180 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5181 : SWIG_fail;
5182 : }
5183 : }
5184 :
5185 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
5186 : return resultobj;
5187 : fail:
5188 : return NULL;
5189 : }
5190 :
5191 :
5192 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
5193 0 : PyObject *resultobj = 0;
5194 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5195 : ptrdiff_t arg2 ;
5196 0 : void *argp1 = 0 ;
5197 0 : int res1 = 0 ;
5198 : ptrdiff_t val2 ;
5199 0 : int ecode2 = 0 ;
5200 0 : swig::SwigPyIterator *result = 0 ;
5201 :
5202 0 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
5203 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5204 0 : if (!SWIG_IsOK(res1)) {
5205 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5206 : }
5207 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5208 0 : ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
5209 0 : if (!SWIG_IsOK(ecode2)) {
5210 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
5211 : }
5212 0 : arg2 = static_cast< ptrdiff_t >(val2);
5213 : try {
5214 0 : result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(arg2);
5215 : }
5216 0 : catch(swig::stop_iteration &_e) {
5217 : {
5218 : (void)_e;
5219 0 : SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
5220 : SWIG_fail;
5221 : }
5222 : }
5223 :
5224 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN | 0 );
5225 : return resultobj;
5226 : fail:
5227 : return NULL;
5228 : }
5229 :
5230 :
5231 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
5232 0 : PyObject *resultobj = 0;
5233 0 : swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
5234 0 : swig::SwigPyIterator *arg2 = 0 ;
5235 0 : void *argp1 = 0 ;
5236 0 : int res1 = 0 ;
5237 0 : void *argp2 = 0 ;
5238 0 : int res2 = 0 ;
5239 : ptrdiff_t result;
5240 :
5241 0 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
5242 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
5243 0 : if (!SWIG_IsOK(res1)) {
5244 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'");
5245 : }
5246 0 : arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
5247 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator, 0 | 0);
5248 0 : if (!SWIG_IsOK(res2)) {
5249 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5250 : }
5251 0 : if (!argp2) {
5252 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'");
5253 : }
5254 0 : arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
5255 0 : result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
5256 : resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
5257 : return resultobj;
5258 : fail:
5259 : return NULL;
5260 : }
5261 :
5262 :
5263 0 : SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
5264 : Py_ssize_t argc;
5265 : PyObject *argv[3] = {
5266 : 0
5267 0 : };
5268 :
5269 0 : if (!(argc = SWIG_Python_UnpackTuple(args,"SwigPyIterator___sub__",0,2,argv))) SWIG_fail;
5270 0 : --argc;
5271 0 : if (argc == 2) {
5272 0 : int _v = 0;
5273 : {
5274 0 : int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, 0);
5275 0 : _v = SWIG_CheckState(res);
5276 : }
5277 0 : if (!_v) goto check_1;
5278 0 : return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
5279 : }
5280 : check_1:
5281 :
5282 0 : if (argc == 2) {
5283 0 : return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
5284 : }
5285 :
5286 : fail:
5287 0 : Py_INCREF(Py_NotImplemented);
5288 0 : return Py_NotImplemented;
5289 : }
5290 :
5291 :
5292 3 : SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5293 : PyObject *obj;
5294 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5295 6 : SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
5296 3 : return SWIG_Py_Void();
5297 : }
5298 :
5299 0 : SWIGINTERN PyObject *_wrap_Exception_what(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5300 0 : PyObject *resultobj = 0;
5301 0 : kdb::Exception *arg1 = (kdb::Exception *) 0 ;
5302 0 : void *argp1 = 0 ;
5303 0 : int res1 = 0 ;
5304 : PyObject *swig_obj[1] ;
5305 0 : char *result = 0 ;
5306 :
5307 0 : if (!args) SWIG_fail;
5308 0 : swig_obj[0] = args;
5309 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Exception, 0 | 0 );
5310 0 : if (!SWIG_IsOK(res1)) {
5311 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exception_what" "', argument " "1"" of type '" "kdb::Exception const *""'");
5312 : }
5313 0 : arg1 = reinterpret_cast< kdb::Exception * >(argp1);
5314 0 : result = (char *)((kdb::Exception const *)arg1)->what();
5315 0 : resultobj = SWIG_FromCharPtr((const char *)result);
5316 : return resultobj;
5317 : fail:
5318 : return NULL;
5319 : }
5320 :
5321 :
5322 0 : SWIGINTERN PyObject *_wrap_new_Exception(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5323 0 : PyObject *resultobj = 0;
5324 0 : kdb::Exception *result = 0 ;
5325 :
5326 0 : if (!SWIG_Python_UnpackTuple(args,"new_Exception",0,0,0)) SWIG_fail;
5327 0 : result = (kdb::Exception *)new kdb::Exception();
5328 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Exception, SWIG_POINTER_NEW | 0 );
5329 0 : return resultobj;
5330 : fail:
5331 : return NULL;
5332 : }
5333 :
5334 :
5335 0 : SWIGINTERN PyObject *_wrap_delete_Exception(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5336 0 : PyObject *resultobj = 0;
5337 0 : kdb::Exception *arg1 = (kdb::Exception *) 0 ;
5338 0 : void *argp1 = 0 ;
5339 0 : int res1 = 0 ;
5340 : PyObject *swig_obj[1] ;
5341 :
5342 0 : if (!args) SWIG_fail;
5343 0 : swig_obj[0] = args;
5344 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Exception, SWIG_POINTER_DISOWN | 0 );
5345 0 : if (!SWIG_IsOK(res1)) {
5346 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Exception" "', argument " "1"" of type '" "kdb::Exception *""'");
5347 : }
5348 0 : arg1 = reinterpret_cast< kdb::Exception * >(argp1);
5349 0 : delete arg1;
5350 0 : resultobj = SWIG_Py_Void();
5351 0 : return resultobj;
5352 : fail:
5353 : return NULL;
5354 : }
5355 :
5356 :
5357 3 : SWIGINTERN PyObject *Exception_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5358 : PyObject *obj;
5359 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5360 6 : SWIG_TypeNewClientData(SWIGTYPE_p_kdb__Exception, SWIG_NewClientData(obj));
5361 3 : return SWIG_Py_Void();
5362 : }
5363 :
5364 0 : SWIGINTERN PyObject *Exception_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5365 0 : return SWIG_Python_InitShadowInstance(args);
5366 : }
5367 :
5368 0 : SWIGINTERN PyObject *_wrap_new_KeyException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5369 0 : PyObject *resultobj = 0;
5370 0 : kdb::KeyException *result = 0 ;
5371 :
5372 0 : if (!SWIG_Python_UnpackTuple(args,"new_KeyException",0,0,0)) SWIG_fail;
5373 0 : result = (kdb::KeyException *)new kdb::KeyException();
5374 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeyException, SWIG_POINTER_NEW | 0 );
5375 0 : return resultobj;
5376 : fail:
5377 : return NULL;
5378 : }
5379 :
5380 :
5381 0 : SWIGINTERN PyObject *_wrap_delete_KeyException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5382 0 : PyObject *resultobj = 0;
5383 0 : kdb::KeyException *arg1 = (kdb::KeyException *) 0 ;
5384 0 : void *argp1 = 0 ;
5385 0 : int res1 = 0 ;
5386 : PyObject *swig_obj[1] ;
5387 :
5388 0 : if (!args) SWIG_fail;
5389 0 : swig_obj[0] = args;
5390 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeyException, SWIG_POINTER_DISOWN | 0 );
5391 0 : if (!SWIG_IsOK(res1)) {
5392 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeyException" "', argument " "1"" of type '" "kdb::KeyException *""'");
5393 : }
5394 0 : arg1 = reinterpret_cast< kdb::KeyException * >(argp1);
5395 0 : delete arg1;
5396 0 : resultobj = SWIG_Py_Void();
5397 0 : return resultobj;
5398 : fail:
5399 : return NULL;
5400 : }
5401 :
5402 :
5403 3 : SWIGINTERN PyObject *KeyException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5404 : PyObject *obj;
5405 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5406 6 : SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeyException, SWIG_NewClientData(obj));
5407 3 : return SWIG_Py_Void();
5408 : }
5409 :
5410 0 : SWIGINTERN PyObject *KeyException_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5411 0 : return SWIG_Python_InitShadowInstance(args);
5412 : }
5413 :
5414 0 : SWIGINTERN PyObject *_wrap_new_KeyNotFoundException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5415 0 : PyObject *resultobj = 0;
5416 0 : std::string arg1 ;
5417 : PyObject *swig_obj[1] ;
5418 0 : kdb::KeyNotFoundException *result = 0 ;
5419 :
5420 0 : if (!args) SWIG_fail;
5421 0 : swig_obj[0] = args;
5422 : {
5423 0 : std::string *ptr = (std::string *)0;
5424 0 : int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
5425 0 : if (!SWIG_IsOK(res) || !ptr) {
5426 0 : SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_KeyNotFoundException" "', argument " "1"" of type '" "std::string""'");
5427 : }
5428 0 : arg1 = *ptr;
5429 0 : if (SWIG_IsNewObj(res)) delete ptr;
5430 : }
5431 0 : result = (kdb::KeyNotFoundException *)new kdb::KeyNotFoundException(arg1);
5432 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeyNotFoundException, SWIG_POINTER_NEW | 0 );
5433 : return resultobj;
5434 : fail:
5435 : return NULL;
5436 : }
5437 :
5438 :
5439 0 : SWIGINTERN PyObject *_wrap_delete_KeyNotFoundException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5440 0 : PyObject *resultobj = 0;
5441 0 : kdb::KeyNotFoundException *arg1 = (kdb::KeyNotFoundException *) 0 ;
5442 0 : void *argp1 = 0 ;
5443 0 : int res1 = 0 ;
5444 : PyObject *swig_obj[1] ;
5445 :
5446 0 : if (!args) SWIG_fail;
5447 0 : swig_obj[0] = args;
5448 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeyNotFoundException, SWIG_POINTER_DISOWN | 0 );
5449 0 : if (!SWIG_IsOK(res1)) {
5450 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeyNotFoundException" "', argument " "1"" of type '" "kdb::KeyNotFoundException *""'");
5451 : }
5452 0 : arg1 = reinterpret_cast< kdb::KeyNotFoundException * >(argp1);
5453 0 : delete arg1;
5454 0 : resultobj = SWIG_Py_Void();
5455 0 : return resultobj;
5456 : fail:
5457 : return NULL;
5458 : }
5459 :
5460 :
5461 3 : SWIGINTERN PyObject *KeyNotFoundException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5462 : PyObject *obj;
5463 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5464 6 : SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeyNotFoundException, SWIG_NewClientData(obj));
5465 3 : return SWIG_Py_Void();
5466 : }
5467 :
5468 0 : SWIGINTERN PyObject *KeyNotFoundException_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5469 0 : return SWIG_Python_InitShadowInstance(args);
5470 : }
5471 :
5472 0 : SWIGINTERN PyObject *_wrap_new_KeyTypeMismatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5473 0 : PyObject *resultobj = 0;
5474 0 : kdb::KeyTypeMismatch *result = 0 ;
5475 :
5476 0 : if (!SWIG_Python_UnpackTuple(args,"new_KeyTypeMismatch",0,0,0)) SWIG_fail;
5477 0 : result = (kdb::KeyTypeMismatch *)new kdb::KeyTypeMismatch();
5478 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeyTypeMismatch, SWIG_POINTER_NEW | 0 );
5479 0 : return resultobj;
5480 : fail:
5481 : return NULL;
5482 : }
5483 :
5484 :
5485 0 : SWIGINTERN PyObject *_wrap_delete_KeyTypeMismatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5486 0 : PyObject *resultobj = 0;
5487 0 : kdb::KeyTypeMismatch *arg1 = (kdb::KeyTypeMismatch *) 0 ;
5488 0 : void *argp1 = 0 ;
5489 0 : int res1 = 0 ;
5490 : PyObject *swig_obj[1] ;
5491 :
5492 0 : if (!args) SWIG_fail;
5493 0 : swig_obj[0] = args;
5494 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeyTypeMismatch, SWIG_POINTER_DISOWN | 0 );
5495 0 : if (!SWIG_IsOK(res1)) {
5496 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeyTypeMismatch" "', argument " "1"" of type '" "kdb::KeyTypeMismatch *""'");
5497 : }
5498 0 : arg1 = reinterpret_cast< kdb::KeyTypeMismatch * >(argp1);
5499 0 : delete arg1;
5500 0 : resultobj = SWIG_Py_Void();
5501 0 : return resultobj;
5502 : fail:
5503 : return NULL;
5504 : }
5505 :
5506 :
5507 3 : SWIGINTERN PyObject *KeyTypeMismatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5508 : PyObject *obj;
5509 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5510 6 : SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeyTypeMismatch, SWIG_NewClientData(obj));
5511 3 : return SWIG_Py_Void();
5512 : }
5513 :
5514 0 : SWIGINTERN PyObject *KeyTypeMismatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5515 0 : return SWIG_Python_InitShadowInstance(args);
5516 : }
5517 :
5518 0 : SWIGINTERN PyObject *_wrap_new_KeyTypeConversion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5519 0 : PyObject *resultobj = 0;
5520 0 : kdb::KeyTypeConversion *result = 0 ;
5521 :
5522 0 : if (!SWIG_Python_UnpackTuple(args,"new_KeyTypeConversion",0,0,0)) SWIG_fail;
5523 0 : result = (kdb::KeyTypeConversion *)new kdb::KeyTypeConversion();
5524 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeyTypeConversion, SWIG_POINTER_NEW | 0 );
5525 0 : return resultobj;
5526 : fail:
5527 : return NULL;
5528 : }
5529 :
5530 :
5531 0 : SWIGINTERN PyObject *_wrap_delete_KeyTypeConversion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5532 0 : PyObject *resultobj = 0;
5533 0 : kdb::KeyTypeConversion *arg1 = (kdb::KeyTypeConversion *) 0 ;
5534 0 : void *argp1 = 0 ;
5535 0 : int res1 = 0 ;
5536 : PyObject *swig_obj[1] ;
5537 :
5538 0 : if (!args) SWIG_fail;
5539 0 : swig_obj[0] = args;
5540 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeyTypeConversion, SWIG_POINTER_DISOWN | 0 );
5541 0 : if (!SWIG_IsOK(res1)) {
5542 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeyTypeConversion" "', argument " "1"" of type '" "kdb::KeyTypeConversion *""'");
5543 : }
5544 0 : arg1 = reinterpret_cast< kdb::KeyTypeConversion * >(argp1);
5545 0 : delete arg1;
5546 0 : resultobj = SWIG_Py_Void();
5547 0 : return resultobj;
5548 : fail:
5549 : return NULL;
5550 : }
5551 :
5552 :
5553 3 : SWIGINTERN PyObject *KeyTypeConversion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5554 : PyObject *obj;
5555 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5556 6 : SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeyTypeConversion, SWIG_NewClientData(obj));
5557 3 : return SWIG_Py_Void();
5558 : }
5559 :
5560 0 : SWIGINTERN PyObject *KeyTypeConversion_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5561 0 : return SWIG_Python_InitShadowInstance(args);
5562 : }
5563 :
5564 0 : SWIGINTERN PyObject *_wrap_new_KeyInvalidName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5565 0 : PyObject *resultobj = 0;
5566 0 : kdb::KeyInvalidName *result = 0 ;
5567 :
5568 0 : if (!SWIG_Python_UnpackTuple(args,"new_KeyInvalidName",0,0,0)) SWIG_fail;
5569 0 : result = (kdb::KeyInvalidName *)new kdb::KeyInvalidName();
5570 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeyInvalidName, SWIG_POINTER_NEW | 0 );
5571 0 : return resultobj;
5572 : fail:
5573 : return NULL;
5574 : }
5575 :
5576 :
5577 1 : SWIGINTERN PyObject *_wrap_delete_KeyInvalidName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5578 1 : PyObject *resultobj = 0;
5579 1 : kdb::KeyInvalidName *arg1 = (kdb::KeyInvalidName *) 0 ;
5580 1 : void *argp1 = 0 ;
5581 1 : int res1 = 0 ;
5582 : PyObject *swig_obj[1] ;
5583 :
5584 1 : if (!args) SWIG_fail;
5585 1 : swig_obj[0] = args;
5586 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeyInvalidName, SWIG_POINTER_DISOWN | 0 );
5587 1 : if (!SWIG_IsOK(res1)) {
5588 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeyInvalidName" "', argument " "1"" of type '" "kdb::KeyInvalidName *""'");
5589 : }
5590 1 : arg1 = reinterpret_cast< kdb::KeyInvalidName * >(argp1);
5591 1 : delete arg1;
5592 1 : resultobj = SWIG_Py_Void();
5593 1 : return resultobj;
5594 : fail:
5595 : return NULL;
5596 : }
5597 :
5598 :
5599 3 : SWIGINTERN PyObject *KeyInvalidName_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5600 : PyObject *obj;
5601 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5602 6 : SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeyInvalidName, SWIG_NewClientData(obj));
5603 3 : return SWIG_Py_Void();
5604 : }
5605 :
5606 0 : SWIGINTERN PyObject *KeyInvalidName_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5607 0 : return SWIG_Python_InitShadowInstance(args);
5608 : }
5609 :
5610 0 : SWIGINTERN PyObject *_wrap_new_KDBException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5611 0 : PyObject *resultobj = 0;
5612 0 : Key arg1 ;
5613 : void *argp1 ;
5614 0 : int res1 = 0 ;
5615 : PyObject *swig_obj[1] ;
5616 0 : kdb::KDBException *result = 0 ;
5617 :
5618 0 : if (!args) SWIG_fail;
5619 0 : swig_obj[0] = args;
5620 : {
5621 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Key, 0 | 0);
5622 0 : if (!SWIG_IsOK(res1)) {
5623 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KDBException" "', argument " "1"" of type '" "Key""'");
5624 : }
5625 0 : if (!argp1) {
5626 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KDBException" "', argument " "1"" of type '" "Key""'");
5627 : } else {
5628 0 : Key * temp = reinterpret_cast< Key * >(argp1);
5629 0 : arg1 = *temp;
5630 0 : if (SWIG_IsNewObj(res1)) delete temp;
5631 : }
5632 : }
5633 0 : result = (kdb::KDBException *)new kdb::KDBException(arg1);
5634 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KDBException, SWIG_POINTER_NEW | 0 );
5635 : return resultobj;
5636 : fail:
5637 : return NULL;
5638 : }
5639 :
5640 :
5641 0 : SWIGINTERN PyObject *_wrap_delete_KDBException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5642 0 : PyObject *resultobj = 0;
5643 0 : kdb::KDBException *arg1 = (kdb::KDBException *) 0 ;
5644 0 : void *argp1 = 0 ;
5645 0 : int res1 = 0 ;
5646 : PyObject *swig_obj[1] ;
5647 :
5648 0 : if (!args) SWIG_fail;
5649 0 : swig_obj[0] = args;
5650 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDBException, SWIG_POINTER_DISOWN | 0 );
5651 0 : if (!SWIG_IsOK(res1)) {
5652 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KDBException" "', argument " "1"" of type '" "kdb::KDBException *""'");
5653 : }
5654 0 : arg1 = reinterpret_cast< kdb::KDBException * >(argp1);
5655 0 : delete arg1;
5656 0 : resultobj = SWIG_Py_Void();
5657 0 : return resultobj;
5658 : fail:
5659 : return NULL;
5660 : }
5661 :
5662 :
5663 0 : SWIGINTERN PyObject *_wrap_KDBException_whatWithArguments(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5664 0 : PyObject *resultobj = 0;
5665 0 : kdb::KDBException *arg1 = (kdb::KDBException *) 0 ;
5666 : bool arg2 ;
5667 : bool arg3 ;
5668 0 : void *argp1 = 0 ;
5669 0 : int res1 = 0 ;
5670 : bool val2 ;
5671 0 : int ecode2 = 0 ;
5672 : bool val3 ;
5673 0 : int ecode3 = 0 ;
5674 : PyObject *swig_obj[3] ;
5675 0 : char *result = 0 ;
5676 :
5677 0 : if (!SWIG_Python_UnpackTuple(args,"KDBException_whatWithArguments",3,3,swig_obj)) SWIG_fail;
5678 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDBException, 0 | 0 );
5679 0 : if (!SWIG_IsOK(res1)) {
5680 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDBException_whatWithArguments" "', argument " "1"" of type '" "kdb::KDBException const *""'");
5681 : }
5682 0 : arg1 = reinterpret_cast< kdb::KDBException * >(argp1);
5683 0 : ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
5684 0 : if (!SWIG_IsOK(ecode2)) {
5685 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KDBException_whatWithArguments" "', argument " "2"" of type '" "bool""'");
5686 : }
5687 0 : arg2 = static_cast< bool >(val2);
5688 0 : ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
5689 0 : if (!SWIG_IsOK(ecode3)) {
5690 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KDBException_whatWithArguments" "', argument " "3"" of type '" "bool""'");
5691 : }
5692 0 : arg3 = static_cast< bool >(val3);
5693 0 : result = (char *)((kdb::KDBException const *)arg1)->whatWithArguments(arg2,arg3);
5694 0 : resultobj = SWIG_FromCharPtr((const char *)result);
5695 : return resultobj;
5696 : fail:
5697 : return NULL;
5698 : }
5699 :
5700 :
5701 3 : SWIGINTERN PyObject *KDBException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5702 : PyObject *obj;
5703 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5704 6 : SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KDBException, SWIG_NewClientData(obj));
5705 3 : return SWIG_Py_Void();
5706 : }
5707 :
5708 0 : SWIGINTERN PyObject *KDBException_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5709 0 : return SWIG_Python_InitShadowInstance(args);
5710 : }
5711 :
5712 0 : SWIGINTERN PyObject *_wrap_new_ContractException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5713 0 : PyObject *resultobj = 0;
5714 0 : Key arg1 ;
5715 : void *argp1 ;
5716 0 : int res1 = 0 ;
5717 : PyObject *swig_obj[1] ;
5718 0 : kdb::ContractException *result = 0 ;
5719 :
5720 0 : if (!args) SWIG_fail;
5721 0 : swig_obj[0] = args;
5722 : {
5723 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_Key, 0 | 0);
5724 0 : if (!SWIG_IsOK(res1)) {
5725 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ContractException" "', argument " "1"" of type '" "Key""'");
5726 : }
5727 0 : if (!argp1) {
5728 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContractException" "', argument " "1"" of type '" "Key""'");
5729 : } else {
5730 0 : Key * temp = reinterpret_cast< Key * >(argp1);
5731 0 : arg1 = *temp;
5732 0 : if (SWIG_IsNewObj(res1)) delete temp;
5733 : }
5734 : }
5735 0 : result = (kdb::ContractException *)new kdb::ContractException(arg1);
5736 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__ContractException, SWIG_POINTER_NEW | 0 );
5737 : return resultobj;
5738 : fail:
5739 : return NULL;
5740 : }
5741 :
5742 :
5743 0 : SWIGINTERN PyObject *_wrap_delete_ContractException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5744 0 : PyObject *resultobj = 0;
5745 0 : kdb::ContractException *arg1 = (kdb::ContractException *) 0 ;
5746 0 : void *argp1 = 0 ;
5747 0 : int res1 = 0 ;
5748 : PyObject *swig_obj[1] ;
5749 :
5750 0 : if (!args) SWIG_fail;
5751 0 : swig_obj[0] = args;
5752 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__ContractException, SWIG_POINTER_DISOWN | 0 );
5753 0 : if (!SWIG_IsOK(res1)) {
5754 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContractException" "', argument " "1"" of type '" "kdb::ContractException *""'");
5755 : }
5756 0 : arg1 = reinterpret_cast< kdb::ContractException * >(argp1);
5757 0 : delete arg1;
5758 0 : resultobj = SWIG_Py_Void();
5759 0 : return resultobj;
5760 : fail:
5761 : return NULL;
5762 : }
5763 :
5764 :
5765 3 : SWIGINTERN PyObject *ContractException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5766 : PyObject *obj;
5767 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5768 6 : SWIG_TypeNewClientData(SWIGTYPE_p_kdb__ContractException, SWIG_NewClientData(obj));
5769 3 : return SWIG_Py_Void();
5770 : }
5771 :
5772 0 : SWIGINTERN PyObject *ContractException_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5773 0 : return SWIG_Python_InitShadowInstance(args);
5774 : }
5775 :
5776 8 : SWIGINTERN PyObject *_wrap_new_Key__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
5777 8 : PyObject *resultobj = 0;
5778 8 : kdb::Key *result = 0 ;
5779 :
5780 8 : if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
5781 : {
5782 : try {
5783 16 : result = (kdb::Key *)new kdb::Key();
5784 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
5785 0 : SWIG_exception(SWIG_RuntimeError, e.what());
5786 0 : } catch (...) {
5787 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::Key()");
5788 : }
5789 : }
5790 8 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, SWIG_POINTER_NEW | 0 );
5791 : return resultobj;
5792 : fail:
5793 : return NULL;
5794 : }
5795 :
5796 :
5797 1 : SWIGINTERN PyObject *_wrap_new_Key__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
5798 1 : PyObject *resultobj = 0;
5799 1 : ckdb::Key *arg1 = (ckdb::Key *) 0 ;
5800 1 : void *argp1 = 0 ;
5801 1 : int res1 = 0 ;
5802 1 : kdb::Key *result = 0 ;
5803 :
5804 1 : if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
5805 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__Key, 0 | 0 );
5806 1 : if (!SWIG_IsOK(res1)) {
5807 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Key" "', argument " "1"" of type '" "ckdb::Key *""'");
5808 : }
5809 1 : arg1 = reinterpret_cast< ckdb::Key * >(argp1);
5810 : {
5811 : try {
5812 2 : result = (kdb::Key *)new kdb::Key(arg1);
5813 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
5814 0 : SWIG_exception(SWIG_RuntimeError, e.what());
5815 0 : } catch (...) {
5816 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::Key(ckdb::Key *)");
5817 : }
5818 : }
5819 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, SWIG_POINTER_NEW | 0 );
5820 : return resultobj;
5821 : fail:
5822 : return NULL;
5823 : }
5824 :
5825 :
5826 2 : SWIGINTERN PyObject *_wrap_new_Key__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
5827 2 : PyObject *resultobj = 0;
5828 2 : kdb::Key *arg1 = 0 ;
5829 2 : void *argp1 = 0 ;
5830 2 : int res1 = 0 ;
5831 2 : kdb::Key *result = 0 ;
5832 :
5833 2 : if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
5834 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_kdb__Key, 0 );
5835 2 : if (!SWIG_IsOK(res1)) {
5836 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Key" "', argument " "1"" of type '" "kdb::Key &""'");
5837 : }
5838 2 : if (!argp1) {
5839 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Key" "', argument " "1"" of type '" "kdb::Key &""'");
5840 : }
5841 2 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
5842 : {
5843 : try {
5844 4 : result = (kdb::Key *)new kdb::Key(*arg1);
5845 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
5846 0 : SWIG_exception(SWIG_RuntimeError, e.what());
5847 0 : } catch (...) {
5848 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::Key(kdb::Key &)");
5849 : }
5850 : }
5851 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, SWIG_POINTER_NEW | 0 );
5852 : return resultobj;
5853 : fail:
5854 : return NULL;
5855 : }
5856 :
5857 :
5858 0 : SWIGINTERN PyObject *_wrap_Key__incRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5859 0 : PyObject *resultobj = 0;
5860 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
5861 0 : void *argp1 = 0 ;
5862 0 : int res1 = 0 ;
5863 : PyObject *swig_obj[1] ;
5864 :
5865 0 : if (!args) SWIG_fail;
5866 0 : swig_obj[0] = args;
5867 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
5868 0 : if (!SWIG_IsOK(res1)) {
5869 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__incRef" "', argument " "1"" of type '" "kdb::Key const *""'");
5870 : }
5871 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
5872 : {
5873 : try {
5874 0 : ((kdb::Key const *)arg1)->operator ++();
5875 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
5876 0 : SWIG_exception(SWIG_RuntimeError, e.what());
5877 0 : } catch (...) {
5878 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator ++() const");
5879 : }
5880 : }
5881 0 : resultobj = SWIG_Py_Void();
5882 0 : return resultobj;
5883 : fail:
5884 : return NULL;
5885 : }
5886 :
5887 :
5888 0 : SWIGINTERN PyObject *_wrap_Key__decRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5889 0 : PyObject *resultobj = 0;
5890 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
5891 0 : void *argp1 = 0 ;
5892 0 : int res1 = 0 ;
5893 : PyObject *swig_obj[1] ;
5894 :
5895 0 : if (!args) SWIG_fail;
5896 0 : swig_obj[0] = args;
5897 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
5898 0 : if (!SWIG_IsOK(res1)) {
5899 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__decRef" "', argument " "1"" of type '" "kdb::Key const *""'");
5900 : }
5901 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
5902 : {
5903 : try {
5904 0 : ((kdb::Key const *)arg1)->operator --();
5905 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
5906 0 : SWIG_exception(SWIG_RuntimeError, e.what());
5907 0 : } catch (...) {
5908 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator --() const");
5909 : }
5910 : }
5911 0 : resultobj = SWIG_Py_Void();
5912 0 : return resultobj;
5913 : fail:
5914 : return NULL;
5915 : }
5916 :
5917 :
5918 0 : SWIGINTERN PyObject *_wrap_Key_getReferenceCounter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5919 0 : PyObject *resultobj = 0;
5920 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
5921 0 : void *argp1 = 0 ;
5922 0 : int res1 = 0 ;
5923 : PyObject *swig_obj[1] ;
5924 : ssize_t result;
5925 :
5926 0 : if (!args) SWIG_fail;
5927 0 : swig_obj[0] = args;
5928 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
5929 0 : if (!SWIG_IsOK(res1)) {
5930 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_getReferenceCounter" "', argument " "1"" of type '" "kdb::Key const *""'");
5931 : }
5932 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
5933 : {
5934 : try {
5935 0 : result = ((kdb::Key const *)arg1)->getReferenceCounter();
5936 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
5937 0 : SWIG_exception(SWIG_RuntimeError, e.what());
5938 0 : } catch (...) {
5939 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getReferenceCounter() const");
5940 : }
5941 : }
5942 0 : resultobj = SWIG_From_long(static_cast< long >(result));
5943 : return resultobj;
5944 : fail:
5945 : return NULL;
5946 : }
5947 :
5948 :
5949 0 : SWIGINTERN PyObject *_wrap_Key_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5950 0 : PyObject *resultobj = 0;
5951 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
5952 0 : kdb::Key *arg2 = 0 ;
5953 0 : void *argp1 = 0 ;
5954 0 : int res1 = 0 ;
5955 0 : void *argp2 = 0 ;
5956 0 : int res2 = 0 ;
5957 : PyObject *swig_obj[2] ;
5958 :
5959 0 : if (!SWIG_Python_UnpackTuple(args,"Key_copy",2,2,swig_obj)) SWIG_fail;
5960 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
5961 0 : if (!SWIG_IsOK(res1)) {
5962 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_copy" "', argument " "1"" of type '" "kdb::Key *""'");
5963 : }
5964 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
5965 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
5966 0 : if (!SWIG_IsOK(res2)) {
5967 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_copy" "', argument " "2"" of type '" "kdb::Key const &""'");
5968 : }
5969 0 : if (!argp2) {
5970 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_copy" "', argument " "2"" of type '" "kdb::Key const &""'");
5971 : }
5972 0 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
5973 : {
5974 : try {
5975 0 : (arg1)->copy((kdb::Key const &)*arg2);
5976 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
5977 0 : SWIG_exception(SWIG_RuntimeError, e.what());
5978 0 : } catch (...) {
5979 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::copy(kdb::Key const &)");
5980 : }
5981 : }
5982 0 : resultobj = SWIG_Py_Void();
5983 0 : return resultobj;
5984 : fail:
5985 : return NULL;
5986 : }
5987 :
5988 :
5989 0 : SWIGINTERN PyObject *_wrap_Key_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5990 0 : PyObject *resultobj = 0;
5991 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
5992 0 : void *argp1 = 0 ;
5993 0 : int res1 = 0 ;
5994 : PyObject *swig_obj[1] ;
5995 :
5996 0 : if (!args) SWIG_fail;
5997 0 : swig_obj[0] = args;
5998 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
5999 0 : if (!SWIG_IsOK(res1)) {
6000 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_clear" "', argument " "1"" of type '" "kdb::Key *""'");
6001 : }
6002 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6003 : {
6004 : try {
6005 0 : (arg1)->clear();
6006 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6007 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6008 0 : } catch (...) {
6009 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::clear()");
6010 : }
6011 : }
6012 0 : resultobj = SWIG_Py_Void();
6013 0 : return resultobj;
6014 : fail:
6015 : return NULL;
6016 : }
6017 :
6018 :
6019 4 : SWIGINTERN PyObject *_wrap_Key_getKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6020 4 : PyObject *resultobj = 0;
6021 4 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6022 4 : void *argp1 = 0 ;
6023 4 : int res1 = 0 ;
6024 : PyObject *swig_obj[1] ;
6025 4 : ckdb::Key *result = 0 ;
6026 :
6027 4 : if (!args) SWIG_fail;
6028 4 : swig_obj[0] = args;
6029 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6030 4 : if (!SWIG_IsOK(res1)) {
6031 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_getKey" "', argument " "1"" of type '" "kdb::Key const *""'");
6032 : }
6033 4 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6034 : {
6035 : try {
6036 4 : result = (ckdb::Key *)((kdb::Key const *)arg1)->getKey();
6037 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6038 : SWIG_exception(SWIG_RuntimeError, e.what());
6039 : } catch (...) {
6040 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getKey() const");
6041 : }
6042 : }
6043 4 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__Key, 0 | 0 );
6044 : return resultobj;
6045 : fail:
6046 : return NULL;
6047 : }
6048 :
6049 :
6050 0 : SWIGINTERN PyObject *_wrap_Key___ref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6051 0 : PyObject *resultobj = 0;
6052 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6053 0 : void *argp1 = 0 ;
6054 0 : int res1 = 0 ;
6055 : PyObject *swig_obj[1] ;
6056 0 : ckdb::Key *result = 0 ;
6057 :
6058 0 : if (!args) SWIG_fail;
6059 0 : swig_obj[0] = args;
6060 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6061 0 : if (!SWIG_IsOK(res1)) {
6062 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___ref__" "', argument " "1"" of type '" "kdb::Key const *""'");
6063 : }
6064 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6065 : {
6066 : try {
6067 0 : result = (ckdb::Key *)((kdb::Key const *)arg1)->operator *();
6068 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6069 : SWIG_exception(SWIG_RuntimeError, e.what());
6070 : } catch (...) {
6071 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator *() const");
6072 : }
6073 : }
6074 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__Key, 0 | 0 );
6075 : return resultobj;
6076 : fail:
6077 : return NULL;
6078 : }
6079 :
6080 :
6081 0 : SWIGINTERN PyObject *_wrap_Key_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6082 0 : PyObject *resultobj = 0;
6083 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6084 0 : void *argp1 = 0 ;
6085 0 : int res1 = 0 ;
6086 : PyObject *swig_obj[1] ;
6087 0 : ckdb::Key *result = 0 ;
6088 :
6089 0 : if (!args) SWIG_fail;
6090 0 : swig_obj[0] = args;
6091 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6092 0 : if (!SWIG_IsOK(res1)) {
6093 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_release" "', argument " "1"" of type '" "kdb::Key *""'");
6094 : }
6095 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6096 : {
6097 : try {
6098 0 : result = (ckdb::Key *)(arg1)->release();
6099 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6100 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6101 0 : } catch (...) {
6102 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::release()");
6103 : }
6104 : }
6105 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__Key, 0 | 0 );
6106 : return resultobj;
6107 : fail:
6108 : return NULL;
6109 : }
6110 :
6111 :
6112 1 : SWIGINTERN PyObject *_wrap_Key_dup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6113 1 : PyObject *resultobj = 0;
6114 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6115 1 : void *argp1 = 0 ;
6116 1 : int res1 = 0 ;
6117 : PyObject *swig_obj[1] ;
6118 1 : ckdb::Key *result = 0 ;
6119 :
6120 1 : if (!args) SWIG_fail;
6121 1 : swig_obj[0] = args;
6122 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6123 1 : if (!SWIG_IsOK(res1)) {
6124 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_dup" "', argument " "1"" of type '" "kdb::Key const *""'");
6125 : }
6126 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6127 : {
6128 : try {
6129 1 : result = (ckdb::Key *)((kdb::Key const *)arg1)->dup();
6130 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6131 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6132 0 : } catch (...) {
6133 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::dup() const");
6134 : }
6135 : }
6136 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__Key, 0 | 0 );
6137 : return resultobj;
6138 : fail:
6139 : return NULL;
6140 : }
6141 :
6142 :
6143 172 : SWIGINTERN PyObject *_wrap_delete_Key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6144 172 : PyObject *resultobj = 0;
6145 172 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6146 172 : void *argp1 = 0 ;
6147 172 : int res1 = 0 ;
6148 : PyObject *swig_obj[1] ;
6149 :
6150 172 : if (!args) SWIG_fail;
6151 172 : swig_obj[0] = args;
6152 172 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, SWIG_POINTER_DISOWN | 0 );
6153 172 : if (!SWIG_IsOK(res1)) {
6154 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Key" "', argument " "1"" of type '" "kdb::Key *""'");
6155 : }
6156 172 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6157 : {
6158 : try {
6159 344 : delete arg1;
6160 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6161 : SWIG_exception(SWIG_RuntimeError, e.what());
6162 : } catch (...) {
6163 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::~Key()");
6164 : }
6165 : }
6166 172 : resultobj = SWIG_Py_Void();
6167 172 : return resultobj;
6168 : fail:
6169 : return NULL;
6170 : }
6171 :
6172 :
6173 7 : SWIGINTERN PyObject *_wrap_Key__getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6174 7 : PyObject *resultobj = 0;
6175 7 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6176 7 : void *argp1 = 0 ;
6177 7 : int res1 = 0 ;
6178 : PyObject *swig_obj[1] ;
6179 14 : std::string result;
6180 :
6181 7 : if (!args) SWIG_fail;
6182 7 : swig_obj[0] = args;
6183 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6184 7 : if (!SWIG_IsOK(res1)) {
6185 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getName" "', argument " "1"" of type '" "kdb::Key const *""'");
6186 : }
6187 7 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6188 : {
6189 : try {
6190 14 : result = ((kdb::Key const *)arg1)->getName();
6191 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6192 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6193 0 : } catch (...) {
6194 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getName() const");
6195 : }
6196 : }
6197 21 : resultobj = SWIG_From_std_string(static_cast< std::string >(result));
6198 7 : return resultobj;
6199 : fail:
6200 : return NULL;
6201 : }
6202 :
6203 :
6204 0 : SWIGINTERN PyObject *_wrap_Key__getNameSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6205 0 : PyObject *resultobj = 0;
6206 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6207 0 : void *argp1 = 0 ;
6208 0 : int res1 = 0 ;
6209 : PyObject *swig_obj[1] ;
6210 : ssize_t result;
6211 :
6212 0 : if (!args) SWIG_fail;
6213 0 : swig_obj[0] = args;
6214 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6215 0 : if (!SWIG_IsOK(res1)) {
6216 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getNameSize" "', argument " "1"" of type '" "kdb::Key const *""'");
6217 : }
6218 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6219 : {
6220 : try {
6221 0 : result = ((kdb::Key const *)arg1)->getNameSize();
6222 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6223 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6224 0 : } catch (...) {
6225 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getNameSize() const");
6226 : }
6227 : }
6228 0 : resultobj = SWIG_From_long(static_cast< long >(result));
6229 : return resultobj;
6230 : fail:
6231 : return NULL;
6232 : }
6233 :
6234 :
6235 2 : SWIGINTERN PyObject *_wrap_Key__getBaseName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6236 2 : PyObject *resultobj = 0;
6237 2 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6238 2 : void *argp1 = 0 ;
6239 2 : int res1 = 0 ;
6240 : PyObject *swig_obj[1] ;
6241 4 : std::string result;
6242 :
6243 2 : if (!args) SWIG_fail;
6244 2 : swig_obj[0] = args;
6245 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6246 2 : if (!SWIG_IsOK(res1)) {
6247 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getBaseName" "', argument " "1"" of type '" "kdb::Key const *""'");
6248 : }
6249 2 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6250 : {
6251 : try {
6252 4 : result = ((kdb::Key const *)arg1)->getBaseName();
6253 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6254 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6255 0 : } catch (...) {
6256 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getBaseName() const");
6257 : }
6258 : }
6259 6 : resultobj = SWIG_From_std_string(static_cast< std::string >(result));
6260 2 : return resultobj;
6261 : fail:
6262 : return NULL;
6263 : }
6264 :
6265 :
6266 0 : SWIGINTERN PyObject *_wrap_Key__getBaseNameSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6267 0 : PyObject *resultobj = 0;
6268 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6269 0 : void *argp1 = 0 ;
6270 0 : int res1 = 0 ;
6271 : PyObject *swig_obj[1] ;
6272 : ssize_t result;
6273 :
6274 0 : if (!args) SWIG_fail;
6275 0 : swig_obj[0] = args;
6276 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6277 0 : if (!SWIG_IsOK(res1)) {
6278 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getBaseNameSize" "', argument " "1"" of type '" "kdb::Key const *""'");
6279 : }
6280 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6281 : {
6282 : try {
6283 0 : result = ((kdb::Key const *)arg1)->getBaseNameSize();
6284 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6285 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6286 0 : } catch (...) {
6287 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getBaseNameSize() const");
6288 : }
6289 : }
6290 0 : resultobj = SWIG_From_long(static_cast< long >(result));
6291 : return resultobj;
6292 : fail:
6293 : return NULL;
6294 : }
6295 :
6296 :
6297 4 : SWIGINTERN PyObject *_wrap_Key__setName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6298 4 : PyObject *resultobj = 0;
6299 4 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6300 4 : std::string *arg2 = 0 ;
6301 4 : void *argp1 = 0 ;
6302 4 : int res1 = 0 ;
6303 4 : int res2 = SWIG_OLDOBJ ;
6304 : PyObject *swig_obj[2] ;
6305 :
6306 4 : if (!SWIG_Python_UnpackTuple(args,"Key__setName",2,2,swig_obj)) SWIG_fail;
6307 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6308 4 : if (!SWIG_IsOK(res1)) {
6309 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__setName" "', argument " "1"" of type '" "kdb::Key *""'");
6310 : }
6311 4 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6312 : {
6313 4 : std::string *ptr = (std::string *)0;
6314 4 : res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
6315 4 : if (!SWIG_IsOK(res2)) {
6316 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key__setName" "', argument " "2"" of type '" "std::string const &""'");
6317 : }
6318 4 : if (!ptr) {
6319 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key__setName" "', argument " "2"" of type '" "std::string const &""'");
6320 : }
6321 4 : arg2 = ptr;
6322 : }
6323 : {
6324 : try {
6325 4 : (arg1)->setName((std::string const &)*arg2);
6326 2 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6327 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6328 0 : } catch (...) {
6329 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setName(std::string const &)");
6330 : }
6331 : }
6332 3 : resultobj = SWIG_Py_Void();
6333 6 : if (SWIG_IsNewObj(res2)) delete arg2;
6334 : return resultobj;
6335 : fail:
6336 2 : if (SWIG_IsNewObj(res2)) delete arg2;
6337 : return NULL;
6338 : }
6339 :
6340 :
6341 0 : SWIGINTERN PyObject *_wrap_Key_addName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6342 0 : PyObject *resultobj = 0;
6343 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6344 0 : std::string *arg2 = 0 ;
6345 0 : void *argp1 = 0 ;
6346 0 : int res1 = 0 ;
6347 0 : int res2 = SWIG_OLDOBJ ;
6348 : PyObject *swig_obj[2] ;
6349 :
6350 0 : if (!SWIG_Python_UnpackTuple(args,"Key_addName",2,2,swig_obj)) SWIG_fail;
6351 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6352 0 : if (!SWIG_IsOK(res1)) {
6353 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_addName" "', argument " "1"" of type '" "kdb::Key *""'");
6354 : }
6355 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6356 : {
6357 0 : std::string *ptr = (std::string *)0;
6358 0 : res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
6359 0 : if (!SWIG_IsOK(res2)) {
6360 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_addName" "', argument " "2"" of type '" "std::string const &""'");
6361 : }
6362 0 : if (!ptr) {
6363 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_addName" "', argument " "2"" of type '" "std::string const &""'");
6364 : }
6365 0 : arg2 = ptr;
6366 : }
6367 : {
6368 : try {
6369 0 : (arg1)->addName((std::string const &)*arg2);
6370 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6371 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6372 0 : } catch (...) {
6373 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::addName(std::string const &)");
6374 : }
6375 : }
6376 0 : resultobj = SWIG_Py_Void();
6377 0 : if (SWIG_IsNewObj(res2)) delete arg2;
6378 : return resultobj;
6379 : fail:
6380 0 : if (SWIG_IsNewObj(res2)) delete arg2;
6381 : return NULL;
6382 : }
6383 :
6384 :
6385 1 : SWIGINTERN PyObject *_wrap_Key__setBaseName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6386 1 : PyObject *resultobj = 0;
6387 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6388 1 : std::string *arg2 = 0 ;
6389 1 : void *argp1 = 0 ;
6390 1 : int res1 = 0 ;
6391 1 : int res2 = SWIG_OLDOBJ ;
6392 : PyObject *swig_obj[2] ;
6393 :
6394 1 : if (!SWIG_Python_UnpackTuple(args,"Key__setBaseName",2,2,swig_obj)) SWIG_fail;
6395 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6396 1 : if (!SWIG_IsOK(res1)) {
6397 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__setBaseName" "', argument " "1"" of type '" "kdb::Key *""'");
6398 : }
6399 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6400 : {
6401 1 : std::string *ptr = (std::string *)0;
6402 1 : res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
6403 1 : if (!SWIG_IsOK(res2)) {
6404 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key__setBaseName" "', argument " "2"" of type '" "std::string const &""'");
6405 : }
6406 1 : if (!ptr) {
6407 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key__setBaseName" "', argument " "2"" of type '" "std::string const &""'");
6408 : }
6409 1 : arg2 = ptr;
6410 : }
6411 : {
6412 : try {
6413 1 : (arg1)->setBaseName((std::string const &)*arg2);
6414 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6415 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6416 0 : } catch (...) {
6417 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setBaseName(std::string const &)");
6418 : }
6419 : }
6420 1 : resultobj = SWIG_Py_Void();
6421 2 : if (SWIG_IsNewObj(res2)) delete arg2;
6422 : return resultobj;
6423 : fail:
6424 0 : if (SWIG_IsNewObj(res2)) delete arg2;
6425 : return NULL;
6426 : }
6427 :
6428 :
6429 0 : SWIGINTERN PyObject *_wrap_Key_addBaseName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6430 0 : PyObject *resultobj = 0;
6431 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6432 0 : std::string *arg2 = 0 ;
6433 0 : void *argp1 = 0 ;
6434 0 : int res1 = 0 ;
6435 0 : int res2 = SWIG_OLDOBJ ;
6436 : PyObject *swig_obj[2] ;
6437 :
6438 0 : if (!SWIG_Python_UnpackTuple(args,"Key_addBaseName",2,2,swig_obj)) SWIG_fail;
6439 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6440 0 : if (!SWIG_IsOK(res1)) {
6441 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_addBaseName" "', argument " "1"" of type '" "kdb::Key *""'");
6442 : }
6443 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6444 : {
6445 0 : std::string *ptr = (std::string *)0;
6446 0 : res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
6447 0 : if (!SWIG_IsOK(res2)) {
6448 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_addBaseName" "', argument " "2"" of type '" "std::string const &""'");
6449 : }
6450 0 : if (!ptr) {
6451 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_addBaseName" "', argument " "2"" of type '" "std::string const &""'");
6452 : }
6453 0 : arg2 = ptr;
6454 : }
6455 : {
6456 : try {
6457 0 : (arg1)->addBaseName((std::string const &)*arg2);
6458 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6459 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6460 0 : } catch (...) {
6461 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::addBaseName(std::string const &)");
6462 : }
6463 : }
6464 0 : resultobj = SWIG_Py_Void();
6465 0 : if (SWIG_IsNewObj(res2)) delete arg2;
6466 : return resultobj;
6467 : fail:
6468 0 : if (SWIG_IsNewObj(res2)) delete arg2;
6469 : return NULL;
6470 : }
6471 :
6472 :
6473 0 : SWIGINTERN PyObject *_wrap_Key_delBaseName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6474 0 : PyObject *resultobj = 0;
6475 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6476 0 : void *argp1 = 0 ;
6477 0 : int res1 = 0 ;
6478 : PyObject *swig_obj[1] ;
6479 :
6480 0 : if (!args) SWIG_fail;
6481 0 : swig_obj[0] = args;
6482 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6483 0 : if (!SWIG_IsOK(res1)) {
6484 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_delBaseName" "', argument " "1"" of type '" "kdb::Key *""'");
6485 : }
6486 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6487 : {
6488 : try {
6489 0 : (arg1)->delBaseName();
6490 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6491 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6492 0 : } catch (...) {
6493 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::delBaseName()");
6494 : }
6495 : }
6496 0 : resultobj = SWIG_Py_Void();
6497 0 : return resultobj;
6498 : fail:
6499 : return NULL;
6500 : }
6501 :
6502 :
6503 0 : SWIGINTERN PyObject *_wrap_Key__getFullNameSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6504 0 : PyObject *resultobj = 0;
6505 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6506 0 : void *argp1 = 0 ;
6507 0 : int res1 = 0 ;
6508 : PyObject *swig_obj[1] ;
6509 : ssize_t result;
6510 :
6511 0 : if (!args) SWIG_fail;
6512 0 : swig_obj[0] = args;
6513 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6514 0 : if (!SWIG_IsOK(res1)) {
6515 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getFullNameSize" "', argument " "1"" of type '" "kdb::Key const *""'");
6516 : }
6517 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6518 : {
6519 : try {
6520 0 : result = ((kdb::Key const *)arg1)->getFullNameSize();
6521 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6522 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6523 0 : } catch (...) {
6524 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getFullNameSize() const");
6525 : }
6526 : }
6527 0 : resultobj = SWIG_From_long(static_cast< long >(result));
6528 : return resultobj;
6529 : fail:
6530 : return NULL;
6531 : }
6532 :
6533 :
6534 2 : SWIGINTERN PyObject *_wrap_Key__getFullName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6535 2 : PyObject *resultobj = 0;
6536 2 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6537 2 : void *argp1 = 0 ;
6538 2 : int res1 = 0 ;
6539 : PyObject *swig_obj[1] ;
6540 4 : std::string result;
6541 :
6542 2 : if (!args) SWIG_fail;
6543 2 : swig_obj[0] = args;
6544 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6545 2 : if (!SWIG_IsOK(res1)) {
6546 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getFullName" "', argument " "1"" of type '" "kdb::Key const *""'");
6547 : }
6548 2 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6549 : {
6550 : try {
6551 4 : result = ((kdb::Key const *)arg1)->getFullName();
6552 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6553 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6554 0 : } catch (...) {
6555 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getFullName() const");
6556 : }
6557 : }
6558 6 : resultobj = SWIG_From_std_string(static_cast< std::string >(result));
6559 2 : return resultobj;
6560 : fail:
6561 : return NULL;
6562 : }
6563 :
6564 :
6565 17 : SWIGINTERN PyObject *_wrap_Key___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6566 17 : PyObject *resultobj = 0;
6567 17 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6568 17 : kdb::Key *arg2 = 0 ;
6569 17 : void *argp1 = 0 ;
6570 17 : int res1 = 0 ;
6571 17 : void *argp2 = 0 ;
6572 17 : int res2 = 0 ;
6573 : PyObject *swig_obj[2] ;
6574 : bool result;
6575 :
6576 17 : if (!SWIG_Python_UnpackTuple(args,"Key___eq__",2,2,swig_obj)) SWIG_fail;
6577 17 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6578 17 : if (!SWIG_IsOK(res1)) {
6579 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___eq__" "', argument " "1"" of type '" "kdb::Key const *""'");
6580 : }
6581 17 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6582 17 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
6583 17 : if (!SWIG_IsOK(res2)) {
6584 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___eq__" "', argument " "2"" of type '" "kdb::Key const &""'");
6585 : }
6586 17 : if (!argp2) {
6587 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___eq__" "', argument " "2"" of type '" "kdb::Key const &""'");
6588 : }
6589 17 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
6590 : {
6591 : try {
6592 17 : result = (bool)((kdb::Key const *)arg1)->operator ==((kdb::Key const &)*arg2);
6593 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6594 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6595 0 : } catch (...) {
6596 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator ==(kdb::Key const &) const");
6597 : }
6598 : }
6599 : resultobj = SWIG_From_bool(static_cast< bool >(result));
6600 : return resultobj;
6601 : fail:
6602 : return NULL;
6603 : }
6604 :
6605 :
6606 5 : SWIGINTERN PyObject *_wrap_Key___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6607 5 : PyObject *resultobj = 0;
6608 5 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6609 5 : kdb::Key *arg2 = 0 ;
6610 5 : void *argp1 = 0 ;
6611 5 : int res1 = 0 ;
6612 5 : void *argp2 = 0 ;
6613 5 : int res2 = 0 ;
6614 : PyObject *swig_obj[2] ;
6615 : bool result;
6616 :
6617 5 : if (!SWIG_Python_UnpackTuple(args,"Key___ne__",2,2,swig_obj)) SWIG_fail;
6618 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6619 5 : if (!SWIG_IsOK(res1)) {
6620 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___ne__" "', argument " "1"" of type '" "kdb::Key const *""'");
6621 : }
6622 5 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6623 5 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
6624 5 : if (!SWIG_IsOK(res2)) {
6625 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___ne__" "', argument " "2"" of type '" "kdb::Key const &""'");
6626 : }
6627 5 : if (!argp2) {
6628 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___ne__" "', argument " "2"" of type '" "kdb::Key const &""'");
6629 : }
6630 5 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
6631 : {
6632 : try {
6633 5 : result = (bool)((kdb::Key const *)arg1)->operator !=((kdb::Key const &)*arg2);
6634 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6635 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6636 0 : } catch (...) {
6637 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator !=(kdb::Key const &) const");
6638 : }
6639 : }
6640 : resultobj = SWIG_From_bool(static_cast< bool >(result));
6641 : return resultobj;
6642 : fail:
6643 : return NULL;
6644 : }
6645 :
6646 :
6647 1 : SWIGINTERN PyObject *_wrap_Key___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6648 1 : PyObject *resultobj = 0;
6649 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6650 1 : kdb::Key *arg2 = 0 ;
6651 1 : void *argp1 = 0 ;
6652 1 : int res1 = 0 ;
6653 1 : void *argp2 = 0 ;
6654 1 : int res2 = 0 ;
6655 : PyObject *swig_obj[2] ;
6656 : bool result;
6657 :
6658 1 : if (!SWIG_Python_UnpackTuple(args,"Key___lt__",2,2,swig_obj)) SWIG_fail;
6659 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6660 1 : if (!SWIG_IsOK(res1)) {
6661 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___lt__" "', argument " "1"" of type '" "kdb::Key const *""'");
6662 : }
6663 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6664 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
6665 1 : if (!SWIG_IsOK(res2)) {
6666 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___lt__" "', argument " "2"" of type '" "kdb::Key const &""'");
6667 : }
6668 1 : if (!argp2) {
6669 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___lt__" "', argument " "2"" of type '" "kdb::Key const &""'");
6670 : }
6671 1 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
6672 : {
6673 : try {
6674 1 : result = (bool)((kdb::Key const *)arg1)->operator <((kdb::Key const &)*arg2);
6675 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6676 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6677 0 : } catch (...) {
6678 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator <(kdb::Key const &) const");
6679 : }
6680 : }
6681 : resultobj = SWIG_From_bool(static_cast< bool >(result));
6682 : return resultobj;
6683 : fail:
6684 : return NULL;
6685 : }
6686 :
6687 :
6688 1 : SWIGINTERN PyObject *_wrap_Key___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6689 1 : PyObject *resultobj = 0;
6690 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6691 1 : kdb::Key *arg2 = 0 ;
6692 1 : void *argp1 = 0 ;
6693 1 : int res1 = 0 ;
6694 1 : void *argp2 = 0 ;
6695 1 : int res2 = 0 ;
6696 : PyObject *swig_obj[2] ;
6697 : bool result;
6698 :
6699 1 : if (!SWIG_Python_UnpackTuple(args,"Key___le__",2,2,swig_obj)) SWIG_fail;
6700 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6701 1 : if (!SWIG_IsOK(res1)) {
6702 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___le__" "', argument " "1"" of type '" "kdb::Key const *""'");
6703 : }
6704 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6705 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
6706 1 : if (!SWIG_IsOK(res2)) {
6707 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___le__" "', argument " "2"" of type '" "kdb::Key const &""'");
6708 : }
6709 1 : if (!argp2) {
6710 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___le__" "', argument " "2"" of type '" "kdb::Key const &""'");
6711 : }
6712 1 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
6713 : {
6714 : try {
6715 1 : result = (bool)((kdb::Key const *)arg1)->operator <=((kdb::Key const &)*arg2);
6716 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6717 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6718 0 : } catch (...) {
6719 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator <=(kdb::Key const &) const");
6720 : }
6721 : }
6722 : resultobj = SWIG_From_bool(static_cast< bool >(result));
6723 : return resultobj;
6724 : fail:
6725 : return NULL;
6726 : }
6727 :
6728 :
6729 1 : SWIGINTERN PyObject *_wrap_Key___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6730 1 : PyObject *resultobj = 0;
6731 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6732 1 : kdb::Key *arg2 = 0 ;
6733 1 : void *argp1 = 0 ;
6734 1 : int res1 = 0 ;
6735 1 : void *argp2 = 0 ;
6736 1 : int res2 = 0 ;
6737 : PyObject *swig_obj[2] ;
6738 : bool result;
6739 :
6740 1 : if (!SWIG_Python_UnpackTuple(args,"Key___gt__",2,2,swig_obj)) SWIG_fail;
6741 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6742 1 : if (!SWIG_IsOK(res1)) {
6743 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___gt__" "', argument " "1"" of type '" "kdb::Key const *""'");
6744 : }
6745 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6746 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
6747 1 : if (!SWIG_IsOK(res2)) {
6748 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___gt__" "', argument " "2"" of type '" "kdb::Key const &""'");
6749 : }
6750 1 : if (!argp2) {
6751 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___gt__" "', argument " "2"" of type '" "kdb::Key const &""'");
6752 : }
6753 1 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
6754 : {
6755 : try {
6756 1 : result = (bool)((kdb::Key const *)arg1)->operator >((kdb::Key const &)*arg2);
6757 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6758 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6759 0 : } catch (...) {
6760 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator >(kdb::Key const &) const");
6761 : }
6762 : }
6763 : resultobj = SWIG_From_bool(static_cast< bool >(result));
6764 : return resultobj;
6765 : fail:
6766 : return NULL;
6767 : }
6768 :
6769 :
6770 1 : SWIGINTERN PyObject *_wrap_Key___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6771 1 : PyObject *resultobj = 0;
6772 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6773 1 : kdb::Key *arg2 = 0 ;
6774 1 : void *argp1 = 0 ;
6775 1 : int res1 = 0 ;
6776 1 : void *argp2 = 0 ;
6777 1 : int res2 = 0 ;
6778 : PyObject *swig_obj[2] ;
6779 : bool result;
6780 :
6781 1 : if (!SWIG_Python_UnpackTuple(args,"Key___ge__",2,2,swig_obj)) SWIG_fail;
6782 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6783 1 : if (!SWIG_IsOK(res1)) {
6784 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___ge__" "', argument " "1"" of type '" "kdb::Key const *""'");
6785 : }
6786 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6787 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
6788 1 : if (!SWIG_IsOK(res2)) {
6789 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___ge__" "', argument " "2"" of type '" "kdb::Key const &""'");
6790 : }
6791 1 : if (!argp2) {
6792 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key___ge__" "', argument " "2"" of type '" "kdb::Key const &""'");
6793 : }
6794 1 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
6795 : {
6796 : try {
6797 1 : result = (bool)((kdb::Key const *)arg1)->operator >=((kdb::Key const &)*arg2);
6798 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6799 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6800 0 : } catch (...) {
6801 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator >=(kdb::Key const &) const");
6802 : }
6803 : }
6804 : resultobj = SWIG_From_bool(static_cast< bool >(result));
6805 : return resultobj;
6806 : fail:
6807 : return NULL;
6808 : }
6809 :
6810 :
6811 0 : SWIGINTERN PyObject *_wrap_Key_isNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6812 0 : PyObject *resultobj = 0;
6813 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6814 0 : void *argp1 = 0 ;
6815 0 : int res1 = 0 ;
6816 : PyObject *swig_obj[1] ;
6817 : bool result;
6818 :
6819 0 : if (!args) SWIG_fail;
6820 0 : swig_obj[0] = args;
6821 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6822 0 : if (!SWIG_IsOK(res1)) {
6823 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isNull" "', argument " "1"" of type '" "kdb::Key const *""'");
6824 : }
6825 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6826 : {
6827 : try {
6828 0 : result = (bool)((kdb::Key const *)arg1)->isNull();
6829 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6830 : SWIG_exception(SWIG_RuntimeError, e.what());
6831 : } catch (...) {
6832 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isNull() const");
6833 : }
6834 : }
6835 : resultobj = SWIG_From_bool(static_cast< bool >(result));
6836 : return resultobj;
6837 : fail:
6838 : return NULL;
6839 : }
6840 :
6841 :
6842 49 : SWIGINTERN PyObject *_wrap_Key___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6843 49 : PyObject *resultobj = 0;
6844 49 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6845 49 : void *argp1 = 0 ;
6846 49 : int res1 = 0 ;
6847 : PyObject *swig_obj[1] ;
6848 : bool result;
6849 :
6850 49 : if (!args) SWIG_fail;
6851 49 : swig_obj[0] = args;
6852 49 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6853 49 : if (!SWIG_IsOK(res1)) {
6854 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___nonzero__" "', argument " "1"" of type '" "kdb::Key const *""'");
6855 : }
6856 49 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6857 : {
6858 : try {
6859 49 : result = (bool)((kdb::Key const *)arg1)->operator bool();
6860 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6861 : SWIG_exception(SWIG_RuntimeError, e.what());
6862 : } catch (...) {
6863 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::operator bool() const");
6864 : }
6865 : }
6866 : resultobj = SWIG_From_bool(static_cast< bool >(result));
6867 : return resultobj;
6868 : fail:
6869 : return NULL;
6870 : }
6871 :
6872 :
6873 0 : SWIGINTERN PyObject *_wrap_Key_needSync(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6874 0 : PyObject *resultobj = 0;
6875 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6876 0 : void *argp1 = 0 ;
6877 0 : int res1 = 0 ;
6878 : PyObject *swig_obj[1] ;
6879 : bool result;
6880 :
6881 0 : if (!args) SWIG_fail;
6882 0 : swig_obj[0] = args;
6883 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6884 0 : if (!SWIG_IsOK(res1)) {
6885 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_needSync" "', argument " "1"" of type '" "kdb::Key const *""'");
6886 : }
6887 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6888 : {
6889 : try {
6890 0 : result = (bool)((kdb::Key const *)arg1)->needSync();
6891 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6892 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6893 0 : } catch (...) {
6894 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::needSync() const");
6895 : }
6896 : }
6897 : resultobj = SWIG_From_bool(static_cast< bool >(result));
6898 : return resultobj;
6899 : fail:
6900 : return NULL;
6901 : }
6902 :
6903 :
6904 7 : SWIGINTERN PyObject *_wrap_Key__getString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6905 7 : PyObject *resultobj = 0;
6906 7 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6907 7 : void *argp1 = 0 ;
6908 7 : int res1 = 0 ;
6909 : PyObject *swig_obj[1] ;
6910 14 : std::string result;
6911 :
6912 7 : if (!args) SWIG_fail;
6913 7 : swig_obj[0] = args;
6914 7 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6915 7 : if (!SWIG_IsOK(res1)) {
6916 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getString" "', argument " "1"" of type '" "kdb::Key const *""'");
6917 : }
6918 7 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6919 : {
6920 : try {
6921 14 : result = ((kdb::Key const *)arg1)->getString();
6922 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6923 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6924 0 : } catch (...) {
6925 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getString() const");
6926 : }
6927 : }
6928 21 : resultobj = SWIG_From_std_string(static_cast< std::string >(result));
6929 7 : return resultobj;
6930 : fail:
6931 : return NULL;
6932 : }
6933 :
6934 :
6935 10 : SWIGINTERN PyObject *_wrap_Key__setString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6936 10 : PyObject *resultobj = 0;
6937 10 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6938 20 : std::string arg2 ;
6939 10 : void *argp1 = 0 ;
6940 10 : int res1 = 0 ;
6941 : PyObject *swig_obj[2] ;
6942 :
6943 10 : if (!SWIG_Python_UnpackTuple(args,"Key__setString",2,2,swig_obj)) SWIG_fail;
6944 10 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6945 10 : if (!SWIG_IsOK(res1)) {
6946 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__setString" "', argument " "1"" of type '" "kdb::Key *""'");
6947 : }
6948 10 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6949 : {
6950 10 : std::string *ptr = (std::string *)0;
6951 10 : int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
6952 10 : if (!SWIG_IsOK(res) || !ptr) {
6953 0 : SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Key__setString" "', argument " "2"" of type '" "std::string""'");
6954 : }
6955 20 : arg2 = *ptr;
6956 20 : if (SWIG_IsNewObj(res)) delete ptr;
6957 : }
6958 : {
6959 : try {
6960 30 : (arg1)->setString(arg2);
6961 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6962 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6963 0 : } catch (...) {
6964 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setString(std::string)");
6965 : }
6966 : }
6967 10 : resultobj = SWIG_Py_Void();
6968 10 : return resultobj;
6969 : fail:
6970 : return NULL;
6971 : }
6972 :
6973 :
6974 0 : SWIGINTERN PyObject *_wrap_Key__getStringSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6975 0 : PyObject *resultobj = 0;
6976 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
6977 0 : void *argp1 = 0 ;
6978 0 : int res1 = 0 ;
6979 : PyObject *swig_obj[1] ;
6980 : ssize_t result;
6981 :
6982 0 : if (!args) SWIG_fail;
6983 0 : swig_obj[0] = args;
6984 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
6985 0 : if (!SWIG_IsOK(res1)) {
6986 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getStringSize" "', argument " "1"" of type '" "kdb::Key const *""'");
6987 : }
6988 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
6989 : {
6990 : try {
6991 0 : result = ((kdb::Key const *)arg1)->getStringSize();
6992 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
6993 0 : SWIG_exception(SWIG_RuntimeError, e.what());
6994 0 : } catch (...) {
6995 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getStringSize() const");
6996 : }
6997 : }
6998 0 : resultobj = SWIG_From_long(static_cast< long >(result));
6999 : return resultobj;
7000 : fail:
7001 : return NULL;
7002 : }
7003 :
7004 :
7005 0 : SWIGINTERN PyObject *_wrap_Key__getFunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7006 0 : PyObject *resultobj = 0;
7007 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7008 0 : void *argp1 = 0 ;
7009 0 : int res1 = 0 ;
7010 : PyObject *swig_obj[1] ;
7011 : kdb::Key::func_t result;
7012 :
7013 0 : if (!args) SWIG_fail;
7014 0 : swig_obj[0] = args;
7015 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7016 0 : if (!SWIG_IsOK(res1)) {
7017 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getFunc" "', argument " "1"" of type '" "kdb::Key const *""'");
7018 : }
7019 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7020 : {
7021 : try {
7022 0 : result = (kdb::Key::func_t)((kdb::Key const *)arg1)->getFunc();
7023 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7024 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7025 0 : } catch (...) {
7026 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getFunc() const");
7027 : }
7028 : }
7029 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f___void);
7030 : return resultobj;
7031 : fail:
7032 : return NULL;
7033 : }
7034 :
7035 :
7036 0 : SWIGINTERN PyObject *_wrap_Key_setCallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7037 0 : PyObject *resultobj = 0;
7038 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7039 0 : kdb::Key::callback_t arg2 = (kdb::Key::callback_t) 0 ;
7040 0 : void *argp1 = 0 ;
7041 0 : int res1 = 0 ;
7042 : PyObject *swig_obj[2] ;
7043 :
7044 0 : if (!SWIG_Python_UnpackTuple(args,"Key_setCallback",2,2,swig_obj)) SWIG_fail;
7045 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7046 0 : if (!SWIG_IsOK(res1)) {
7047 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_setCallback" "', argument " "1"" of type '" "kdb::Key *""'");
7048 : }
7049 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7050 : {
7051 0 : int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_p__KeySet_p__Key_p__Key_option_t__p__Key);
7052 0 : if (!SWIG_IsOK(res)) {
7053 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Key_setCallback" "', argument " "2"" of type '" "kdb::Key::callback_t""'");
7054 : }
7055 : }
7056 : {
7057 : try {
7058 0 : (arg1)->setCallback(arg2);
7059 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7060 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7061 0 : } catch (...) {
7062 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setCallback(kdb::Key::callback_t)");
7063 : }
7064 : }
7065 0 : resultobj = SWIG_Py_Void();
7066 0 : return resultobj;
7067 : fail:
7068 : return NULL;
7069 : }
7070 :
7071 :
7072 0 : SWIGINTERN PyObject *_wrap_Key__getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7073 0 : PyObject *resultobj = 0;
7074 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7075 0 : void *argp1 = 0 ;
7076 0 : int res1 = 0 ;
7077 : PyObject *swig_obj[1] ;
7078 0 : void *result = 0 ;
7079 :
7080 0 : if (!args) SWIG_fail;
7081 0 : swig_obj[0] = args;
7082 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7083 0 : if (!SWIG_IsOK(res1)) {
7084 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getValue" "', argument " "1"" of type '" "kdb::Key const *""'");
7085 : }
7086 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7087 : {
7088 : try {
7089 0 : result = (void *)((kdb::Key const *)arg1)->getValue();
7090 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7091 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7092 0 : } catch (...) {
7093 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getValue() const");
7094 : }
7095 : }
7096 : {
7097 0 : ssize_t size = arg1->getBinarySize();
7098 0 : resultobj = PyBytes_FromStringAndSize((const char*)result, (size > 0) ? size : 0);
7099 : }
7100 : return resultobj;
7101 : fail:
7102 : return NULL;
7103 : }
7104 :
7105 :
7106 2 : SWIGINTERN PyObject *_wrap_Key__getBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7107 2 : PyObject *resultobj = 0;
7108 2 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7109 2 : void *argp1 = 0 ;
7110 2 : int res1 = 0 ;
7111 : PyObject *swig_obj[1] ;
7112 4 : std::string result;
7113 :
7114 2 : if (!args) SWIG_fail;
7115 2 : swig_obj[0] = args;
7116 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7117 2 : if (!SWIG_IsOK(res1)) {
7118 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getBinary" "', argument " "1"" of type '" "kdb::Key const *""'");
7119 : }
7120 2 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7121 : {
7122 : try {
7123 4 : result = ((kdb::Key const *)arg1)->getBinary();
7124 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7125 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7126 0 : } catch (...) {
7127 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getBinary() const");
7128 : }
7129 : }
7130 : {
7131 4 : resultobj = PyBytes_FromStringAndSize((&result)->data(), (&result)->size());
7132 : }
7133 : return resultobj;
7134 : fail:
7135 : return NULL;
7136 : }
7137 :
7138 :
7139 0 : SWIGINTERN PyObject *_wrap_Key__getBinarySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7140 0 : PyObject *resultobj = 0;
7141 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7142 0 : void *argp1 = 0 ;
7143 0 : int res1 = 0 ;
7144 : PyObject *swig_obj[1] ;
7145 : ssize_t result;
7146 :
7147 0 : if (!args) SWIG_fail;
7148 0 : swig_obj[0] = args;
7149 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7150 0 : if (!SWIG_IsOK(res1)) {
7151 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getBinarySize" "', argument " "1"" of type '" "kdb::Key const *""'");
7152 : }
7153 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7154 : {
7155 : try {
7156 0 : result = ((kdb::Key const *)arg1)->getBinarySize();
7157 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7158 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7159 0 : } catch (...) {
7160 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getBinarySize() const");
7161 : }
7162 : }
7163 0 : resultobj = SWIG_From_long(static_cast< long >(result));
7164 : return resultobj;
7165 : fail:
7166 : return NULL;
7167 : }
7168 :
7169 :
7170 8 : SWIGINTERN PyObject *_wrap_Key__setBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7171 8 : PyObject *resultobj = 0;
7172 8 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7173 8 : void *arg2 = (void *) 0 ;
7174 : size_t arg3 ;
7175 8 : void *argp1 = 0 ;
7176 8 : int res1 = 0 ;
7177 : PyObject *swig_obj[2] ;
7178 : ssize_t result;
7179 :
7180 8 : if (!SWIG_Python_UnpackTuple(args,"Key__setBinary",2,2,swig_obj)) SWIG_fail;
7181 8 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7182 8 : if (!SWIG_IsOK(res1)) {
7183 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__setBinary" "', argument " "1"" of type '" "kdb::Key *""'");
7184 : }
7185 8 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7186 : {
7187 : Py_ssize_t len;
7188 8 : if (PyBytes_AsStringAndSize(swig_obj[1], reinterpret_cast<char **>(&arg2), &len) == -1)
7189 0 : return NULL;
7190 8 : arg3 = len;
7191 : }
7192 : {
7193 : try {
7194 16 : result = (arg1)->setBinary((void const *)arg2,arg3);
7195 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7196 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7197 0 : } catch (...) {
7198 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setBinary(void const *,size_t)");
7199 : }
7200 : }
7201 8 : resultobj = SWIG_From_long(static_cast< long >(result));
7202 : return resultobj;
7203 : fail:
7204 : return NULL;
7205 : }
7206 :
7207 :
7208 1 : SWIGINTERN PyObject *_wrap_Key_hasMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7209 1 : PyObject *resultobj = 0;
7210 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7211 1 : std::string *arg2 = 0 ;
7212 1 : void *argp1 = 0 ;
7213 1 : int res1 = 0 ;
7214 1 : int res2 = SWIG_OLDOBJ ;
7215 : PyObject *swig_obj[2] ;
7216 : bool result;
7217 :
7218 1 : if (!SWIG_Python_UnpackTuple(args,"Key_hasMeta",2,2,swig_obj)) SWIG_fail;
7219 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7220 1 : if (!SWIG_IsOK(res1)) {
7221 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_hasMeta" "', argument " "1"" of type '" "kdb::Key const *""'");
7222 : }
7223 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7224 : {
7225 1 : std::string *ptr = (std::string *)0;
7226 1 : res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
7227 1 : if (!SWIG_IsOK(res2)) {
7228 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_hasMeta" "', argument " "2"" of type '" "std::string const &""'");
7229 : }
7230 1 : if (!ptr) {
7231 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_hasMeta" "', argument " "2"" of type '" "std::string const &""'");
7232 : }
7233 1 : arg2 = ptr;
7234 : }
7235 : {
7236 : try {
7237 2 : result = (bool)((kdb::Key const *)arg1)->hasMeta((std::string const &)*arg2);
7238 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7239 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7240 0 : } catch (...) {
7241 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::hasMeta(std::string const &) const");
7242 : }
7243 : }
7244 1 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7245 2 : if (SWIG_IsNewObj(res2)) delete arg2;
7246 : return resultobj;
7247 : fail:
7248 0 : if (SWIG_IsNewObj(res2)) delete arg2;
7249 : return NULL;
7250 : }
7251 :
7252 :
7253 0 : SWIGINTERN PyObject *_wrap_Key_delMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7254 0 : PyObject *resultobj = 0;
7255 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7256 0 : std::string *arg2 = 0 ;
7257 0 : void *argp1 = 0 ;
7258 0 : int res1 = 0 ;
7259 0 : int res2 = SWIG_OLDOBJ ;
7260 : PyObject *swig_obj[2] ;
7261 :
7262 0 : if (!SWIG_Python_UnpackTuple(args,"Key_delMeta",2,2,swig_obj)) SWIG_fail;
7263 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7264 0 : if (!SWIG_IsOK(res1)) {
7265 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_delMeta" "', argument " "1"" of type '" "kdb::Key *""'");
7266 : }
7267 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7268 : {
7269 0 : std::string *ptr = (std::string *)0;
7270 0 : res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
7271 0 : if (!SWIG_IsOK(res2)) {
7272 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_delMeta" "', argument " "2"" of type '" "std::string const &""'");
7273 : }
7274 0 : if (!ptr) {
7275 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_delMeta" "', argument " "2"" of type '" "std::string const &""'");
7276 : }
7277 0 : arg2 = ptr;
7278 : }
7279 : {
7280 : try {
7281 0 : (arg1)->delMeta((std::string const &)*arg2);
7282 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7283 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7284 0 : } catch (...) {
7285 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::delMeta(std::string const &)");
7286 : }
7287 : }
7288 0 : resultobj = SWIG_Py_Void();
7289 0 : if (SWIG_IsNewObj(res2)) delete arg2;
7290 : return resultobj;
7291 : fail:
7292 0 : if (SWIG_IsNewObj(res2)) delete arg2;
7293 : return NULL;
7294 : }
7295 :
7296 :
7297 0 : SWIGINTERN PyObject *_wrap_Key_copyMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7298 0 : PyObject *resultobj = 0;
7299 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7300 0 : kdb::Key *arg2 = 0 ;
7301 0 : std::string *arg3 = 0 ;
7302 0 : void *argp1 = 0 ;
7303 0 : int res1 = 0 ;
7304 0 : void *argp2 = 0 ;
7305 0 : int res2 = 0 ;
7306 0 : int res3 = SWIG_OLDOBJ ;
7307 : PyObject *swig_obj[3] ;
7308 :
7309 0 : if (!SWIG_Python_UnpackTuple(args,"Key_copyMeta",3,3,swig_obj)) SWIG_fail;
7310 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7311 0 : if (!SWIG_IsOK(res1)) {
7312 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_copyMeta" "', argument " "1"" of type '" "kdb::Key *""'");
7313 : }
7314 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7315 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
7316 0 : if (!SWIG_IsOK(res2)) {
7317 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_copyMeta" "', argument " "2"" of type '" "kdb::Key const &""'");
7318 : }
7319 0 : if (!argp2) {
7320 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_copyMeta" "', argument " "2"" of type '" "kdb::Key const &""'");
7321 : }
7322 0 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
7323 : {
7324 0 : std::string *ptr = (std::string *)0;
7325 0 : res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
7326 0 : if (!SWIG_IsOK(res3)) {
7327 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Key_copyMeta" "', argument " "3"" of type '" "std::string const &""'");
7328 : }
7329 0 : if (!ptr) {
7330 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_copyMeta" "', argument " "3"" of type '" "std::string const &""'");
7331 : }
7332 0 : arg3 = ptr;
7333 : }
7334 : {
7335 : try {
7336 0 : (arg1)->copyMeta((kdb::Key const &)*arg2,(std::string const &)*arg3);
7337 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7338 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7339 0 : } catch (...) {
7340 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::copyMeta(kdb::Key const &,std::string const &)");
7341 : }
7342 : }
7343 0 : resultobj = SWIG_Py_Void();
7344 0 : if (SWIG_IsNewObj(res3)) delete arg3;
7345 : return resultobj;
7346 : fail:
7347 0 : if (SWIG_IsNewObj(res3)) delete arg3;
7348 : return NULL;
7349 : }
7350 :
7351 :
7352 0 : SWIGINTERN PyObject *_wrap_Key_copyAllMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7353 0 : PyObject *resultobj = 0;
7354 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7355 0 : kdb::Key *arg2 = 0 ;
7356 0 : void *argp1 = 0 ;
7357 0 : int res1 = 0 ;
7358 0 : void *argp2 = 0 ;
7359 0 : int res2 = 0 ;
7360 : PyObject *swig_obj[2] ;
7361 :
7362 0 : if (!SWIG_Python_UnpackTuple(args,"Key_copyAllMeta",2,2,swig_obj)) SWIG_fail;
7363 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7364 0 : if (!SWIG_IsOK(res1)) {
7365 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_copyAllMeta" "', argument " "1"" of type '" "kdb::Key *""'");
7366 : }
7367 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7368 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
7369 0 : if (!SWIG_IsOK(res2)) {
7370 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_copyAllMeta" "', argument " "2"" of type '" "kdb::Key const &""'");
7371 : }
7372 0 : if (!argp2) {
7373 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_copyAllMeta" "', argument " "2"" of type '" "kdb::Key const &""'");
7374 : }
7375 0 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
7376 : {
7377 : try {
7378 0 : (arg1)->copyAllMeta((kdb::Key const &)*arg2);
7379 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7380 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7381 0 : } catch (...) {
7382 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::copyAllMeta(kdb::Key const &)");
7383 : }
7384 : }
7385 0 : resultobj = SWIG_Py_Void();
7386 0 : return resultobj;
7387 : fail:
7388 : return NULL;
7389 : }
7390 :
7391 :
7392 2 : SWIGINTERN PyObject *_wrap_Key__rewindMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7393 2 : PyObject *resultobj = 0;
7394 2 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7395 2 : void *argp1 = 0 ;
7396 2 : int res1 = 0 ;
7397 : PyObject *swig_obj[1] ;
7398 :
7399 2 : if (!args) SWIG_fail;
7400 2 : swig_obj[0] = args;
7401 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7402 2 : if (!SWIG_IsOK(res1)) {
7403 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__rewindMeta" "', argument " "1"" of type '" "kdb::Key *""'");
7404 : }
7405 2 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7406 : {
7407 : try {
7408 2 : (arg1)->rewindMeta();
7409 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7410 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7411 0 : } catch (...) {
7412 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::rewindMeta()");
7413 : }
7414 : }
7415 2 : resultobj = SWIG_Py_Void();
7416 2 : return resultobj;
7417 : fail:
7418 : return NULL;
7419 : }
7420 :
7421 :
7422 5 : SWIGINTERN PyObject *_wrap_Key__nextMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7423 5 : PyObject *resultobj = 0;
7424 5 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7425 5 : void *argp1 = 0 ;
7426 5 : int res1 = 0 ;
7427 : PyObject *swig_obj[1] ;
7428 10 : kdb::Key result;
7429 :
7430 5 : if (!args) SWIG_fail;
7431 5 : swig_obj[0] = args;
7432 5 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7433 5 : if (!SWIG_IsOK(res1)) {
7434 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__nextMeta" "', argument " "1"" of type '" "kdb::Key *""'");
7435 : }
7436 5 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7437 : {
7438 : try {
7439 15 : result = (arg1)->nextMeta();
7440 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7441 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7442 0 : } catch (...) {
7443 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::nextMeta()");
7444 : }
7445 : }
7446 10 : resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN | 0 );
7447 : return resultobj;
7448 : fail:
7449 : return NULL;
7450 : }
7451 :
7452 :
7453 0 : SWIGINTERN PyObject *_wrap_Key__currentMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7454 0 : PyObject *resultobj = 0;
7455 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7456 0 : void *argp1 = 0 ;
7457 0 : int res1 = 0 ;
7458 : PyObject *swig_obj[1] ;
7459 0 : kdb::Key result;
7460 :
7461 0 : if (!args) SWIG_fail;
7462 0 : swig_obj[0] = args;
7463 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7464 0 : if (!SWIG_IsOK(res1)) {
7465 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__currentMeta" "', argument " "1"" of type '" "kdb::Key const *""'");
7466 : }
7467 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7468 : {
7469 : try {
7470 0 : result = ((kdb::Key const *)arg1)->currentMeta();
7471 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7472 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7473 0 : } catch (...) {
7474 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::currentMeta() const");
7475 : }
7476 : }
7477 0 : resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN | 0 );
7478 : return resultobj;
7479 : fail:
7480 : return NULL;
7481 : }
7482 :
7483 :
7484 11 : SWIGINTERN PyObject *_wrap_Key_isValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7485 11 : PyObject *resultobj = 0;
7486 11 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7487 11 : void *argp1 = 0 ;
7488 11 : int res1 = 0 ;
7489 : PyObject *swig_obj[1] ;
7490 : bool result;
7491 :
7492 11 : if (!args) SWIG_fail;
7493 11 : swig_obj[0] = args;
7494 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7495 11 : if (!SWIG_IsOK(res1)) {
7496 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isValid" "', argument " "1"" of type '" "kdb::Key const *""'");
7497 : }
7498 11 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7499 : {
7500 : try {
7501 11 : result = (bool)((kdb::Key const *)arg1)->isValid();
7502 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7503 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7504 0 : } catch (...) {
7505 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isValid() const");
7506 : }
7507 : }
7508 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7509 : return resultobj;
7510 : fail:
7511 : return NULL;
7512 : }
7513 :
7514 :
7515 0 : SWIGINTERN PyObject *_wrap_Key_getNamespace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7516 0 : PyObject *resultobj = 0;
7517 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7518 0 : void *argp1 = 0 ;
7519 0 : int res1 = 0 ;
7520 : PyObject *swig_obj[1] ;
7521 0 : std::string result;
7522 :
7523 0 : if (!args) SWIG_fail;
7524 0 : swig_obj[0] = args;
7525 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7526 0 : if (!SWIG_IsOK(res1)) {
7527 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_getNamespace" "', argument " "1"" of type '" "kdb::Key const *""'");
7528 : }
7529 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7530 : {
7531 : try {
7532 0 : result = ((kdb::Key const *)arg1)->getNamespace();
7533 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7534 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7535 0 : } catch (...) {
7536 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getNamespace() const");
7537 : }
7538 : }
7539 0 : resultobj = SWIG_From_std_string(static_cast< std::string >(result));
7540 0 : return resultobj;
7541 : fail:
7542 : return NULL;
7543 : }
7544 :
7545 :
7546 0 : SWIGINTERN PyObject *_wrap_Key_isCascading(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7547 0 : PyObject *resultobj = 0;
7548 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7549 0 : void *argp1 = 0 ;
7550 0 : int res1 = 0 ;
7551 : PyObject *swig_obj[1] ;
7552 : bool result;
7553 :
7554 0 : if (!args) SWIG_fail;
7555 0 : swig_obj[0] = args;
7556 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7557 0 : if (!SWIG_IsOK(res1)) {
7558 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isCascading" "', argument " "1"" of type '" "kdb::Key const *""'");
7559 : }
7560 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7561 : {
7562 : try {
7563 0 : result = (bool)((kdb::Key const *)arg1)->isCascading();
7564 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7565 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7566 0 : } catch (...) {
7567 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isCascading() const");
7568 : }
7569 : }
7570 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7571 : return resultobj;
7572 : fail:
7573 : return NULL;
7574 : }
7575 :
7576 :
7577 0 : SWIGINTERN PyObject *_wrap_Key_isSpec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7578 0 : PyObject *resultobj = 0;
7579 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7580 0 : void *argp1 = 0 ;
7581 0 : int res1 = 0 ;
7582 : PyObject *swig_obj[1] ;
7583 : bool result;
7584 :
7585 0 : if (!args) SWIG_fail;
7586 0 : swig_obj[0] = args;
7587 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7588 0 : if (!SWIG_IsOK(res1)) {
7589 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isSpec" "', argument " "1"" of type '" "kdb::Key const *""'");
7590 : }
7591 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7592 : {
7593 : try {
7594 0 : result = (bool)((kdb::Key const *)arg1)->isSpec();
7595 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7596 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7597 0 : } catch (...) {
7598 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isSpec() const");
7599 : }
7600 : }
7601 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7602 : return resultobj;
7603 : fail:
7604 : return NULL;
7605 : }
7606 :
7607 :
7608 0 : SWIGINTERN PyObject *_wrap_Key_isProc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7609 0 : PyObject *resultobj = 0;
7610 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7611 0 : void *argp1 = 0 ;
7612 0 : int res1 = 0 ;
7613 : PyObject *swig_obj[1] ;
7614 : bool result;
7615 :
7616 0 : if (!args) SWIG_fail;
7617 0 : swig_obj[0] = args;
7618 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7619 0 : if (!SWIG_IsOK(res1)) {
7620 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isProc" "', argument " "1"" of type '" "kdb::Key const *""'");
7621 : }
7622 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7623 : {
7624 : try {
7625 0 : result = (bool)((kdb::Key const *)arg1)->isProc();
7626 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7627 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7628 0 : } catch (...) {
7629 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isProc() const");
7630 : }
7631 : }
7632 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7633 : return resultobj;
7634 : fail:
7635 : return NULL;
7636 : }
7637 :
7638 :
7639 0 : SWIGINTERN PyObject *_wrap_Key_isDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7640 0 : PyObject *resultobj = 0;
7641 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7642 0 : void *argp1 = 0 ;
7643 0 : int res1 = 0 ;
7644 : PyObject *swig_obj[1] ;
7645 : bool result;
7646 :
7647 0 : if (!args) SWIG_fail;
7648 0 : swig_obj[0] = args;
7649 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7650 0 : if (!SWIG_IsOK(res1)) {
7651 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isDir" "', argument " "1"" of type '" "kdb::Key const *""'");
7652 : }
7653 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7654 : {
7655 : try {
7656 0 : result = (bool)((kdb::Key const *)arg1)->isDir();
7657 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7658 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7659 0 : } catch (...) {
7660 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isDir() const");
7661 : }
7662 : }
7663 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7664 : return resultobj;
7665 : fail:
7666 : return NULL;
7667 : }
7668 :
7669 :
7670 1 : SWIGINTERN PyObject *_wrap_Key_isUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7671 1 : PyObject *resultobj = 0;
7672 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7673 1 : void *argp1 = 0 ;
7674 1 : int res1 = 0 ;
7675 : PyObject *swig_obj[1] ;
7676 : bool result;
7677 :
7678 1 : if (!args) SWIG_fail;
7679 1 : swig_obj[0] = args;
7680 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7681 1 : if (!SWIG_IsOK(res1)) {
7682 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isUser" "', argument " "1"" of type '" "kdb::Key const *""'");
7683 : }
7684 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7685 : {
7686 : try {
7687 1 : result = (bool)((kdb::Key const *)arg1)->isUser();
7688 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7689 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7690 0 : } catch (...) {
7691 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isUser() const");
7692 : }
7693 : }
7694 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7695 : return resultobj;
7696 : fail:
7697 : return NULL;
7698 : }
7699 :
7700 :
7701 1 : SWIGINTERN PyObject *_wrap_Key_isSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7702 1 : PyObject *resultobj = 0;
7703 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7704 1 : void *argp1 = 0 ;
7705 1 : int res1 = 0 ;
7706 : PyObject *swig_obj[1] ;
7707 : bool result;
7708 :
7709 1 : if (!args) SWIG_fail;
7710 1 : swig_obj[0] = args;
7711 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7712 1 : if (!SWIG_IsOK(res1)) {
7713 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isSystem" "', argument " "1"" of type '" "kdb::Key const *""'");
7714 : }
7715 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7716 : {
7717 : try {
7718 1 : result = (bool)((kdb::Key const *)arg1)->isSystem();
7719 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7720 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7721 0 : } catch (...) {
7722 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isSystem() const");
7723 : }
7724 : }
7725 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7726 : return resultobj;
7727 : fail:
7728 : return NULL;
7729 : }
7730 :
7731 :
7732 1 : SWIGINTERN PyObject *_wrap_Key_isString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7733 1 : PyObject *resultobj = 0;
7734 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7735 1 : void *argp1 = 0 ;
7736 1 : int res1 = 0 ;
7737 : PyObject *swig_obj[1] ;
7738 : bool result;
7739 :
7740 1 : if (!args) SWIG_fail;
7741 1 : swig_obj[0] = args;
7742 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7743 1 : if (!SWIG_IsOK(res1)) {
7744 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isString" "', argument " "1"" of type '" "kdb::Key const *""'");
7745 : }
7746 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7747 : {
7748 : try {
7749 1 : result = (bool)((kdb::Key const *)arg1)->isString();
7750 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7751 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7752 0 : } catch (...) {
7753 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isString() const");
7754 : }
7755 : }
7756 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7757 : return resultobj;
7758 : fail:
7759 : return NULL;
7760 : }
7761 :
7762 :
7763 28 : SWIGINTERN PyObject *_wrap_Key_isBinary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7764 28 : PyObject *resultobj = 0;
7765 28 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7766 28 : void *argp1 = 0 ;
7767 28 : int res1 = 0 ;
7768 : PyObject *swig_obj[1] ;
7769 : bool result;
7770 :
7771 28 : if (!args) SWIG_fail;
7772 28 : swig_obj[0] = args;
7773 28 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7774 28 : if (!SWIG_IsOK(res1)) {
7775 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isBinary" "', argument " "1"" of type '" "kdb::Key const *""'");
7776 : }
7777 28 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7778 : {
7779 : try {
7780 28 : result = (bool)((kdb::Key const *)arg1)->isBinary();
7781 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7782 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7783 0 : } catch (...) {
7784 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isBinary() const");
7785 : }
7786 : }
7787 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7788 : return resultobj;
7789 : fail:
7790 : return NULL;
7791 : }
7792 :
7793 :
7794 0 : SWIGINTERN PyObject *_wrap_Key_isInactive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7795 0 : PyObject *resultobj = 0;
7796 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7797 0 : void *argp1 = 0 ;
7798 0 : int res1 = 0 ;
7799 : PyObject *swig_obj[1] ;
7800 : bool result;
7801 :
7802 0 : if (!args) SWIG_fail;
7803 0 : swig_obj[0] = args;
7804 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7805 0 : if (!SWIG_IsOK(res1)) {
7806 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isInactive" "', argument " "1"" of type '" "kdb::Key const *""'");
7807 : }
7808 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7809 : {
7810 : try {
7811 0 : result = (bool)((kdb::Key const *)arg1)->isInactive();
7812 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7813 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7814 0 : } catch (...) {
7815 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isInactive() const");
7816 : }
7817 : }
7818 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7819 : return resultobj;
7820 : fail:
7821 : return NULL;
7822 : }
7823 :
7824 :
7825 1 : SWIGINTERN PyObject *_wrap_Key_isBelow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7826 1 : PyObject *resultobj = 0;
7827 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7828 1 : kdb::Key *arg2 = 0 ;
7829 1 : void *argp1 = 0 ;
7830 1 : int res1 = 0 ;
7831 1 : void *argp2 = 0 ;
7832 1 : int res2 = 0 ;
7833 : PyObject *swig_obj[2] ;
7834 : bool result;
7835 :
7836 1 : if (!SWIG_Python_UnpackTuple(args,"Key_isBelow",2,2,swig_obj)) SWIG_fail;
7837 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7838 1 : if (!SWIG_IsOK(res1)) {
7839 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isBelow" "', argument " "1"" of type '" "kdb::Key const *""'");
7840 : }
7841 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7842 1 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
7843 1 : if (!SWIG_IsOK(res2)) {
7844 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_isBelow" "', argument " "2"" of type '" "kdb::Key const &""'");
7845 : }
7846 1 : if (!argp2) {
7847 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_isBelow" "', argument " "2"" of type '" "kdb::Key const &""'");
7848 : }
7849 1 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
7850 : {
7851 : try {
7852 1 : result = (bool)((kdb::Key const *)arg1)->isBelow((kdb::Key const &)*arg2);
7853 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7854 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7855 0 : } catch (...) {
7856 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isBelow(kdb::Key const &) const");
7857 : }
7858 : }
7859 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7860 : return resultobj;
7861 : fail:
7862 : return NULL;
7863 : }
7864 :
7865 :
7866 0 : SWIGINTERN PyObject *_wrap_Key_isBelowOrSame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7867 0 : PyObject *resultobj = 0;
7868 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7869 0 : kdb::Key *arg2 = 0 ;
7870 0 : void *argp1 = 0 ;
7871 0 : int res1 = 0 ;
7872 0 : void *argp2 = 0 ;
7873 0 : int res2 = 0 ;
7874 : PyObject *swig_obj[2] ;
7875 : bool result;
7876 :
7877 0 : if (!SWIG_Python_UnpackTuple(args,"Key_isBelowOrSame",2,2,swig_obj)) SWIG_fail;
7878 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7879 0 : if (!SWIG_IsOK(res1)) {
7880 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isBelowOrSame" "', argument " "1"" of type '" "kdb::Key const *""'");
7881 : }
7882 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7883 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
7884 0 : if (!SWIG_IsOK(res2)) {
7885 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_isBelowOrSame" "', argument " "2"" of type '" "kdb::Key const &""'");
7886 : }
7887 0 : if (!argp2) {
7888 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_isBelowOrSame" "', argument " "2"" of type '" "kdb::Key const &""'");
7889 : }
7890 0 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
7891 : {
7892 : try {
7893 0 : result = (bool)((kdb::Key const *)arg1)->isBelowOrSame((kdb::Key const &)*arg2);
7894 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7895 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7896 0 : } catch (...) {
7897 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isBelowOrSame(kdb::Key const &) const");
7898 : }
7899 : }
7900 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7901 : return resultobj;
7902 : fail:
7903 : return NULL;
7904 : }
7905 :
7906 :
7907 0 : SWIGINTERN PyObject *_wrap_Key_isDirectBelow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7908 0 : PyObject *resultobj = 0;
7909 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
7910 0 : kdb::Key *arg2 = 0 ;
7911 0 : void *argp1 = 0 ;
7912 0 : int res1 = 0 ;
7913 0 : void *argp2 = 0 ;
7914 0 : int res2 = 0 ;
7915 : PyObject *swig_obj[2] ;
7916 : bool result;
7917 :
7918 0 : if (!SWIG_Python_UnpackTuple(args,"Key_isDirectBelow",2,2,swig_obj)) SWIG_fail;
7919 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
7920 0 : if (!SWIG_IsOK(res1)) {
7921 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key_isDirectBelow" "', argument " "1"" of type '" "kdb::Key const *""'");
7922 : }
7923 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
7924 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
7925 0 : if (!SWIG_IsOK(res2)) {
7926 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key_isDirectBelow" "', argument " "2"" of type '" "kdb::Key const &""'");
7927 : }
7928 0 : if (!argp2) {
7929 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key_isDirectBelow" "', argument " "2"" of type '" "kdb::Key const &""'");
7930 : }
7931 0 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
7932 : {
7933 : try {
7934 0 : result = (bool)((kdb::Key const *)arg1)->isDirectBelow((kdb::Key const &)*arg2);
7935 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7936 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7937 0 : } catch (...) {
7938 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::isDirectBelow(kdb::Key const &) const");
7939 : }
7940 : }
7941 : resultobj = SWIG_From_bool(static_cast< bool >(result));
7942 : return resultobj;
7943 : fail:
7944 : return NULL;
7945 : }
7946 :
7947 :
7948 106 : SWIGINTERN PyObject *_wrap_new_Key__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7949 106 : PyObject *resultobj = 0;
7950 106 : char *arg1 = (char *) 0 ;
7951 : int arg2 ;
7952 : int res1 ;
7953 106 : char *buf1 = 0 ;
7954 106 : int alloc1 = 0 ;
7955 : int val2 ;
7956 106 : int ecode2 = 0 ;
7957 106 : kdb::Key *result = 0 ;
7958 :
7959 106 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
7960 106 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
7961 106 : if (!SWIG_IsOK(res1)) {
7962 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Key" "', argument " "1"" of type '" "char const *""'");
7963 : }
7964 106 : arg1 = reinterpret_cast< char * >(buf1);
7965 212 : ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7966 106 : if (!SWIG_IsOK(ecode2)) {
7967 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Key" "', argument " "2"" of type '" "int""'");
7968 : }
7969 106 : arg2 = static_cast< int >(val2);
7970 : {
7971 : try {
7972 106 : result = (kdb::Key *)new_kdb_Key__SWIG_3((char const *)arg1,arg2);
7973 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
7974 0 : SWIG_exception(SWIG_RuntimeError, e.what());
7975 0 : } catch (...) {
7976 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::Key(char const *,int)");
7977 : }
7978 : }
7979 106 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, SWIG_POINTER_NEW | 0 );
7980 106 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
7981 : return resultobj;
7982 : fail:
7983 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
7984 : return NULL;
7985 : }
7986 :
7987 :
7988 0 : SWIGINTERN PyObject *_wrap_new_Key__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
7989 0 : PyObject *resultobj = 0;
7990 0 : char *arg1 = (char *) 0 ;
7991 : int res1 ;
7992 0 : char *buf1 = 0 ;
7993 0 : int alloc1 = 0 ;
7994 0 : kdb::Key *result = 0 ;
7995 :
7996 0 : if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
7997 0 : res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
7998 0 : if (!SWIG_IsOK(res1)) {
7999 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Key" "', argument " "1"" of type '" "char const *""'");
8000 : }
8001 0 : arg1 = reinterpret_cast< char * >(buf1);
8002 : {
8003 : try {
8004 0 : result = (kdb::Key *)new_kdb_Key__SWIG_3((char const *)arg1);
8005 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
8006 0 : SWIG_exception(SWIG_RuntimeError, e.what());
8007 0 : } catch (...) {
8008 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::Key(char const *)");
8009 : }
8010 : }
8011 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, SWIG_POINTER_NEW | 0 );
8012 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
8013 : return resultobj;
8014 : fail:
8015 0 : if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
8016 : return NULL;
8017 : }
8018 :
8019 :
8020 117 : SWIGINTERN PyObject *_wrap_new_Key(PyObject *self, PyObject *args) {
8021 : Py_ssize_t argc;
8022 : PyObject *argv[3] = {
8023 : 0
8024 117 : };
8025 :
8026 117 : if (!(argc = SWIG_Python_UnpackTuple(args,"new_Key",0,2,argv))) SWIG_fail;
8027 117 : --argc;
8028 117 : if (argc == 0) {
8029 8 : return _wrap_new_Key__SWIG_0(self, argc, argv);
8030 : }
8031 109 : if (argc == 1) {
8032 3 : int _v = 0;
8033 : {
8034 3 : void *vptr = 0;
8035 3 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__Key, 0);
8036 3 : _v = SWIG_CheckState(res);
8037 : }
8038 3 : if (!_v) goto check_2;
8039 1 : return _wrap_new_Key__SWIG_1(self, argc, argv);
8040 : }
8041 : check_2:
8042 :
8043 108 : if (argc == 1) {
8044 2 : int _v = 0;
8045 : {
8046 2 : void *vptr = 0;
8047 2 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_kdb__Key, 0);
8048 2 : _v = SWIG_CheckState(res);
8049 : }
8050 2 : if (!_v) goto check_3;
8051 2 : return _wrap_new_Key__SWIG_2(self, argc, argv);
8052 : }
8053 : check_3:
8054 :
8055 106 : if (argc == 1) {
8056 0 : return _wrap_new_Key__SWIG_4(self, argc, argv);
8057 : }
8058 106 : if (argc == 2) {
8059 106 : return _wrap_new_Key__SWIG_3(self, argc, argv);
8060 : }
8061 :
8062 : fail:
8063 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Key'.\n"
8064 : " Possible C/C++ prototypes are:\n"
8065 : " kdb::Key::Key()\n"
8066 : " kdb::Key::Key(ckdb::Key *)\n"
8067 : " kdb::Key::Key(kdb::Key &)\n"
8068 : " kdb::Key::Key(char const *,int)\n"
8069 0 : " kdb::Key::Key(char const *)\n");
8070 : return 0;
8071 : }
8072 :
8073 :
8074 0 : SWIGINTERN PyObject *_wrap_Key___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8075 0 : PyObject *resultobj = 0;
8076 0 : kdb::Key *arg1 = (kdb::Key *) 0 ;
8077 0 : kdb::Key *arg2 = (kdb::Key *) 0 ;
8078 0 : void *argp1 = 0 ;
8079 0 : int res1 = 0 ;
8080 0 : void *argp2 = 0 ;
8081 0 : int res2 = 0 ;
8082 : PyObject *swig_obj[2] ;
8083 : int result;
8084 :
8085 0 : if (!SWIG_Python_UnpackTuple(args,"Key___cmp__",2,2,swig_obj)) SWIG_fail;
8086 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
8087 0 : if (!SWIG_IsOK(res1)) {
8088 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___cmp__" "', argument " "1"" of type '" "kdb::Key *""'");
8089 : }
8090 0 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
8091 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_kdb__Key, 0 | 0 );
8092 0 : if (!SWIG_IsOK(res2)) {
8093 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key___cmp__" "', argument " "2"" of type '" "kdb::Key const *""'");
8094 : }
8095 0 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
8096 : {
8097 : try {
8098 0 : result = (int)kdb_Key___cmp__(arg1,(kdb::Key const *)arg2);
8099 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
8100 0 : SWIG_exception(SWIG_RuntimeError, e.what());
8101 0 : } catch (...) {
8102 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::__cmp__(kdb::Key const *)");
8103 : }
8104 : }
8105 : resultobj = SWIG_From_int(static_cast< int >(result));
8106 : return resultobj;
8107 : fail:
8108 : return NULL;
8109 : }
8110 :
8111 :
8112 1 : SWIGINTERN PyObject *_wrap_Key___copy__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8113 1 : PyObject *resultobj = 0;
8114 1 : kdb::Key *arg1 = (kdb::Key *) 0 ;
8115 1 : void *argp1 = 0 ;
8116 1 : int res1 = 0 ;
8117 : PyObject *swig_obj[1] ;
8118 1 : kdb::Key *result = 0 ;
8119 :
8120 1 : if (!args) SWIG_fail;
8121 1 : swig_obj[0] = args;
8122 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
8123 1 : if (!SWIG_IsOK(res1)) {
8124 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___copy__" "', argument " "1"" of type '" "kdb::Key *""'");
8125 : }
8126 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
8127 : {
8128 : try {
8129 1 : result = (kdb::Key *)kdb_Key___copy__(arg1);
8130 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
8131 0 : SWIG_exception(SWIG_RuntimeError, e.what());
8132 0 : } catch (...) {
8133 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::__copy__()");
8134 : }
8135 : }
8136 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__Key, 0 | 0 );
8137 : return resultobj;
8138 : fail:
8139 : return NULL;
8140 : }
8141 :
8142 :
8143 2 : SWIGINTERN PyObject *_wrap_Key___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8144 2 : PyObject *resultobj = 0;
8145 2 : kdb::Key *arg1 = (kdb::Key *) 0 ;
8146 2 : PyObject **arg2 = (PyObject **) 0 ;
8147 2 : void *argp1 = 0 ;
8148 2 : int res1 = 0 ;
8149 : PyObject *swig_obj[1] ;
8150 2 : swig::SwigPyIterator *result = 0 ;
8151 :
8152 2 : arg2 = &swig_obj[0];
8153 2 : if (!args) SWIG_fail;
8154 2 : swig_obj[0] = args;
8155 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
8156 2 : if (!SWIG_IsOK(res1)) {
8157 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___iter__" "', argument " "1"" of type '" "kdb::Key *""'");
8158 : }
8159 2 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
8160 : {
8161 : try {
8162 2 : result = (swig::SwigPyIterator *)kdb_Key___iter__(arg1,arg2);
8163 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
8164 0 : SWIG_exception(SWIG_RuntimeError, e.what());
8165 0 : } catch (...) {
8166 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::__iter__(PyObject **)");
8167 : }
8168 : }
8169 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
8170 : return resultobj;
8171 : fail:
8172 : return NULL;
8173 : }
8174 :
8175 :
8176 2 : SWIGINTERN PyObject *_wrap_Key___reversed__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8177 2 : PyObject *resultobj = 0;
8178 2 : kdb::Key *arg1 = (kdb::Key *) 0 ;
8179 2 : PyObject **arg2 = (PyObject **) 0 ;
8180 2 : void *argp1 = 0 ;
8181 2 : int res1 = 0 ;
8182 : PyObject *swig_obj[1] ;
8183 2 : swig::SwigPyIterator *result = 0 ;
8184 :
8185 2 : arg2 = &swig_obj[0];
8186 2 : if (!args) SWIG_fail;
8187 2 : swig_obj[0] = args;
8188 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
8189 2 : if (!SWIG_IsOK(res1)) {
8190 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key___reversed__" "', argument " "1"" of type '" "kdb::Key *""'");
8191 : }
8192 2 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
8193 : {
8194 : try {
8195 2 : result = (swig::SwigPyIterator *)kdb_Key___reversed__(arg1,arg2);
8196 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
8197 0 : SWIG_exception(SWIG_RuntimeError, e.what());
8198 0 : } catch (...) {
8199 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::__reversed__(PyObject **)");
8200 : }
8201 : }
8202 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
8203 : return resultobj;
8204 : fail:
8205 : return NULL;
8206 : }
8207 :
8208 :
8209 10 : SWIGINTERN PyObject *_wrap_Key__getMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8210 10 : PyObject *resultobj = 0;
8211 10 : kdb::Key *arg1 = (kdb::Key *) 0 ;
8212 10 : std::string *arg2 = 0 ;
8213 10 : void *argp1 = 0 ;
8214 10 : int res1 = 0 ;
8215 10 : int res2 = SWIG_OLDOBJ ;
8216 : PyObject *swig_obj[2] ;
8217 20 : kdb::Key result;
8218 :
8219 10 : if (!SWIG_Python_UnpackTuple(args,"Key__getMeta",2,2,swig_obj)) SWIG_fail;
8220 10 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
8221 10 : if (!SWIG_IsOK(res1)) {
8222 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__getMeta" "', argument " "1"" of type '" "kdb::Key const *""'");
8223 : }
8224 10 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
8225 : {
8226 10 : std::string *ptr = (std::string *)0;
8227 10 : res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
8228 10 : if (!SWIG_IsOK(res2)) {
8229 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key__getMeta" "', argument " "2"" of type '" "std::string const &""'");
8230 : }
8231 10 : if (!ptr) {
8232 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key__getMeta" "', argument " "2"" of type '" "std::string const &""'");
8233 : }
8234 10 : arg2 = ptr;
8235 : }
8236 : {
8237 : try {
8238 30 : result = ((kdb::Key const *)arg1)->SWIGTEMPLATEDISAMBIGUATOR getMeta< kdb::Key const >((std::string const &)*arg2);
8239 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
8240 0 : SWIG_exception(SWIG_RuntimeError, e.what());
8241 0 : } catch (...) {
8242 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::getMeta< kdb::Key const >(std::string const &) const");
8243 : }
8244 : }
8245 20 : resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN | 0 );
8246 20 : if (SWIG_IsNewObj(res2)) delete arg2;
8247 : return resultobj;
8248 : fail:
8249 0 : if (SWIG_IsNewObj(res2)) delete arg2;
8250 : return NULL;
8251 : }
8252 :
8253 :
8254 16 : SWIGINTERN PyObject *_wrap_Key__setMeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8255 16 : PyObject *resultobj = 0;
8256 16 : kdb::Key *arg1 = (kdb::Key *) 0 ;
8257 16 : std::string *arg2 = 0 ;
8258 32 : std::string arg3 ;
8259 16 : void *argp1 = 0 ;
8260 16 : int res1 = 0 ;
8261 16 : int res2 = SWIG_OLDOBJ ;
8262 : PyObject *swig_obj[3] ;
8263 :
8264 16 : if (!SWIG_Python_UnpackTuple(args,"Key__setMeta",3,3,swig_obj)) SWIG_fail;
8265 16 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__Key, 0 | 0 );
8266 16 : if (!SWIG_IsOK(res1)) {
8267 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Key__setMeta" "', argument " "1"" of type '" "kdb::Key *""'");
8268 : }
8269 16 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
8270 : {
8271 16 : std::string *ptr = (std::string *)0;
8272 16 : res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
8273 16 : if (!SWIG_IsOK(res2)) {
8274 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Key__setMeta" "', argument " "2"" of type '" "std::string const &""'");
8275 : }
8276 16 : if (!ptr) {
8277 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Key__setMeta" "', argument " "2"" of type '" "std::string const &""'");
8278 : }
8279 16 : arg2 = ptr;
8280 : }
8281 : {
8282 16 : std::string *ptr = (std::string *)0;
8283 32 : int res = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
8284 16 : if (!SWIG_IsOK(res) || !ptr) {
8285 0 : SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Key__setMeta" "', argument " "3"" of type '" "std::string""'");
8286 : }
8287 32 : arg3 = *ptr;
8288 32 : if (SWIG_IsNewObj(res)) delete ptr;
8289 : }
8290 : {
8291 : try {
8292 32 : (arg1)->SWIGTEMPLATEDISAMBIGUATOR setMeta< std::string >((std::string const &)*arg2,arg3);
8293 0 : } KEY_EXCEPTIONS catch (const std::exception & e) {
8294 0 : SWIG_exception(SWIG_RuntimeError, e.what());
8295 0 : } catch (...) {
8296 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::Key::setMeta< std::string >(std::string const &,std::string)");
8297 : }
8298 : }
8299 16 : resultobj = SWIG_Py_Void();
8300 32 : if (SWIG_IsNewObj(res2)) delete arg2;
8301 : return resultobj;
8302 : fail:
8303 0 : if (SWIG_IsNewObj(res2)) delete arg2;
8304 : return NULL;
8305 : }
8306 :
8307 :
8308 3 : SWIGINTERN PyObject *Key_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8309 : PyObject *obj;
8310 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8311 6 : SWIG_TypeNewClientData(SWIGTYPE_p_kdb__Key, SWIG_NewClientData(obj));
8312 3 : return SWIG_Py_Void();
8313 : }
8314 :
8315 117 : SWIGINTERN PyObject *Key_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8316 117 : return SWIG_Python_InitShadowInstance(args);
8317 : }
8318 :
8319 1 : SWIGINTERN PyObject *_wrap_new_KeySet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
8320 1 : PyObject *resultobj = 0;
8321 1 : kdb::KeySet *result = 0 ;
8322 :
8323 1 : if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
8324 2 : result = (kdb::KeySet *)new kdb::KeySet();
8325 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_NEW | 0 );
8326 : return resultobj;
8327 : fail:
8328 : return NULL;
8329 : }
8330 :
8331 :
8332 1 : SWIGINTERN PyObject *_wrap_new_KeySet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
8333 1 : PyObject *resultobj = 0;
8334 1 : ckdb::KeySet *arg1 = (ckdb::KeySet *) 0 ;
8335 1 : void *argp1 = 0 ;
8336 1 : int res1 = 0 ;
8337 1 : kdb::KeySet *result = 0 ;
8338 :
8339 1 : if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
8340 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__KeySet, 0 | 0 );
8341 1 : if (!SWIG_IsOK(res1)) {
8342 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KeySet" "', argument " "1"" of type '" "ckdb::KeySet *""'");
8343 : }
8344 1 : arg1 = reinterpret_cast< ckdb::KeySet * >(argp1);
8345 2 : result = (kdb::KeySet *)new kdb::KeySet(arg1);
8346 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_NEW | 0 );
8347 : return resultobj;
8348 : fail:
8349 : return NULL;
8350 : }
8351 :
8352 :
8353 1 : SWIGINTERN PyObject *_wrap_new_KeySet__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
8354 1 : PyObject *resultobj = 0;
8355 1 : kdb::KeySet *arg1 = 0 ;
8356 1 : void *argp1 = 0 ;
8357 1 : int res1 = 0 ;
8358 1 : kdb::KeySet *result = 0 ;
8359 :
8360 1 : if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
8361 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_kdb__KeySet, 0 | 0);
8362 1 : if (!SWIG_IsOK(res1)) {
8363 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KeySet" "', argument " "1"" of type '" "kdb::KeySet const &""'");
8364 : }
8365 1 : if (!argp1) {
8366 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KeySet" "', argument " "1"" of type '" "kdb::KeySet const &""'");
8367 : }
8368 1 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8369 2 : result = (kdb::KeySet *)new kdb::KeySet((kdb::KeySet const &)*arg1);
8370 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_NEW | 0 );
8371 : return resultobj;
8372 : fail:
8373 : return NULL;
8374 : }
8375 :
8376 :
8377 19 : SWIGINTERN PyObject *_wrap_delete_KeySet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8378 19 : PyObject *resultobj = 0;
8379 19 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8380 19 : void *argp1 = 0 ;
8381 19 : int res1 = 0 ;
8382 : PyObject *swig_obj[1] ;
8383 :
8384 19 : if (!args) SWIG_fail;
8385 19 : swig_obj[0] = args;
8386 19 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_DISOWN | 0 );
8387 19 : if (!SWIG_IsOK(res1)) {
8388 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KeySet" "', argument " "1"" of type '" "kdb::KeySet *""'");
8389 : }
8390 19 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8391 38 : delete arg1;
8392 19 : resultobj = SWIG_Py_Void();
8393 19 : return resultobj;
8394 : fail:
8395 : return NULL;
8396 : }
8397 :
8398 :
8399 0 : SWIGINTERN PyObject *_wrap_KeySet_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8400 0 : PyObject *resultobj = 0;
8401 0 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8402 0 : void *argp1 = 0 ;
8403 0 : int res1 = 0 ;
8404 : PyObject *swig_obj[1] ;
8405 0 : ckdb::KeySet *result = 0 ;
8406 :
8407 0 : if (!args) SWIG_fail;
8408 0 : swig_obj[0] = args;
8409 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8410 0 : if (!SWIG_IsOK(res1)) {
8411 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_release" "', argument " "1"" of type '" "kdb::KeySet *""'");
8412 : }
8413 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8414 0 : result = (ckdb::KeySet *)(arg1)->release();
8415 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__KeySet, 0 | 0 );
8416 : return resultobj;
8417 : fail:
8418 : return NULL;
8419 : }
8420 :
8421 :
8422 0 : SWIGINTERN PyObject *_wrap_KeySet_getKeySet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8423 0 : PyObject *resultobj = 0;
8424 0 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8425 0 : void *argp1 = 0 ;
8426 0 : int res1 = 0 ;
8427 : PyObject *swig_obj[1] ;
8428 0 : ckdb::KeySet *result = 0 ;
8429 :
8430 0 : if (!args) SWIG_fail;
8431 0 : swig_obj[0] = args;
8432 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8433 0 : if (!SWIG_IsOK(res1)) {
8434 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_getKeySet" "', argument " "1"" of type '" "kdb::KeySet const *""'");
8435 : }
8436 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8437 0 : result = (ckdb::KeySet *)((kdb::KeySet const *)arg1)->getKeySet();
8438 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__KeySet, 0 | 0 );
8439 : return resultobj;
8440 : fail:
8441 : return NULL;
8442 : }
8443 :
8444 :
8445 0 : SWIGINTERN PyObject *_wrap_KeySet_setKeySet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8446 0 : PyObject *resultobj = 0;
8447 0 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8448 0 : ckdb::KeySet *arg2 = (ckdb::KeySet *) 0 ;
8449 0 : void *argp1 = 0 ;
8450 0 : int res1 = 0 ;
8451 0 : void *argp2 = 0 ;
8452 0 : int res2 = 0 ;
8453 : PyObject *swig_obj[2] ;
8454 :
8455 0 : if (!SWIG_Python_UnpackTuple(args,"KeySet_setKeySet",2,2,swig_obj)) SWIG_fail;
8456 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8457 0 : if (!SWIG_IsOK(res1)) {
8458 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_setKeySet" "', argument " "1"" of type '" "kdb::KeySet *""'");
8459 : }
8460 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8461 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p__KeySet, 0 | 0 );
8462 0 : if (!SWIG_IsOK(res2)) {
8463 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet_setKeySet" "', argument " "2"" of type '" "ckdb::KeySet *""'");
8464 : }
8465 0 : arg2 = reinterpret_cast< ckdb::KeySet * >(argp2);
8466 0 : (arg1)->setKeySet(arg2);
8467 0 : resultobj = SWIG_Py_Void();
8468 0 : return resultobj;
8469 : fail:
8470 : return NULL;
8471 : }
8472 :
8473 :
8474 18 : SWIGINTERN PyObject *_wrap_KeySet___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8475 18 : PyObject *resultobj = 0;
8476 18 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8477 18 : void *argp1 = 0 ;
8478 18 : int res1 = 0 ;
8479 : PyObject *swig_obj[1] ;
8480 : ssize_t result;
8481 :
8482 18 : if (!args) SWIG_fail;
8483 18 : swig_obj[0] = args;
8484 18 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8485 18 : if (!SWIG_IsOK(res1)) {
8486 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet___len__" "', argument " "1"" of type '" "kdb::KeySet const *""'");
8487 : }
8488 18 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8489 18 : result = ((kdb::KeySet const *)arg1)->size();
8490 18 : resultobj = SWIG_From_long(static_cast< long >(result));
8491 : return resultobj;
8492 : fail:
8493 : return NULL;
8494 : }
8495 :
8496 :
8497 1 : SWIGINTERN PyObject *_wrap_KeySet_dup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8498 1 : PyObject *resultobj = 0;
8499 1 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8500 1 : void *argp1 = 0 ;
8501 1 : int res1 = 0 ;
8502 : PyObject *swig_obj[1] ;
8503 1 : ckdb::KeySet *result = 0 ;
8504 :
8505 1 : if (!args) SWIG_fail;
8506 1 : swig_obj[0] = args;
8507 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8508 1 : if (!SWIG_IsOK(res1)) {
8509 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_dup" "', argument " "1"" of type '" "kdb::KeySet const *""'");
8510 : }
8511 1 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8512 1 : result = (ckdb::KeySet *)((kdb::KeySet const *)arg1)->dup();
8513 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__KeySet, 0 | 0 );
8514 : return resultobj;
8515 : fail:
8516 : return NULL;
8517 : }
8518 :
8519 :
8520 0 : SWIGINTERN PyObject *_wrap_KeySet_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8521 0 : PyObject *resultobj = 0;
8522 0 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8523 0 : kdb::KeySet *arg2 = 0 ;
8524 0 : void *argp1 = 0 ;
8525 0 : int res1 = 0 ;
8526 0 : void *argp2 = 0 ;
8527 0 : int res2 = 0 ;
8528 : PyObject *swig_obj[2] ;
8529 :
8530 0 : if (!SWIG_Python_UnpackTuple(args,"KeySet_copy",2,2,swig_obj)) SWIG_fail;
8531 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8532 0 : if (!SWIG_IsOK(res1)) {
8533 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_copy" "', argument " "1"" of type '" "kdb::KeySet *""'");
8534 : }
8535 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8536 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet, 0 | 0);
8537 0 : if (!SWIG_IsOK(res2)) {
8538 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet_copy" "', argument " "2"" of type '" "kdb::KeySet const &""'");
8539 : }
8540 0 : if (!argp2) {
8541 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet_copy" "', argument " "2"" of type '" "kdb::KeySet const &""'");
8542 : }
8543 0 : arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
8544 0 : (arg1)->copy((kdb::KeySet const &)*arg2);
8545 0 : resultobj = SWIG_Py_Void();
8546 0 : return resultobj;
8547 : fail:
8548 : return NULL;
8549 : }
8550 :
8551 :
8552 1 : SWIGINTERN PyObject *_wrap_KeySet_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8553 1 : PyObject *resultobj = 0;
8554 1 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8555 1 : void *argp1 = 0 ;
8556 1 : int res1 = 0 ;
8557 : PyObject *swig_obj[1] ;
8558 :
8559 1 : if (!args) SWIG_fail;
8560 1 : swig_obj[0] = args;
8561 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8562 1 : if (!SWIG_IsOK(res1)) {
8563 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_clear" "', argument " "1"" of type '" "kdb::KeySet *""'");
8564 : }
8565 1 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8566 1 : (arg1)->clear();
8567 1 : resultobj = SWIG_Py_Void();
8568 1 : return resultobj;
8569 : fail:
8570 : return NULL;
8571 : }
8572 :
8573 :
8574 35 : SWIGINTERN PyObject *_wrap_KeySet_append__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
8575 35 : PyObject *resultobj = 0;
8576 35 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8577 35 : kdb::Key *arg2 = 0 ;
8578 35 : void *argp1 = 0 ;
8579 35 : int res1 = 0 ;
8580 35 : void *argp2 = 0 ;
8581 35 : int res2 = 0 ;
8582 : ssize_t result;
8583 :
8584 35 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
8585 35 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8586 35 : if (!SWIG_IsOK(res1)) {
8587 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_append" "', argument " "1"" of type '" "kdb::KeySet *""'");
8588 : }
8589 35 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8590 35 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
8591 35 : if (!SWIG_IsOK(res2)) {
8592 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet_append" "', argument " "2"" of type '" "kdb::Key const &""'");
8593 : }
8594 35 : if (!argp2) {
8595 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet_append" "', argument " "2"" of type '" "kdb::Key const &""'");
8596 : }
8597 35 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
8598 35 : result = (arg1)->append((kdb::Key const &)*arg2);
8599 35 : resultobj = SWIG_From_long(static_cast< long >(result));
8600 : return resultobj;
8601 : fail:
8602 : return NULL;
8603 : }
8604 :
8605 :
8606 0 : SWIGINTERN PyObject *_wrap_KeySet_append__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
8607 0 : PyObject *resultobj = 0;
8608 0 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8609 0 : kdb::KeySet *arg2 = 0 ;
8610 0 : void *argp1 = 0 ;
8611 0 : int res1 = 0 ;
8612 0 : void *argp2 = 0 ;
8613 0 : int res2 = 0 ;
8614 : ssize_t result;
8615 :
8616 0 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
8617 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8618 0 : if (!SWIG_IsOK(res1)) {
8619 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_append" "', argument " "1"" of type '" "kdb::KeySet *""'");
8620 : }
8621 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8622 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet, 0 | 0);
8623 0 : if (!SWIG_IsOK(res2)) {
8624 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet_append" "', argument " "2"" of type '" "kdb::KeySet const &""'");
8625 : }
8626 0 : if (!argp2) {
8627 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet_append" "', argument " "2"" of type '" "kdb::KeySet const &""'");
8628 : }
8629 0 : arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
8630 0 : result = (arg1)->append((kdb::KeySet const &)*arg2);
8631 0 : resultobj = SWIG_From_long(static_cast< long >(result));
8632 : return resultobj;
8633 : fail:
8634 : return NULL;
8635 : }
8636 :
8637 :
8638 35 : SWIGINTERN PyObject *_wrap_KeySet_append(PyObject *self, PyObject *args) {
8639 : Py_ssize_t argc;
8640 : PyObject *argv[3] = {
8641 : 0
8642 35 : };
8643 :
8644 35 : if (!(argc = SWIG_Python_UnpackTuple(args,"KeySet_append",0,2,argv))) SWIG_fail;
8645 35 : --argc;
8646 35 : if (argc == 2) {
8647 35 : int _v = 0;
8648 : {
8649 35 : int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_kdb__Key, 0);
8650 35 : _v = SWIG_CheckState(res);
8651 : }
8652 35 : if (!_v) goto check_1;
8653 35 : return _wrap_KeySet_append__SWIG_0(self, argc, argv);
8654 : }
8655 : check_1:
8656 :
8657 0 : if (argc == 2) {
8658 0 : return _wrap_KeySet_append__SWIG_1(self, argc, argv);
8659 : }
8660 :
8661 : fail:
8662 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'KeySet_append'.\n"
8663 : " Possible C/C++ prototypes are:\n"
8664 : " kdb::KeySet::append(kdb::Key const &)\n"
8665 0 : " kdb::KeySet::append(kdb::KeySet const &)\n");
8666 : return 0;
8667 : }
8668 :
8669 :
8670 0 : SWIGINTERN PyObject *_wrap_KeySet_head(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8671 0 : PyObject *resultobj = 0;
8672 0 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8673 0 : void *argp1 = 0 ;
8674 0 : int res1 = 0 ;
8675 : PyObject *swig_obj[1] ;
8676 0 : kdb::Key result;
8677 :
8678 0 : if (!args) SWIG_fail;
8679 0 : swig_obj[0] = args;
8680 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8681 0 : if (!SWIG_IsOK(res1)) {
8682 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_head" "', argument " "1"" of type '" "kdb::KeySet const *""'");
8683 : }
8684 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8685 0 : result = ((kdb::KeySet const *)arg1)->head();
8686 0 : resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN | 0 );
8687 : return resultobj;
8688 : fail:
8689 : return NULL;
8690 : }
8691 :
8692 :
8693 0 : SWIGINTERN PyObject *_wrap_KeySet_tail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8694 0 : PyObject *resultobj = 0;
8695 0 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8696 0 : void *argp1 = 0 ;
8697 0 : int res1 = 0 ;
8698 : PyObject *swig_obj[1] ;
8699 0 : kdb::Key result;
8700 :
8701 0 : if (!args) SWIG_fail;
8702 0 : swig_obj[0] = args;
8703 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8704 0 : if (!SWIG_IsOK(res1)) {
8705 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_tail" "', argument " "1"" of type '" "kdb::KeySet const *""'");
8706 : }
8707 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8708 0 : result = ((kdb::KeySet const *)arg1)->tail();
8709 0 : resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN | 0 );
8710 : return resultobj;
8711 : fail:
8712 : return NULL;
8713 : }
8714 :
8715 :
8716 0 : SWIGINTERN PyObject *_wrap_KeySet_setCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8717 0 : PyObject *resultobj = 0;
8718 0 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8719 : cursor_t arg2 ;
8720 0 : void *argp1 = 0 ;
8721 0 : int res1 = 0 ;
8722 : long val2 ;
8723 0 : int ecode2 = 0 ;
8724 : PyObject *swig_obj[2] ;
8725 :
8726 0 : if (!SWIG_Python_UnpackTuple(args,"KeySet_setCursor",2,2,swig_obj)) SWIG_fail;
8727 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8728 0 : if (!SWIG_IsOK(res1)) {
8729 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_setCursor" "', argument " "1"" of type '" "kdb::KeySet const *""'");
8730 : }
8731 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8732 0 : ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
8733 0 : if (!SWIG_IsOK(ecode2)) {
8734 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeySet_setCursor" "', argument " "2"" of type '" "cursor_t""'");
8735 : }
8736 0 : arg2 = static_cast< cursor_t >(val2);
8737 0 : ((kdb::KeySet const *)arg1)->setCursor(arg2);
8738 0 : resultobj = SWIG_Py_Void();
8739 0 : return resultobj;
8740 : fail:
8741 : return NULL;
8742 : }
8743 :
8744 :
8745 0 : SWIGINTERN PyObject *_wrap_KeySet_getCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8746 0 : PyObject *resultobj = 0;
8747 0 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8748 0 : void *argp1 = 0 ;
8749 0 : int res1 = 0 ;
8750 : PyObject *swig_obj[1] ;
8751 : cursor_t result;
8752 :
8753 0 : if (!args) SWIG_fail;
8754 0 : swig_obj[0] = args;
8755 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8756 0 : if (!SWIG_IsOK(res1)) {
8757 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_getCursor" "', argument " "1"" of type '" "kdb::KeySet const *""'");
8758 : }
8759 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8760 0 : result = ((kdb::KeySet const *)arg1)->getCursor();
8761 0 : resultobj = SWIG_From_long(static_cast< long >(result));
8762 : return resultobj;
8763 : fail:
8764 : return NULL;
8765 : }
8766 :
8767 :
8768 2 : SWIGINTERN PyObject *_wrap_KeySet_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8769 2 : PyObject *resultobj = 0;
8770 2 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8771 2 : void *argp1 = 0 ;
8772 2 : int res1 = 0 ;
8773 : PyObject *swig_obj[1] ;
8774 4 : kdb::Key result;
8775 :
8776 2 : if (!args) SWIG_fail;
8777 2 : swig_obj[0] = args;
8778 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8779 2 : if (!SWIG_IsOK(res1)) {
8780 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_pop" "', argument " "1"" of type '" "kdb::KeySet *""'");
8781 : }
8782 2 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8783 6 : result = (arg1)->pop();
8784 4 : resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN | 0 );
8785 : return resultobj;
8786 : fail:
8787 : return NULL;
8788 : }
8789 :
8790 :
8791 14 : SWIGINTERN PyObject *_wrap_KeySet__lookup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
8792 14 : PyObject *resultobj = 0;
8793 14 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8794 : cursor_t arg2 ;
8795 14 : void *argp1 = 0 ;
8796 14 : int res1 = 0 ;
8797 : long val2 ;
8798 14 : int ecode2 = 0 ;
8799 28 : kdb::Key result;
8800 :
8801 14 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
8802 14 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8803 14 : if (!SWIG_IsOK(res1)) {
8804 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet__lookup" "', argument " "1"" of type '" "kdb::KeySet const *""'");
8805 : }
8806 14 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8807 14 : ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
8808 14 : if (!SWIG_IsOK(ecode2)) {
8809 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeySet__lookup" "', argument " "2"" of type '" "cursor_t""'");
8810 : }
8811 14 : arg2 = static_cast< cursor_t >(val2);
8812 42 : result = ((kdb::KeySet const *)arg1)->at(arg2);
8813 28 : resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN | 0 );
8814 : return resultobj;
8815 : fail:
8816 : return NULL;
8817 : }
8818 :
8819 :
8820 3 : SWIGINTERN PyObject *_wrap_KeySet_cut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8821 3 : PyObject *resultobj = 0;
8822 3 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8823 6 : kdb::Key arg2 ;
8824 3 : void *argp1 = 0 ;
8825 3 : int res1 = 0 ;
8826 : void *argp2 ;
8827 3 : int res2 = 0 ;
8828 : PyObject *swig_obj[2] ;
8829 6 : kdb::KeySet result;
8830 :
8831 3 : if (!SWIG_Python_UnpackTuple(args,"KeySet_cut",2,2,swig_obj)) SWIG_fail;
8832 3 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8833 3 : if (!SWIG_IsOK(res1)) {
8834 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet_cut" "', argument " "1"" of type '" "kdb::KeySet *""'");
8835 : }
8836 3 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8837 : {
8838 3 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
8839 3 : if (!SWIG_IsOK(res2)) {
8840 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet_cut" "', argument " "2"" of type '" "kdb::Key""'");
8841 : }
8842 3 : if (!argp2) {
8843 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet_cut" "', argument " "2"" of type '" "kdb::Key""'");
8844 : } else {
8845 3 : kdb::Key * temp = reinterpret_cast< kdb::Key * >(argp2);
8846 3 : arg2 = *temp;
8847 3 : if (SWIG_IsNewObj(res2)) delete temp;
8848 : }
8849 : }
8850 15 : result = (arg1)->cut(arg2);
8851 6 : resultobj = SWIG_NewPointerObj((new kdb::KeySet(static_cast< const kdb::KeySet& >(result))), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_OWN | 0 );
8852 : return resultobj;
8853 : fail:
8854 : return NULL;
8855 : }
8856 :
8857 :
8858 0 : SWIGINTERN PyObject *_wrap_KeySet__lookup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
8859 0 : PyObject *resultobj = 0;
8860 0 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8861 0 : kdb::Key *arg2 = 0 ;
8862 : option_t arg3 ;
8863 0 : void *argp1 = 0 ;
8864 0 : int res1 = 0 ;
8865 0 : void *argp2 = 0 ;
8866 0 : int res2 = 0 ;
8867 : void *argp3 ;
8868 0 : int res3 = 0 ;
8869 0 : kdb::Key result;
8870 :
8871 0 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
8872 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8873 0 : if (!SWIG_IsOK(res1)) {
8874 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet__lookup" "', argument " "1"" of type '" "kdb::KeySet const *""'");
8875 : }
8876 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8877 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
8878 0 : if (!SWIG_IsOK(res2)) {
8879 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet__lookup" "', argument " "2"" of type '" "kdb::Key const &""'");
8880 : }
8881 0 : if (!argp2) {
8882 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "2"" of type '" "kdb::Key const &""'");
8883 : }
8884 0 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
8885 : {
8886 0 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_option_t, 0 | 0);
8887 0 : if (!SWIG_IsOK(res3)) {
8888 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KeySet__lookup" "', argument " "3"" of type '" "option_t const""'");
8889 : }
8890 0 : if (!argp3) {
8891 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "3"" of type '" "option_t const""'");
8892 : } else {
8893 0 : option_t * temp = reinterpret_cast< option_t * >(argp3);
8894 0 : arg3 = *temp;
8895 0 : if (SWIG_IsNewObj(res3)) delete temp;
8896 : }
8897 : }
8898 0 : result = ((kdb::KeySet const *)arg1)->lookup((kdb::Key const &)*arg2,arg3);
8899 0 : resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN | 0 );
8900 : return resultobj;
8901 : fail:
8902 : return NULL;
8903 : }
8904 :
8905 :
8906 11 : SWIGINTERN PyObject *_wrap_KeySet__lookup__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
8907 11 : PyObject *resultobj = 0;
8908 11 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8909 11 : kdb::Key *arg2 = 0 ;
8910 11 : void *argp1 = 0 ;
8911 11 : int res1 = 0 ;
8912 11 : void *argp2 = 0 ;
8913 11 : int res2 = 0 ;
8914 22 : kdb::Key result;
8915 :
8916 11 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
8917 11 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8918 11 : if (!SWIG_IsOK(res1)) {
8919 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet__lookup" "', argument " "1"" of type '" "kdb::KeySet const *""'");
8920 : }
8921 11 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8922 11 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 | 0);
8923 11 : if (!SWIG_IsOK(res2)) {
8924 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet__lookup" "', argument " "2"" of type '" "kdb::Key const &""'");
8925 : }
8926 11 : if (!argp2) {
8927 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "2"" of type '" "kdb::Key const &""'");
8928 : }
8929 11 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
8930 33 : result = ((kdb::KeySet const *)arg1)->lookup((kdb::Key const &)*arg2);
8931 22 : resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN | 0 );
8932 : return resultobj;
8933 : fail:
8934 : return NULL;
8935 : }
8936 :
8937 :
8938 0 : SWIGINTERN PyObject *_wrap_KeySet__lookup__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
8939 0 : PyObject *resultobj = 0;
8940 0 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8941 0 : std::string *arg2 = 0 ;
8942 : option_t arg3 ;
8943 0 : void *argp1 = 0 ;
8944 0 : int res1 = 0 ;
8945 0 : int res2 = SWIG_OLDOBJ ;
8946 : void *argp3 ;
8947 0 : int res3 = 0 ;
8948 0 : kdb::Key result;
8949 :
8950 0 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
8951 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
8952 0 : if (!SWIG_IsOK(res1)) {
8953 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet__lookup" "', argument " "1"" of type '" "kdb::KeySet const *""'");
8954 : }
8955 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
8956 : {
8957 0 : std::string *ptr = (std::string *)0;
8958 0 : res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
8959 0 : if (!SWIG_IsOK(res2)) {
8960 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet__lookup" "', argument " "2"" of type '" "std::string const &""'");
8961 : }
8962 0 : if (!ptr) {
8963 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "2"" of type '" "std::string const &""'");
8964 : }
8965 0 : arg2 = ptr;
8966 : }
8967 : {
8968 0 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_option_t, 0 | 0);
8969 0 : if (!SWIG_IsOK(res3)) {
8970 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KeySet__lookup" "', argument " "3"" of type '" "option_t const""'");
8971 : }
8972 0 : if (!argp3) {
8973 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "3"" of type '" "option_t const""'");
8974 : } else {
8975 0 : option_t * temp = reinterpret_cast< option_t * >(argp3);
8976 0 : arg3 = *temp;
8977 0 : if (SWIG_IsNewObj(res3)) delete temp;
8978 : }
8979 : }
8980 0 : result = ((kdb::KeySet const *)arg1)->lookup((std::string const &)*arg2,arg3);
8981 0 : resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN | 0 );
8982 0 : if (SWIG_IsNewObj(res2)) delete arg2;
8983 : return resultobj;
8984 : fail:
8985 0 : if (SWIG_IsNewObj(res2)) delete arg2;
8986 : return NULL;
8987 : }
8988 :
8989 :
8990 6 : SWIGINTERN PyObject *_wrap_KeySet__lookup__SWIG_4(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
8991 6 : PyObject *resultobj = 0;
8992 6 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
8993 6 : std::string *arg2 = 0 ;
8994 6 : void *argp1 = 0 ;
8995 6 : int res1 = 0 ;
8996 6 : int res2 = SWIG_OLDOBJ ;
8997 12 : kdb::Key result;
8998 :
8999 6 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
9000 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
9001 6 : if (!SWIG_IsOK(res1)) {
9002 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet__lookup" "', argument " "1"" of type '" "kdb::KeySet const *""'");
9003 : }
9004 6 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
9005 : {
9006 6 : std::string *ptr = (std::string *)0;
9007 6 : res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
9008 6 : if (!SWIG_IsOK(res2)) {
9009 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KeySet__lookup" "', argument " "2"" of type '" "std::string const &""'");
9010 : }
9011 6 : if (!ptr) {
9012 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KeySet__lookup" "', argument " "2"" of type '" "std::string const &""'");
9013 : }
9014 6 : arg2 = ptr;
9015 : }
9016 18 : result = ((kdb::KeySet const *)arg1)->lookup((std::string const &)*arg2);
9017 12 : resultobj = SWIG_NewPointerObj((new kdb::Key(static_cast< const kdb::Key& >(result))), SWIGTYPE_p_kdb__Key, SWIG_POINTER_OWN | 0 );
9018 12 : if (SWIG_IsNewObj(res2)) delete arg2;
9019 : return resultobj;
9020 : fail:
9021 : if (SWIG_IsNewObj(res2)) delete arg2;
9022 : return NULL;
9023 : }
9024 :
9025 :
9026 31 : SWIGINTERN PyObject *_wrap_KeySet__lookup(PyObject *self, PyObject *args) {
9027 : Py_ssize_t argc;
9028 : PyObject *argv[4] = {
9029 : 0
9030 31 : };
9031 :
9032 31 : if (!(argc = SWIG_Python_UnpackTuple(args,"KeySet__lookup",0,3,argv))) SWIG_fail;
9033 31 : --argc;
9034 31 : if (argc == 2) {
9035 31 : int _v = 0;
9036 : {
9037 31 : int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_kdb__Key, 0);
9038 31 : _v = SWIG_CheckState(res);
9039 : }
9040 31 : if (!_v) goto check_1;
9041 11 : return _wrap_KeySet__lookup__SWIG_2(self, argc, argv);
9042 : }
9043 : check_1:
9044 :
9045 20 : if (argc == 2) {
9046 20 : int _v = 0;
9047 : {
9048 : {
9049 20 : int res = SWIG_AsVal_long(argv[1], NULL);
9050 20 : _v = SWIG_CheckState(res);
9051 : }
9052 : }
9053 20 : if (!_v) goto check_2;
9054 14 : return _wrap_KeySet__lookup__SWIG_0(self, argc, argv);
9055 : }
9056 : check_2:
9057 :
9058 6 : if (argc == 2) {
9059 6 : return _wrap_KeySet__lookup__SWIG_4(self, argc, argv);
9060 : }
9061 0 : if (argc == 3) {
9062 0 : int _v = 0;
9063 : {
9064 0 : int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_kdb__Key, 0);
9065 0 : _v = SWIG_CheckState(res);
9066 : }
9067 0 : if (!_v) goto check_4;
9068 0 : return _wrap_KeySet__lookup__SWIG_1(self, argc, argv);
9069 : }
9070 : check_4:
9071 :
9072 0 : if (argc == 3) {
9073 0 : return _wrap_KeySet__lookup__SWIG_3(self, argc, argv);
9074 : }
9075 :
9076 : fail:
9077 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'KeySet__lookup'.\n"
9078 : " Possible C/C++ prototypes are:\n"
9079 : " kdb::KeySet::at(cursor_t) const\n"
9080 : " kdb::KeySet::lookup(kdb::Key const &,option_t const) const\n"
9081 : " kdb::KeySet::lookup(kdb::Key const &) const\n"
9082 : " kdb::KeySet::lookup(std::string const &,option_t const) const\n"
9083 0 : " kdb::KeySet::lookup(std::string const &) const\n");
9084 : return 0;
9085 : }
9086 :
9087 :
9088 15 : SWIGINTERN PyObject *_wrap_new_KeySet__SWIG_3(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
9089 15 : PyObject *resultobj = 0;
9090 : size_t arg1 ;
9091 : size_t val1 ;
9092 15 : int ecode1 = 0 ;
9093 15 : kdb::KeySet *result = 0 ;
9094 :
9095 15 : if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
9096 30 : ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
9097 15 : if (!SWIG_IsOK(ecode1)) {
9098 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeySet" "', argument " "1"" of type '" "size_t""'");
9099 : }
9100 15 : arg1 = static_cast< size_t >(val1);
9101 15 : result = (kdb::KeySet *)new_kdb_KeySet__SWIG_3(arg1);
9102 15 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, SWIG_POINTER_NEW | 0 );
9103 : return resultobj;
9104 : fail:
9105 : return NULL;
9106 : }
9107 :
9108 :
9109 18 : SWIGINTERN PyObject *_wrap_new_KeySet(PyObject *self, PyObject *args) {
9110 : Py_ssize_t argc;
9111 : PyObject *argv[2] = {
9112 : 0
9113 18 : };
9114 :
9115 18 : if (!(argc = SWIG_Python_UnpackTuple(args,"new_KeySet",0,1,argv))) SWIG_fail;
9116 18 : --argc;
9117 18 : if (argc == 0) {
9118 1 : return _wrap_new_KeySet__SWIG_0(self, argc, argv);
9119 : }
9120 17 : if (argc == 1) {
9121 17 : int _v = 0;
9122 : {
9123 17 : void *vptr = 0;
9124 17 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p__KeySet, 0);
9125 17 : _v = SWIG_CheckState(res);
9126 : }
9127 17 : if (!_v) goto check_2;
9128 1 : return _wrap_new_KeySet__SWIG_1(self, argc, argv);
9129 : }
9130 : check_2:
9131 :
9132 16 : if (argc == 1) {
9133 16 : int _v = 0;
9134 : {
9135 16 : int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_kdb__KeySet, 0);
9136 16 : _v = SWIG_CheckState(res);
9137 : }
9138 16 : if (!_v) goto check_3;
9139 1 : return _wrap_new_KeySet__SWIG_2(self, argc, argv);
9140 : }
9141 : check_3:
9142 :
9143 15 : if (argc == 1) {
9144 15 : return _wrap_new_KeySet__SWIG_3(self, argc, argv);
9145 : }
9146 :
9147 : fail:
9148 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_KeySet'.\n"
9149 : " Possible C/C++ prototypes are:\n"
9150 : " kdb::KeySet::KeySet()\n"
9151 : " kdb::KeySet::KeySet(ckdb::KeySet *)\n"
9152 : " kdb::KeySet::KeySet(kdb::KeySet const &)\n"
9153 0 : " kdb::KeySet::KeySet(size_t)\n");
9154 : return 0;
9155 : }
9156 :
9157 :
9158 1 : SWIGINTERN PyObject *_wrap_KeySet___copy__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9159 1 : PyObject *resultobj = 0;
9160 1 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
9161 1 : void *argp1 = 0 ;
9162 1 : int res1 = 0 ;
9163 : PyObject *swig_obj[1] ;
9164 1 : kdb::KeySet *result = 0 ;
9165 :
9166 1 : if (!args) SWIG_fail;
9167 1 : swig_obj[0] = args;
9168 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
9169 1 : if (!SWIG_IsOK(res1)) {
9170 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet___copy__" "', argument " "1"" of type '" "kdb::KeySet *""'");
9171 : }
9172 1 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
9173 1 : result = (kdb::KeySet *)kdb_KeySet___copy__(arg1);
9174 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, 0 | 0 );
9175 : return resultobj;
9176 : fail:
9177 : return NULL;
9178 : }
9179 :
9180 :
9181 1 : SWIGINTERN PyObject *_wrap_KeySet___deepcopy__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9182 1 : PyObject *resultobj = 0;
9183 1 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
9184 1 : PyObject *arg2 = (PyObject *) 0 ;
9185 1 : void *argp1 = 0 ;
9186 1 : int res1 = 0 ;
9187 : PyObject *swig_obj[2] ;
9188 1 : kdb::KeySet *result = 0 ;
9189 :
9190 1 : if (!SWIG_Python_UnpackTuple(args,"KeySet___deepcopy__",2,2,swig_obj)) SWIG_fail;
9191 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
9192 1 : if (!SWIG_IsOK(res1)) {
9193 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet___deepcopy__" "', argument " "1"" of type '" "kdb::KeySet *""'");
9194 : }
9195 1 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
9196 1 : arg2 = swig_obj[1];
9197 1 : result = (kdb::KeySet *)kdb_KeySet___deepcopy__(arg1,arg2);
9198 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KeySet, 0 | 0 );
9199 : return resultobj;
9200 : fail:
9201 : return NULL;
9202 : }
9203 :
9204 :
9205 2 : SWIGINTERN PyObject *_wrap_KeySet___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9206 2 : PyObject *resultobj = 0;
9207 2 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
9208 2 : PyObject **arg2 = (PyObject **) 0 ;
9209 2 : void *argp1 = 0 ;
9210 2 : int res1 = 0 ;
9211 : PyObject *swig_obj[1] ;
9212 2 : swig::SwigPyIterator *result = 0 ;
9213 :
9214 2 : arg2 = &swig_obj[0];
9215 2 : if (!args) SWIG_fail;
9216 2 : swig_obj[0] = args;
9217 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
9218 2 : if (!SWIG_IsOK(res1)) {
9219 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet___iter__" "', argument " "1"" of type '" "kdb::KeySet *""'");
9220 : }
9221 2 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
9222 2 : result = (swig::SwigPyIterator *)kdb_KeySet___iter__(arg1,arg2);
9223 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
9224 : return resultobj;
9225 : fail:
9226 : return NULL;
9227 : }
9228 :
9229 :
9230 1 : SWIGINTERN PyObject *_wrap_KeySet___reversed__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9231 1 : PyObject *resultobj = 0;
9232 1 : kdb::KeySet *arg1 = (kdb::KeySet *) 0 ;
9233 1 : PyObject **arg2 = (PyObject **) 0 ;
9234 1 : void *argp1 = 0 ;
9235 1 : int res1 = 0 ;
9236 : PyObject *swig_obj[1] ;
9237 1 : swig::SwigPyIterator *result = 0 ;
9238 :
9239 1 : arg2 = &swig_obj[0];
9240 1 : if (!args) SWIG_fail;
9241 1 : swig_obj[0] = args;
9242 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KeySet, 0 | 0 );
9243 1 : if (!SWIG_IsOK(res1)) {
9244 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeySet___reversed__" "', argument " "1"" of type '" "kdb::KeySet *""'");
9245 : }
9246 1 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
9247 1 : result = (swig::SwigPyIterator *)kdb_KeySet___reversed__(arg1,arg2);
9248 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 | 0 );
9249 : return resultobj;
9250 : fail:
9251 : return NULL;
9252 : }
9253 :
9254 :
9255 3 : SWIGINTERN PyObject *KeySet_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9256 : PyObject *obj;
9257 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9258 6 : SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KeySet, SWIG_NewClientData(obj));
9259 3 : return SWIG_Py_Void();
9260 : }
9261 :
9262 18 : SWIGINTERN PyObject *KeySet_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9263 18 : return SWIG_Python_InitShadowInstance(args);
9264 : }
9265 :
9266 0 : SWIGINTERN PyObject *_wrap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9267 0 : PyObject *resultobj = 0;
9268 0 : kdb::KeySet *arg1 = 0 ;
9269 0 : kdb::KeySet *arg2 = 0 ;
9270 0 : void *argp1 = 0 ;
9271 0 : int res1 = 0 ;
9272 0 : void *argp2 = 0 ;
9273 0 : int res2 = 0 ;
9274 : PyObject *swig_obj[2] ;
9275 : bool result;
9276 :
9277 0 : if (!SWIG_Python_UnpackTuple(args,"__eq__",2,2,swig_obj)) SWIG_fail;
9278 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_kdb__KeySet, 0 | 0);
9279 0 : if (!SWIG_IsOK(res1)) {
9280 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "kdb::KeySet const &""'");
9281 : }
9282 0 : if (!argp1) {
9283 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "kdb::KeySet const &""'");
9284 : }
9285 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
9286 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet, 0 | 0);
9287 0 : if (!SWIG_IsOK(res2)) {
9288 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "kdb::KeySet const &""'");
9289 : }
9290 0 : if (!argp2) {
9291 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "2"" of type '" "kdb::KeySet const &""'");
9292 : }
9293 0 : arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
9294 0 : result = (bool)kdb::operator ==((kdb::KeySet const &)*arg1,(kdb::KeySet const &)*arg2);
9295 : resultobj = SWIG_From_bool(static_cast< bool >(result));
9296 : return resultobj;
9297 : fail:
9298 : return NULL;
9299 : }
9300 :
9301 :
9302 0 : SWIGINTERN PyObject *_wrap___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9303 0 : PyObject *resultobj = 0;
9304 0 : kdb::KeySet *arg1 = 0 ;
9305 0 : kdb::KeySet *arg2 = 0 ;
9306 0 : void *argp1 = 0 ;
9307 0 : int res1 = 0 ;
9308 0 : void *argp2 = 0 ;
9309 0 : int res2 = 0 ;
9310 : PyObject *swig_obj[2] ;
9311 : bool result;
9312 :
9313 0 : if (!SWIG_Python_UnpackTuple(args,"__ne__",2,2,swig_obj)) SWIG_fail;
9314 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_kdb__KeySet, 0 | 0);
9315 0 : if (!SWIG_IsOK(res1)) {
9316 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__ne__" "', argument " "1"" of type '" "kdb::KeySet const &""'");
9317 : }
9318 0 : if (!argp1) {
9319 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "1"" of type '" "kdb::KeySet const &""'");
9320 : }
9321 0 : arg1 = reinterpret_cast< kdb::KeySet * >(argp1);
9322 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet, 0 | 0);
9323 0 : if (!SWIG_IsOK(res2)) {
9324 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__ne__" "', argument " "2"" of type '" "kdb::KeySet const &""'");
9325 : }
9326 0 : if (!argp2) {
9327 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__ne__" "', argument " "2"" of type '" "kdb::KeySet const &""'");
9328 : }
9329 0 : arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
9330 0 : result = (bool)kdb::operator !=((kdb::KeySet const &)*arg1,(kdb::KeySet const &)*arg2);
9331 : resultobj = SWIG_From_bool(static_cast< bool >(result));
9332 : return resultobj;
9333 : fail:
9334 : return NULL;
9335 : }
9336 :
9337 :
9338 5 : SWIGINTERN PyObject *_wrap_new_KDB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
9339 5 : PyObject *resultobj = 0;
9340 5 : kdb::KDB *result = 0 ;
9341 :
9342 5 : if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
9343 : {
9344 : try {
9345 5 : result = (kdb::KDB *)new kdb::KDB();
9346 0 : } KDB_EXCEPTIONS catch (const std::exception & e) {
9347 0 : SWIG_exception(SWIG_RuntimeError, e.what());
9348 0 : } catch (...) {
9349 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::KDB()");
9350 : }
9351 : }
9352 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KDB, SWIG_POINTER_NEW | 0 );
9353 : return resultobj;
9354 : fail:
9355 : return NULL;
9356 : }
9357 :
9358 :
9359 1 : SWIGINTERN PyObject *_wrap_new_KDB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
9360 1 : PyObject *resultobj = 0;
9361 1 : kdb::Key *arg1 = 0 ;
9362 1 : void *argp1 = 0 ;
9363 1 : int res1 = 0 ;
9364 1 : kdb::KDB *result = 0 ;
9365 :
9366 1 : if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
9367 1 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_kdb__Key, 0 );
9368 1 : if (!SWIG_IsOK(res1)) {
9369 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KDB" "', argument " "1"" of type '" "kdb::Key &""'");
9370 : }
9371 1 : if (!argp1) {
9372 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KDB" "', argument " "1"" of type '" "kdb::Key &""'");
9373 : }
9374 1 : arg1 = reinterpret_cast< kdb::Key * >(argp1);
9375 : {
9376 : try {
9377 2 : result = (kdb::KDB *)new kdb::KDB(*arg1);
9378 0 : } KDB_EXCEPTIONS catch (const std::exception & e) {
9379 0 : SWIG_exception(SWIG_RuntimeError, e.what());
9380 0 : } catch (...) {
9381 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::KDB(kdb::Key &)");
9382 : }
9383 : }
9384 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_kdb__KDB, SWIG_POINTER_NEW | 0 );
9385 : return resultobj;
9386 : fail:
9387 : return NULL;
9388 : }
9389 :
9390 :
9391 6 : SWIGINTERN PyObject *_wrap_new_KDB(PyObject *self, PyObject *args) {
9392 : Py_ssize_t argc;
9393 : PyObject *argv[2] = {
9394 : 0
9395 6 : };
9396 :
9397 6 : if (!(argc = SWIG_Python_UnpackTuple(args,"new_KDB",0,1,argv))) SWIG_fail;
9398 6 : --argc;
9399 6 : if (argc == 0) {
9400 5 : return _wrap_new_KDB__SWIG_0(self, argc, argv);
9401 : }
9402 1 : if (argc == 1) {
9403 1 : return _wrap_new_KDB__SWIG_1(self, argc, argv);
9404 : }
9405 :
9406 : fail:
9407 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_KDB'.\n"
9408 : " Possible C/C++ prototypes are:\n"
9409 : " kdb::KDB::KDB()\n"
9410 0 : " kdb::KDB::KDB(kdb::Key &)\n");
9411 : return 0;
9412 : }
9413 :
9414 :
9415 6 : SWIGINTERN PyObject *_wrap_delete_KDB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9416 6 : PyObject *resultobj = 0;
9417 6 : kdb::KDB *arg1 = (kdb::KDB *) 0 ;
9418 6 : void *argp1 = 0 ;
9419 6 : int res1 = 0 ;
9420 : PyObject *swig_obj[1] ;
9421 :
9422 6 : if (!args) SWIG_fail;
9423 6 : swig_obj[0] = args;
9424 6 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, SWIG_POINTER_DISOWN | 0 );
9425 6 : if (!SWIG_IsOK(res1)) {
9426 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KDB" "', argument " "1"" of type '" "kdb::KDB *""'");
9427 : }
9428 6 : arg1 = reinterpret_cast< kdb::KDB * >(argp1);
9429 : {
9430 : try {
9431 6 : delete arg1;
9432 : } KDB_EXCEPTIONS catch (const std::exception & e) {
9433 : SWIG_exception(SWIG_RuntimeError, e.what());
9434 : } catch (...) {
9435 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::~KDB()");
9436 : }
9437 : }
9438 6 : resultobj = SWIG_Py_Void();
9439 6 : return resultobj;
9440 : fail:
9441 : return NULL;
9442 : }
9443 :
9444 :
9445 0 : SWIGINTERN PyObject *_wrap_KDB_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9446 0 : PyObject *resultobj = 0;
9447 0 : kdb::KDB *arg1 = (kdb::KDB *) 0 ;
9448 0 : kdb::Key *arg2 = 0 ;
9449 0 : void *argp1 = 0 ;
9450 0 : int res1 = 0 ;
9451 0 : void *argp2 = 0 ;
9452 0 : int res2 = 0 ;
9453 : PyObject *swig_obj[2] ;
9454 :
9455 0 : if (!SWIG_Python_UnpackTuple(args,"KDB_open",2,2,swig_obj)) SWIG_fail;
9456 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 | 0 );
9457 0 : if (!SWIG_IsOK(res1)) {
9458 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_open" "', argument " "1"" of type '" "kdb::KDB *""'");
9459 : }
9460 0 : arg1 = reinterpret_cast< kdb::KDB * >(argp1);
9461 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 );
9462 0 : if (!SWIG_IsOK(res2)) {
9463 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_open" "', argument " "2"" of type '" "kdb::Key &""'");
9464 : }
9465 0 : if (!argp2) {
9466 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_open" "', argument " "2"" of type '" "kdb::Key &""'");
9467 : }
9468 0 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
9469 : {
9470 : try {
9471 0 : (arg1)->open(*arg2);
9472 0 : } KDB_EXCEPTIONS catch (const std::exception & e) {
9473 0 : SWIG_exception(SWIG_RuntimeError, e.what());
9474 0 : } catch (...) {
9475 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::open(kdb::Key &)");
9476 : }
9477 : }
9478 0 : resultobj = SWIG_Py_Void();
9479 0 : return resultobj;
9480 : fail:
9481 : return NULL;
9482 : }
9483 :
9484 :
9485 0 : SWIGINTERN PyObject *_wrap_KDB_close__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
9486 0 : PyObject *resultobj = 0;
9487 0 : kdb::KDB *arg1 = (kdb::KDB *) 0 ;
9488 0 : void *argp1 = 0 ;
9489 0 : int res1 = 0 ;
9490 :
9491 0 : if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
9492 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 | 0 );
9493 0 : if (!SWIG_IsOK(res1)) {
9494 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_close" "', argument " "1"" of type '" "kdb::KDB *""'");
9495 : }
9496 0 : arg1 = reinterpret_cast< kdb::KDB * >(argp1);
9497 : {
9498 : try {
9499 0 : (arg1)->close();
9500 : } KDB_EXCEPTIONS catch (const std::exception & e) {
9501 : SWIG_exception(SWIG_RuntimeError, e.what());
9502 : } catch (...) {
9503 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::close()");
9504 : }
9505 : }
9506 0 : resultobj = SWIG_Py_Void();
9507 : return resultobj;
9508 : fail:
9509 : return NULL;
9510 : }
9511 :
9512 :
9513 4 : SWIGINTERN PyObject *_wrap_KDB_close__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
9514 4 : PyObject *resultobj = 0;
9515 4 : kdb::KDB *arg1 = (kdb::KDB *) 0 ;
9516 4 : kdb::Key *arg2 = 0 ;
9517 4 : void *argp1 = 0 ;
9518 4 : int res1 = 0 ;
9519 4 : void *argp2 = 0 ;
9520 4 : int res2 = 0 ;
9521 :
9522 4 : if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
9523 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 | 0 );
9524 4 : if (!SWIG_IsOK(res1)) {
9525 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_close" "', argument " "1"" of type '" "kdb::KDB *""'");
9526 : }
9527 4 : arg1 = reinterpret_cast< kdb::KDB * >(argp1);
9528 4 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__Key, 0 );
9529 4 : if (!SWIG_IsOK(res2)) {
9530 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_close" "', argument " "2"" of type '" "kdb::Key &""'");
9531 : }
9532 4 : if (!argp2) {
9533 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_close" "', argument " "2"" of type '" "kdb::Key &""'");
9534 : }
9535 4 : arg2 = reinterpret_cast< kdb::Key * >(argp2);
9536 : {
9537 : try {
9538 4 : (arg1)->close(*arg2);
9539 : } KDB_EXCEPTIONS catch (const std::exception & e) {
9540 : SWIG_exception(SWIG_RuntimeError, e.what());
9541 : } catch (...) {
9542 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::close(kdb::Key &)");
9543 : }
9544 : }
9545 4 : resultobj = SWIG_Py_Void();
9546 : return resultobj;
9547 : fail:
9548 : return NULL;
9549 : }
9550 :
9551 :
9552 4 : SWIGINTERN PyObject *_wrap_KDB_close(PyObject *self, PyObject *args) {
9553 : Py_ssize_t argc;
9554 : PyObject *argv[3] = {
9555 : 0
9556 4 : };
9557 :
9558 4 : if (!(argc = SWIG_Python_UnpackTuple(args,"KDB_close",0,2,argv))) SWIG_fail;
9559 4 : --argc;
9560 4 : if (argc == 1) {
9561 0 : return _wrap_KDB_close__SWIG_0(self, argc, argv);
9562 : }
9563 4 : if (argc == 2) {
9564 4 : return _wrap_KDB_close__SWIG_1(self, argc, argv);
9565 : }
9566 :
9567 : fail:
9568 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'KDB_close'.\n"
9569 : " Possible C/C++ prototypes are:\n"
9570 : " kdb::KDB::close()\n"
9571 0 : " kdb::KDB::close(kdb::Key &)\n");
9572 : return 0;
9573 : }
9574 :
9575 :
9576 4 : SWIGINTERN PyObject *_wrap_KDB_get__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
9577 4 : PyObject *resultobj = 0;
9578 4 : kdb::KDB *arg1 = (kdb::KDB *) 0 ;
9579 4 : kdb::KeySet *arg2 = 0 ;
9580 4 : std::string *arg3 = 0 ;
9581 4 : void *argp1 = 0 ;
9582 4 : int res1 = 0 ;
9583 4 : void *argp2 = 0 ;
9584 4 : int res2 = 0 ;
9585 4 : int res3 = SWIG_OLDOBJ ;
9586 : int result;
9587 :
9588 4 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
9589 4 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 | 0 );
9590 4 : if (!SWIG_IsOK(res1)) {
9591 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_get" "', argument " "1"" of type '" "kdb::KDB *""'");
9592 : }
9593 4 : arg1 = reinterpret_cast< kdb::KDB * >(argp1);
9594 4 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet, 0 );
9595 4 : if (!SWIG_IsOK(res2)) {
9596 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_get" "', argument " "2"" of type '" "kdb::KeySet &""'");
9597 : }
9598 4 : if (!argp2) {
9599 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_get" "', argument " "2"" of type '" "kdb::KeySet &""'");
9600 : }
9601 4 : arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
9602 : {
9603 4 : std::string *ptr = (std::string *)0;
9604 4 : res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
9605 4 : if (!SWIG_IsOK(res3)) {
9606 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KDB_get" "', argument " "3"" of type '" "std::string const &""'");
9607 : }
9608 4 : if (!ptr) {
9609 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_get" "', argument " "3"" of type '" "std::string const &""'");
9610 : }
9611 4 : arg3 = ptr;
9612 : }
9613 : {
9614 : try {
9615 8 : result = (int)(arg1)->get(*arg2,(std::string const &)*arg3);
9616 0 : } KDB_EXCEPTIONS catch (const std::exception & e) {
9617 0 : SWIG_exception(SWIG_RuntimeError, e.what());
9618 0 : } catch (...) {
9619 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::get(kdb::KeySet &,std::string const &)");
9620 : }
9621 : }
9622 4 : resultobj = SWIG_From_int(static_cast< int >(result));
9623 8 : if (SWIG_IsNewObj(res3)) delete arg3;
9624 : return resultobj;
9625 : fail:
9626 0 : if (SWIG_IsNewObj(res3)) delete arg3;
9627 : return NULL;
9628 : }
9629 :
9630 :
9631 0 : SWIGINTERN PyObject *_wrap_KDB_get__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
9632 0 : PyObject *resultobj = 0;
9633 0 : kdb::KDB *arg1 = (kdb::KDB *) 0 ;
9634 0 : kdb::KeySet *arg2 = 0 ;
9635 0 : kdb::Key *arg3 = 0 ;
9636 0 : void *argp1 = 0 ;
9637 0 : int res1 = 0 ;
9638 0 : void *argp2 = 0 ;
9639 0 : int res2 = 0 ;
9640 0 : void *argp3 = 0 ;
9641 0 : int res3 = 0 ;
9642 : int result;
9643 :
9644 0 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
9645 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 | 0 );
9646 0 : if (!SWIG_IsOK(res1)) {
9647 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_get" "', argument " "1"" of type '" "kdb::KDB *""'");
9648 : }
9649 0 : arg1 = reinterpret_cast< kdb::KDB * >(argp1);
9650 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet, 0 );
9651 0 : if (!SWIG_IsOK(res2)) {
9652 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_get" "', argument " "2"" of type '" "kdb::KeySet &""'");
9653 : }
9654 0 : if (!argp2) {
9655 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_get" "', argument " "2"" of type '" "kdb::KeySet &""'");
9656 : }
9657 0 : arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
9658 0 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_kdb__Key, 0 );
9659 0 : if (!SWIG_IsOK(res3)) {
9660 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KDB_get" "', argument " "3"" of type '" "kdb::Key &""'");
9661 : }
9662 0 : if (!argp3) {
9663 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_get" "', argument " "3"" of type '" "kdb::Key &""'");
9664 : }
9665 0 : arg3 = reinterpret_cast< kdb::Key * >(argp3);
9666 : {
9667 : try {
9668 0 : result = (int)(arg1)->get(*arg2,*arg3);
9669 0 : } KDB_EXCEPTIONS catch (const std::exception & e) {
9670 0 : SWIG_exception(SWIG_RuntimeError, e.what());
9671 0 : } catch (...) {
9672 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::get(kdb::KeySet &,kdb::Key &)");
9673 : }
9674 : }
9675 : resultobj = SWIG_From_int(static_cast< int >(result));
9676 : return resultobj;
9677 : fail:
9678 : return NULL;
9679 : }
9680 :
9681 :
9682 4 : SWIGINTERN PyObject *_wrap_KDB_get(PyObject *self, PyObject *args) {
9683 : Py_ssize_t argc;
9684 : PyObject *argv[4] = {
9685 : 0
9686 4 : };
9687 :
9688 4 : if (!(argc = SWIG_Python_UnpackTuple(args,"KDB_get",0,3,argv))) SWIG_fail;
9689 4 : --argc;
9690 4 : if (argc == 3) {
9691 4 : int _v = 0;
9692 : {
9693 4 : void *vptr = 0;
9694 4 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_kdb__Key, 0);
9695 4 : _v = SWIG_CheckState(res);
9696 : }
9697 4 : if (!_v) goto check_1;
9698 0 : return _wrap_KDB_get__SWIG_1(self, argc, argv);
9699 : }
9700 : check_1:
9701 :
9702 4 : if (argc == 3) {
9703 4 : return _wrap_KDB_get__SWIG_0(self, argc, argv);
9704 : }
9705 :
9706 : fail:
9707 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'KDB_get'.\n"
9708 : " Possible C/C++ prototypes are:\n"
9709 : " kdb::KDB::get(kdb::KeySet &,std::string const &)\n"
9710 0 : " kdb::KDB::get(kdb::KeySet &,kdb::Key &)\n");
9711 : return 0;
9712 : }
9713 :
9714 :
9715 2 : SWIGINTERN PyObject *_wrap_KDB_set__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
9716 2 : PyObject *resultobj = 0;
9717 2 : kdb::KDB *arg1 = (kdb::KDB *) 0 ;
9718 2 : kdb::KeySet *arg2 = 0 ;
9719 2 : std::string *arg3 = 0 ;
9720 2 : void *argp1 = 0 ;
9721 2 : int res1 = 0 ;
9722 2 : void *argp2 = 0 ;
9723 2 : int res2 = 0 ;
9724 2 : int res3 = SWIG_OLDOBJ ;
9725 : int result;
9726 :
9727 2 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
9728 2 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 | 0 );
9729 2 : if (!SWIG_IsOK(res1)) {
9730 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_set" "', argument " "1"" of type '" "kdb::KDB *""'");
9731 : }
9732 2 : arg1 = reinterpret_cast< kdb::KDB * >(argp1);
9733 2 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet, 0 );
9734 2 : if (!SWIG_IsOK(res2)) {
9735 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_set" "', argument " "2"" of type '" "kdb::KeySet &""'");
9736 : }
9737 2 : if (!argp2) {
9738 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_set" "', argument " "2"" of type '" "kdb::KeySet &""'");
9739 : }
9740 2 : arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
9741 : {
9742 2 : std::string *ptr = (std::string *)0;
9743 2 : res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
9744 2 : if (!SWIG_IsOK(res3)) {
9745 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KDB_set" "', argument " "3"" of type '" "std::string const &""'");
9746 : }
9747 2 : if (!ptr) {
9748 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_set" "', argument " "3"" of type '" "std::string const &""'");
9749 : }
9750 2 : arg3 = ptr;
9751 : }
9752 : {
9753 : try {
9754 4 : result = (int)(arg1)->set(*arg2,(std::string const &)*arg3);
9755 0 : } KDB_EXCEPTIONS catch (const std::exception & e) {
9756 0 : SWIG_exception(SWIG_RuntimeError, e.what());
9757 0 : } catch (...) {
9758 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::set(kdb::KeySet &,std::string const &)");
9759 : }
9760 : }
9761 2 : resultobj = SWIG_From_int(static_cast< int >(result));
9762 4 : if (SWIG_IsNewObj(res3)) delete arg3;
9763 : return resultobj;
9764 : fail:
9765 0 : if (SWIG_IsNewObj(res3)) delete arg3;
9766 : return NULL;
9767 : }
9768 :
9769 :
9770 0 : SWIGINTERN PyObject *_wrap_KDB_set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
9771 0 : PyObject *resultobj = 0;
9772 0 : kdb::KDB *arg1 = (kdb::KDB *) 0 ;
9773 0 : kdb::KeySet *arg2 = 0 ;
9774 0 : kdb::Key *arg3 = 0 ;
9775 0 : void *argp1 = 0 ;
9776 0 : int res1 = 0 ;
9777 0 : void *argp2 = 0 ;
9778 0 : int res2 = 0 ;
9779 0 : void *argp3 = 0 ;
9780 0 : int res3 = 0 ;
9781 : int result;
9782 :
9783 0 : if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
9784 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 | 0 );
9785 0 : if (!SWIG_IsOK(res1)) {
9786 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_set" "', argument " "1"" of type '" "kdb::KDB *""'");
9787 : }
9788 0 : arg1 = reinterpret_cast< kdb::KDB * >(argp1);
9789 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet, 0 );
9790 0 : if (!SWIG_IsOK(res2)) {
9791 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_set" "', argument " "2"" of type '" "kdb::KeySet &""'");
9792 : }
9793 0 : if (!argp2) {
9794 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_set" "', argument " "2"" of type '" "kdb::KeySet &""'");
9795 : }
9796 0 : arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
9797 0 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_kdb__Key, 0 );
9798 0 : if (!SWIG_IsOK(res3)) {
9799 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KDB_set" "', argument " "3"" of type '" "kdb::Key &""'");
9800 : }
9801 0 : if (!argp3) {
9802 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_set" "', argument " "3"" of type '" "kdb::Key &""'");
9803 : }
9804 0 : arg3 = reinterpret_cast< kdb::Key * >(argp3);
9805 : {
9806 : try {
9807 0 : result = (int)(arg1)->set(*arg2,*arg3);
9808 0 : } KDB_EXCEPTIONS catch (const std::exception & e) {
9809 0 : SWIG_exception(SWIG_RuntimeError, e.what());
9810 0 : } catch (...) {
9811 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::set(kdb::KeySet &,kdb::Key &)");
9812 : }
9813 : }
9814 : resultobj = SWIG_From_int(static_cast< int >(result));
9815 : return resultobj;
9816 : fail:
9817 : return NULL;
9818 : }
9819 :
9820 :
9821 2 : SWIGINTERN PyObject *_wrap_KDB_set(PyObject *self, PyObject *args) {
9822 : Py_ssize_t argc;
9823 : PyObject *argv[4] = {
9824 : 0
9825 2 : };
9826 :
9827 2 : if (!(argc = SWIG_Python_UnpackTuple(args,"KDB_set",0,3,argv))) SWIG_fail;
9828 2 : --argc;
9829 2 : if (argc == 3) {
9830 2 : int _v = 0;
9831 : {
9832 2 : void *vptr = 0;
9833 2 : int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_kdb__Key, 0);
9834 2 : _v = SWIG_CheckState(res);
9835 : }
9836 2 : if (!_v) goto check_1;
9837 0 : return _wrap_KDB_set__SWIG_1(self, argc, argv);
9838 : }
9839 : check_1:
9840 :
9841 2 : if (argc == 3) {
9842 2 : return _wrap_KDB_set__SWIG_0(self, argc, argv);
9843 : }
9844 :
9845 : fail:
9846 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'KDB_set'.\n"
9847 : " Possible C/C++ prototypes are:\n"
9848 : " kdb::KDB::set(kdb::KeySet &,std::string const &)\n"
9849 0 : " kdb::KDB::set(kdb::KeySet &,kdb::Key &)\n");
9850 : return 0;
9851 : }
9852 :
9853 :
9854 0 : SWIGINTERN PyObject *_wrap_KDB_ensure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9855 0 : PyObject *resultobj = 0;
9856 0 : kdb::KDB *arg1 = (kdb::KDB *) 0 ;
9857 0 : kdb::KeySet *arg2 = 0 ;
9858 0 : kdb::Key *arg3 = 0 ;
9859 0 : void *argp1 = 0 ;
9860 0 : int res1 = 0 ;
9861 0 : void *argp2 = 0 ;
9862 0 : int res2 = 0 ;
9863 0 : void *argp3 = 0 ;
9864 0 : int res3 = 0 ;
9865 : PyObject *swig_obj[3] ;
9866 : int result;
9867 :
9868 0 : if (!SWIG_Python_UnpackTuple(args,"KDB_ensure",3,3,swig_obj)) SWIG_fail;
9869 0 : res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_kdb__KDB, 0 | 0 );
9870 0 : if (!SWIG_IsOK(res1)) {
9871 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDB_ensure" "', argument " "1"" of type '" "kdb::KDB *""'");
9872 : }
9873 0 : arg1 = reinterpret_cast< kdb::KDB * >(argp1);
9874 0 : res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_kdb__KeySet, 0 | 0);
9875 0 : if (!SWIG_IsOK(res2)) {
9876 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KDB_ensure" "', argument " "2"" of type '" "kdb::KeySet const &""'");
9877 : }
9878 0 : if (!argp2) {
9879 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_ensure" "', argument " "2"" of type '" "kdb::KeySet const &""'");
9880 : }
9881 0 : arg2 = reinterpret_cast< kdb::KeySet * >(argp2);
9882 0 : res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_kdb__Key, 0 );
9883 0 : if (!SWIG_IsOK(res3)) {
9884 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KDB_ensure" "', argument " "3"" of type '" "kdb::Key &""'");
9885 : }
9886 0 : if (!argp3) {
9887 0 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KDB_ensure" "', argument " "3"" of type '" "kdb::Key &""'");
9888 : }
9889 0 : arg3 = reinterpret_cast< kdb::Key * >(argp3);
9890 : {
9891 : try {
9892 0 : result = (int)(arg1)->ensure((kdb::KeySet const &)*arg2,*arg3);
9893 0 : } KDB_EXCEPTIONS catch (const std::exception & e) {
9894 0 : SWIG_exception(SWIG_RuntimeError, e.what());
9895 0 : } catch (...) {
9896 0 : SWIG_exception(SWIG_UnknownError, "unknown error in kdb::KDB::ensure(kdb::KeySet const &,kdb::Key &)");
9897 : }
9898 : }
9899 : resultobj = SWIG_From_int(static_cast< int >(result));
9900 : return resultobj;
9901 : fail:
9902 : return NULL;
9903 : }
9904 :
9905 :
9906 3 : SWIGINTERN PyObject *KDB_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9907 : PyObject *obj;
9908 3 : if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9909 6 : SWIG_TypeNewClientData(SWIGTYPE_p_kdb__KDB, SWIG_NewClientData(obj));
9910 3 : return SWIG_Py_Void();
9911 : }
9912 :
9913 6 : SWIGINTERN PyObject *KDB_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9914 6 : return SWIG_Python_InitShadowInstance(args);
9915 : }
9916 :
9917 : static PyMethodDef SwigMethods[] = {
9918 : { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
9919 : { (char *)"delete_SwigPyIterator", (PyCFunction)_wrap_delete_SwigPyIterator, METH_O, NULL},
9920 : { (char *)"SwigPyIterator_value", (PyCFunction)_wrap_SwigPyIterator_value, METH_O, NULL},
9921 : { (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
9922 : { (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
9923 : { (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
9924 : { (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
9925 : { (char *)"SwigPyIterator_copy", (PyCFunction)_wrap_SwigPyIterator_copy, METH_O, NULL},
9926 : { (char *)"SwigPyIterator_next", (PyCFunction)_wrap_SwigPyIterator_next, METH_O, NULL},
9927 : { (char *)"SwigPyIterator___next__", (PyCFunction)_wrap_SwigPyIterator___next__, METH_O, NULL},
9928 : { (char *)"SwigPyIterator_previous", (PyCFunction)_wrap_SwigPyIterator_previous, METH_O, NULL},
9929 : { (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
9930 : { (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
9931 : { (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
9932 : { (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
9933 : { (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
9934 : { (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
9935 : { (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
9936 : { (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
9937 : { (char *)"Exception_what", (PyCFunction)_wrap_Exception_what, METH_O, (char *)"\n"
9938 : "Exception_what(Exception self) -> char const *\n"
9939 : "\n"
9940 : "Parameters\n"
9941 : "----------\n"
9942 : "self: kdb::Exception const *\n"
9943 : "\n"
9944 : ""},
9945 : { (char *)"new_Exception", (PyCFunction)_wrap_new_Exception, METH_NOARGS, (char *)"new_Exception() -> Exception"},
9946 : { (char *)"delete_Exception", (PyCFunction)_wrap_delete_Exception, METH_O, (char *)"\n"
9947 : "delete_Exception(Exception self)\n"
9948 : "\n"
9949 : "Parameters\n"
9950 : "----------\n"
9951 : "self: kdb::Exception *\n"
9952 : "\n"
9953 : ""},
9954 : { (char *)"Exception_swigregister", Exception_swigregister, METH_VARARGS, NULL},
9955 : { (char *)"Exception_swiginit", Exception_swiginit, METH_VARARGS, NULL},
9956 : { (char *)"new_KeyException", (PyCFunction)_wrap_new_KeyException, METH_NOARGS, (char *)"new_KeyException() -> KeyException"},
9957 : { (char *)"delete_KeyException", (PyCFunction)_wrap_delete_KeyException, METH_O, (char *)"\n"
9958 : "delete_KeyException(KeyException self)\n"
9959 : "\n"
9960 : "Parameters\n"
9961 : "----------\n"
9962 : "self: kdb::KeyException *\n"
9963 : "\n"
9964 : ""},
9965 : { (char *)"KeyException_swigregister", KeyException_swigregister, METH_VARARGS, NULL},
9966 : { (char *)"KeyException_swiginit", KeyException_swiginit, METH_VARARGS, NULL},
9967 : { (char *)"new_KeyNotFoundException", (PyCFunction)_wrap_new_KeyNotFoundException, METH_O, (char *)"\n"
9968 : "new_KeyNotFoundException(std::string message) -> KeyNotFoundException\n"
9969 : "\n"
9970 : "Parameters\n"
9971 : "----------\n"
9972 : "message: std::string\n"
9973 : "\n"
9974 : ""},
9975 : { (char *)"delete_KeyNotFoundException", (PyCFunction)_wrap_delete_KeyNotFoundException, METH_O, (char *)"\n"
9976 : "delete_KeyNotFoundException(KeyNotFoundException self)\n"
9977 : "\n"
9978 : "Parameters\n"
9979 : "----------\n"
9980 : "self: kdb::KeyNotFoundException *\n"
9981 : "\n"
9982 : ""},
9983 : { (char *)"KeyNotFoundException_swigregister", KeyNotFoundException_swigregister, METH_VARARGS, NULL},
9984 : { (char *)"KeyNotFoundException_swiginit", KeyNotFoundException_swiginit, METH_VARARGS, NULL},
9985 : { (char *)"new_KeyTypeMismatch", (PyCFunction)_wrap_new_KeyTypeMismatch, METH_NOARGS, (char *)"new_KeyTypeMismatch() -> KeyTypeMismatch"},
9986 : { (char *)"delete_KeyTypeMismatch", (PyCFunction)_wrap_delete_KeyTypeMismatch, METH_O, (char *)"\n"
9987 : "delete_KeyTypeMismatch(KeyTypeMismatch self)\n"
9988 : "\n"
9989 : "Parameters\n"
9990 : "----------\n"
9991 : "self: kdb::KeyTypeMismatch *\n"
9992 : "\n"
9993 : ""},
9994 : { (char *)"KeyTypeMismatch_swigregister", KeyTypeMismatch_swigregister, METH_VARARGS, NULL},
9995 : { (char *)"KeyTypeMismatch_swiginit", KeyTypeMismatch_swiginit, METH_VARARGS, NULL},
9996 : { (char *)"new_KeyTypeConversion", (PyCFunction)_wrap_new_KeyTypeConversion, METH_NOARGS, (char *)"new_KeyTypeConversion() -> KeyTypeConversion"},
9997 : { (char *)"delete_KeyTypeConversion", (PyCFunction)_wrap_delete_KeyTypeConversion, METH_O, (char *)"\n"
9998 : "delete_KeyTypeConversion(KeyTypeConversion self)\n"
9999 : "\n"
10000 : "Parameters\n"
10001 : "----------\n"
10002 : "self: kdb::KeyTypeConversion *\n"
10003 : "\n"
10004 : ""},
10005 : { (char *)"KeyTypeConversion_swigregister", KeyTypeConversion_swigregister, METH_VARARGS, NULL},
10006 : { (char *)"KeyTypeConversion_swiginit", KeyTypeConversion_swiginit, METH_VARARGS, NULL},
10007 : { (char *)"new_KeyInvalidName", (PyCFunction)_wrap_new_KeyInvalidName, METH_NOARGS, (char *)"new_KeyInvalidName() -> KeyInvalidName"},
10008 : { (char *)"delete_KeyInvalidName", (PyCFunction)_wrap_delete_KeyInvalidName, METH_O, (char *)"\n"
10009 : "delete_KeyInvalidName(KeyInvalidName self)\n"
10010 : "\n"
10011 : "Parameters\n"
10012 : "----------\n"
10013 : "self: kdb::KeyInvalidName *\n"
10014 : "\n"
10015 : ""},
10016 : { (char *)"KeyInvalidName_swigregister", KeyInvalidName_swigregister, METH_VARARGS, NULL},
10017 : { (char *)"KeyInvalidName_swiginit", KeyInvalidName_swiginit, METH_VARARGS, NULL},
10018 : { (char *)"new_KDBException", (PyCFunction)_wrap_new_KDBException, METH_O, (char *)"\n"
10019 : "new_KDBException(Key key) -> KDBException\n"
10020 : "\n"
10021 : "Parameters\n"
10022 : "----------\n"
10023 : "key: Key\n"
10024 : "\n"
10025 : ""},
10026 : { (char *)"delete_KDBException", (PyCFunction)_wrap_delete_KDBException, METH_O, (char *)"\n"
10027 : "delete_KDBException(KDBException self)\n"
10028 : "\n"
10029 : "Parameters\n"
10030 : "----------\n"
10031 : "self: kdb::KDBException *\n"
10032 : "\n"
10033 : ""},
10034 : { (char *)"KDBException_whatWithArguments", _wrap_KDBException_whatWithArguments, METH_VARARGS, (char *)"\n"
10035 : "KDBException_whatWithArguments(KDBException self, bool printVerbose, bool printDebug) -> char const *\n"
10036 : "\n"
10037 : "Parameters\n"
10038 : "----------\n"
10039 : "self: kdb::KDBException const *\n"
10040 : "printVerbose: bool\n"
10041 : "printDebug: bool\n"
10042 : "\n"
10043 : ""},
10044 : { (char *)"KDBException_swigregister", KDBException_swigregister, METH_VARARGS, NULL},
10045 : { (char *)"KDBException_swiginit", KDBException_swiginit, METH_VARARGS, NULL},
10046 : { (char *)"new_ContractException", (PyCFunction)_wrap_new_ContractException, METH_O, (char *)"\n"
10047 : "new_ContractException(Key key) -> ContractException\n"
10048 : "\n"
10049 : "Parameters\n"
10050 : "----------\n"
10051 : "key: Key\n"
10052 : "\n"
10053 : ""},
10054 : { (char *)"delete_ContractException", (PyCFunction)_wrap_delete_ContractException, METH_O, (char *)"\n"
10055 : "delete_ContractException(ContractException self)\n"
10056 : "\n"
10057 : "Parameters\n"
10058 : "----------\n"
10059 : "self: kdb::ContractException *\n"
10060 : "\n"
10061 : ""},
10062 : { (char *)"ContractException_swigregister", ContractException_swigregister, METH_VARARGS, NULL},
10063 : { (char *)"ContractException_swiginit", ContractException_swiginit, METH_VARARGS, NULL},
10064 : { (char *)"Key__incRef", (PyCFunction)_wrap_Key__incRef, METH_O, (char *)"\n"
10065 : "Key__incRef(Key self)\n"
10066 : "\n"
10067 : "Parameters\n"
10068 : "----------\n"
10069 : "self: kdb::Key const *\n"
10070 : "\n"
10071 : ""},
10072 : { (char *)"Key__decRef", (PyCFunction)_wrap_Key__decRef, METH_O, (char *)"\n"
10073 : "Key__decRef(Key self)\n"
10074 : "\n"
10075 : "Parameters\n"
10076 : "----------\n"
10077 : "self: kdb::Key const *\n"
10078 : "\n"
10079 : ""},
10080 : { (char *)"Key_getReferenceCounter", (PyCFunction)_wrap_Key_getReferenceCounter, METH_O, (char *)"\n"
10081 : "Key_getReferenceCounter(Key self) -> ssize_t\n"
10082 : "\n"
10083 : "Parameters\n"
10084 : "----------\n"
10085 : "self: kdb::Key const *\n"
10086 : "\n"
10087 : ""},
10088 : { (char *)"Key_copy", _wrap_Key_copy, METH_VARARGS, (char *)"\n"
10089 : "Key_copy(Key self, Key other)\n"
10090 : "\n"
10091 : "Parameters\n"
10092 : "----------\n"
10093 : "self: kdb::Key *\n"
10094 : "other: kdb::Key const &\n"
10095 : "\n"
10096 : ""},
10097 : { (char *)"Key_clear", (PyCFunction)_wrap_Key_clear, METH_O, (char *)"\n"
10098 : "Key_clear(Key self)\n"
10099 : "\n"
10100 : "Parameters\n"
10101 : "----------\n"
10102 : "self: kdb::Key *\n"
10103 : "\n"
10104 : ""},
10105 : { (char *)"Key_getKey", (PyCFunction)_wrap_Key_getKey, METH_O, (char *)"\n"
10106 : "Key_getKey(Key self) -> ckdb::Key *\n"
10107 : "\n"
10108 : "Parameters\n"
10109 : "----------\n"
10110 : "self: kdb::Key const *\n"
10111 : "\n"
10112 : ""},
10113 : { (char *)"Key___ref__", (PyCFunction)_wrap_Key___ref__, METH_O, (char *)"\n"
10114 : "Key___ref__(Key self) -> ckdb::Key *\n"
10115 : "\n"
10116 : "Parameters\n"
10117 : "----------\n"
10118 : "self: kdb::Key const *\n"
10119 : "\n"
10120 : ""},
10121 : { (char *)"Key_release", (PyCFunction)_wrap_Key_release, METH_O, (char *)"\n"
10122 : "Key_release(Key self) -> ckdb::Key *\n"
10123 : "\n"
10124 : "Parameters\n"
10125 : "----------\n"
10126 : "self: kdb::Key *\n"
10127 : "\n"
10128 : ""},
10129 : { (char *)"Key_dup", (PyCFunction)_wrap_Key_dup, METH_O, (char *)"\n"
10130 : "Key_dup(Key self) -> ckdb::Key *\n"
10131 : "\n"
10132 : "Parameters\n"
10133 : "----------\n"
10134 : "self: kdb::Key const *\n"
10135 : "\n"
10136 : ""},
10137 : { (char *)"delete_Key", (PyCFunction)_wrap_delete_Key, METH_O, (char *)"\n"
10138 : "delete_Key(Key self)\n"
10139 : "\n"
10140 : "Parameters\n"
10141 : "----------\n"
10142 : "self: kdb::Key *\n"
10143 : "\n"
10144 : ""},
10145 : { (char *)"Key__getName", (PyCFunction)_wrap_Key__getName, METH_O, (char *)"\n"
10146 : "Key__getName(Key self) -> std::string\n"
10147 : "\n"
10148 : "Parameters\n"
10149 : "----------\n"
10150 : "self: kdb::Key const *\n"
10151 : "\n"
10152 : ""},
10153 : { (char *)"Key__getNameSize", (PyCFunction)_wrap_Key__getNameSize, METH_O, (char *)"\n"
10154 : "Key__getNameSize(Key self) -> ssize_t\n"
10155 : "\n"
10156 : "Parameters\n"
10157 : "----------\n"
10158 : "self: kdb::Key const *\n"
10159 : "\n"
10160 : ""},
10161 : { (char *)"Key__getBaseName", (PyCFunction)_wrap_Key__getBaseName, METH_O, (char *)"\n"
10162 : "Key__getBaseName(Key self) -> std::string\n"
10163 : "\n"
10164 : "Parameters\n"
10165 : "----------\n"
10166 : "self: kdb::Key const *\n"
10167 : "\n"
10168 : ""},
10169 : { (char *)"Key__getBaseNameSize", (PyCFunction)_wrap_Key__getBaseNameSize, METH_O, (char *)"\n"
10170 : "Key__getBaseNameSize(Key self) -> ssize_t\n"
10171 : "\n"
10172 : "Parameters\n"
10173 : "----------\n"
10174 : "self: kdb::Key const *\n"
10175 : "\n"
10176 : ""},
10177 : { (char *)"Key__setName", _wrap_Key__setName, METH_VARARGS, (char *)"\n"
10178 : "Key__setName(Key self, std::string const & newName)\n"
10179 : "\n"
10180 : "Parameters\n"
10181 : "----------\n"
10182 : "self: kdb::Key *\n"
10183 : "newName: std::string const &\n"
10184 : "\n"
10185 : ""},
10186 : { (char *)"Key_addName", _wrap_Key_addName, METH_VARARGS, (char *)"\n"
10187 : "Key_addName(Key self, std::string const & addedName)\n"
10188 : "\n"
10189 : "Parameters\n"
10190 : "----------\n"
10191 : "self: kdb::Key *\n"
10192 : "addedName: std::string const &\n"
10193 : "\n"
10194 : ""},
10195 : { (char *)"Key__setBaseName", _wrap_Key__setBaseName, METH_VARARGS, (char *)"\n"
10196 : "Key__setBaseName(Key self, std::string const & baseName)\n"
10197 : "\n"
10198 : "Parameters\n"
10199 : "----------\n"
10200 : "self: kdb::Key *\n"
10201 : "baseName: std::string const &\n"
10202 : "\n"
10203 : ""},
10204 : { (char *)"Key_addBaseName", _wrap_Key_addBaseName, METH_VARARGS, (char *)"\n"
10205 : "Key_addBaseName(Key self, std::string const & baseName)\n"
10206 : "\n"
10207 : "Parameters\n"
10208 : "----------\n"
10209 : "self: kdb::Key *\n"
10210 : "baseName: std::string const &\n"
10211 : "\n"
10212 : ""},
10213 : { (char *)"Key_delBaseName", (PyCFunction)_wrap_Key_delBaseName, METH_O, (char *)"\n"
10214 : "Key_delBaseName(Key self)\n"
10215 : "\n"
10216 : "Parameters\n"
10217 : "----------\n"
10218 : "self: kdb::Key *\n"
10219 : "\n"
10220 : ""},
10221 : { (char *)"Key__getFullNameSize", (PyCFunction)_wrap_Key__getFullNameSize, METH_O, (char *)"\n"
10222 : "Key__getFullNameSize(Key self) -> ssize_t\n"
10223 : "\n"
10224 : "Parameters\n"
10225 : "----------\n"
10226 : "self: kdb::Key const *\n"
10227 : "\n"
10228 : ""},
10229 : { (char *)"Key__getFullName", (PyCFunction)_wrap_Key__getFullName, METH_O, (char *)"\n"
10230 : "Key__getFullName(Key self) -> std::string\n"
10231 : "\n"
10232 : "Parameters\n"
10233 : "----------\n"
10234 : "self: kdb::Key const *\n"
10235 : "\n"
10236 : ""},
10237 : { (char *)"Key___eq__", _wrap_Key___eq__, METH_VARARGS, (char *)"\n"
10238 : "Key___eq__(Key self, Key k) -> bool\n"
10239 : "\n"
10240 : "Parameters\n"
10241 : "----------\n"
10242 : "self: kdb::Key const *\n"
10243 : "k: kdb::Key const &\n"
10244 : "\n"
10245 : ""},
10246 : { (char *)"Key___ne__", _wrap_Key___ne__, METH_VARARGS, (char *)"\n"
10247 : "Key___ne__(Key self, Key k) -> bool\n"
10248 : "\n"
10249 : "Parameters\n"
10250 : "----------\n"
10251 : "self: kdb::Key const *\n"
10252 : "k: kdb::Key const &\n"
10253 : "\n"
10254 : ""},
10255 : { (char *)"Key___lt__", _wrap_Key___lt__, METH_VARARGS, (char *)"\n"
10256 : "Key___lt__(Key self, Key other) -> bool\n"
10257 : "\n"
10258 : "Parameters\n"
10259 : "----------\n"
10260 : "self: kdb::Key const *\n"
10261 : "other: kdb::Key const &\n"
10262 : "\n"
10263 : ""},
10264 : { (char *)"Key___le__", _wrap_Key___le__, METH_VARARGS, (char *)"\n"
10265 : "Key___le__(Key self, Key other) -> bool\n"
10266 : "\n"
10267 : "Parameters\n"
10268 : "----------\n"
10269 : "self: kdb::Key const *\n"
10270 : "other: kdb::Key const &\n"
10271 : "\n"
10272 : ""},
10273 : { (char *)"Key___gt__", _wrap_Key___gt__, METH_VARARGS, (char *)"\n"
10274 : "Key___gt__(Key self, Key other) -> bool\n"
10275 : "\n"
10276 : "Parameters\n"
10277 : "----------\n"
10278 : "self: kdb::Key const *\n"
10279 : "other: kdb::Key const &\n"
10280 : "\n"
10281 : ""},
10282 : { (char *)"Key___ge__", _wrap_Key___ge__, METH_VARARGS, (char *)"\n"
10283 : "Key___ge__(Key self, Key other) -> bool\n"
10284 : "\n"
10285 : "Parameters\n"
10286 : "----------\n"
10287 : "self: kdb::Key const *\n"
10288 : "other: kdb::Key const &\n"
10289 : "\n"
10290 : ""},
10291 : { (char *)"Key_isNull", (PyCFunction)_wrap_Key_isNull, METH_O, (char *)"\n"
10292 : "Key_isNull(Key self) -> bool\n"
10293 : "\n"
10294 : "Parameters\n"
10295 : "----------\n"
10296 : "self: kdb::Key const *\n"
10297 : "\n"
10298 : ""},
10299 : { (char *)"Key___nonzero__", (PyCFunction)_wrap_Key___nonzero__, METH_O, (char *)"\n"
10300 : "Key___nonzero__(Key self) -> bool\n"
10301 : "\n"
10302 : "Parameters\n"
10303 : "----------\n"
10304 : "self: kdb::Key const *\n"
10305 : "\n"
10306 : ""},
10307 : { (char *)"Key_needSync", (PyCFunction)_wrap_Key_needSync, METH_O, (char *)"\n"
10308 : "Key_needSync(Key self) -> bool\n"
10309 : "\n"
10310 : "Parameters\n"
10311 : "----------\n"
10312 : "self: kdb::Key const *\n"
10313 : "\n"
10314 : ""},
10315 : { (char *)"Key__getString", (PyCFunction)_wrap_Key__getString, METH_O, (char *)"\n"
10316 : "Key__getString(Key self) -> std::string\n"
10317 : "\n"
10318 : "Parameters\n"
10319 : "----------\n"
10320 : "self: kdb::Key const *\n"
10321 : "\n"
10322 : ""},
10323 : { (char *)"Key__setString", _wrap_Key__setString, METH_VARARGS, (char *)"\n"
10324 : "Key__setString(Key self, std::string newString)\n"
10325 : "\n"
10326 : "Parameters\n"
10327 : "----------\n"
10328 : "self: kdb::Key *\n"
10329 : "newString: std::string\n"
10330 : "\n"
10331 : ""},
10332 : { (char *)"Key__getStringSize", (PyCFunction)_wrap_Key__getStringSize, METH_O, (char *)"\n"
10333 : "Key__getStringSize(Key self) -> ssize_t\n"
10334 : "\n"
10335 : "Parameters\n"
10336 : "----------\n"
10337 : "self: kdb::Key const *\n"
10338 : "\n"
10339 : ""},
10340 : { (char *)"Key__getFunc", (PyCFunction)_wrap_Key__getFunc, METH_O, (char *)"\n"
10341 : "Key__getFunc(Key self) -> kdb::Key::func_t\n"
10342 : "\n"
10343 : "Parameters\n"
10344 : "----------\n"
10345 : "self: kdb::Key const *\n"
10346 : "\n"
10347 : ""},
10348 : { (char *)"Key_setCallback", _wrap_Key_setCallback, METH_VARARGS, (char *)"\n"
10349 : "Key_setCallback(Key self, kdb::Key::callback_t fct)\n"
10350 : "\n"
10351 : "Parameters\n"
10352 : "----------\n"
10353 : "self: kdb::Key *\n"
10354 : "fct: kdb::Key::callback_t\n"
10355 : "\n"
10356 : ""},
10357 : { (char *)"Key__getValue", (PyCFunction)_wrap_Key__getValue, METH_O, (char *)"\n"
10358 : "Key__getValue(Key self) -> void const *\n"
10359 : "\n"
10360 : "Parameters\n"
10361 : "----------\n"
10362 : "self: kdb::Key const *\n"
10363 : "\n"
10364 : ""},
10365 : { (char *)"Key__getBinary", (PyCFunction)_wrap_Key__getBinary, METH_O, (char *)"\n"
10366 : "Key__getBinary(Key self) -> std::string\n"
10367 : "\n"
10368 : "Parameters\n"
10369 : "----------\n"
10370 : "self: kdb::Key const *\n"
10371 : "\n"
10372 : ""},
10373 : { (char *)"Key__getBinarySize", (PyCFunction)_wrap_Key__getBinarySize, METH_O, (char *)"\n"
10374 : "Key__getBinarySize(Key self) -> ssize_t\n"
10375 : "\n"
10376 : "Parameters\n"
10377 : "----------\n"
10378 : "self: kdb::Key const *\n"
10379 : "\n"
10380 : ""},
10381 : { (char *)"Key__setBinary", _wrap_Key__setBinary, METH_VARARGS, (char *)"\n"
10382 : "Key__setBinary(Key self, void const * newBinary) -> ssize_t\n"
10383 : "\n"
10384 : "Parameters\n"
10385 : "----------\n"
10386 : "self: kdb::Key *\n"
10387 : "newBinary: void const *\n"
10388 : "\n"
10389 : ""},
10390 : { (char *)"Key_hasMeta", _wrap_Key_hasMeta, METH_VARARGS, (char *)"\n"
10391 : "Key_hasMeta(Key self, std::string const & metaName) -> bool\n"
10392 : "\n"
10393 : "Parameters\n"
10394 : "----------\n"
10395 : "self: kdb::Key const *\n"
10396 : "metaName: std::string const &\n"
10397 : "\n"
10398 : ""},
10399 : { (char *)"Key_delMeta", _wrap_Key_delMeta, METH_VARARGS, (char *)"\n"
10400 : "Key_delMeta(Key self, std::string const & metaName)\n"
10401 : "\n"
10402 : "Parameters\n"
10403 : "----------\n"
10404 : "self: kdb::Key *\n"
10405 : "metaName: std::string const &\n"
10406 : "\n"
10407 : ""},
10408 : { (char *)"Key_copyMeta", _wrap_Key_copyMeta, METH_VARARGS, (char *)"\n"
10409 : "Key_copyMeta(Key self, Key other, std::string const & metaName)\n"
10410 : "\n"
10411 : "Parameters\n"
10412 : "----------\n"
10413 : "self: kdb::Key *\n"
10414 : "other: kdb::Key const &\n"
10415 : "metaName: std::string const &\n"
10416 : "\n"
10417 : ""},
10418 : { (char *)"Key_copyAllMeta", _wrap_Key_copyAllMeta, METH_VARARGS, (char *)"\n"
10419 : "Key_copyAllMeta(Key self, Key other)\n"
10420 : "\n"
10421 : "Parameters\n"
10422 : "----------\n"
10423 : "self: kdb::Key *\n"
10424 : "other: kdb::Key const &\n"
10425 : "\n"
10426 : ""},
10427 : { (char *)"Key__rewindMeta", (PyCFunction)_wrap_Key__rewindMeta, METH_O, (char *)"\n"
10428 : "Key__rewindMeta(Key self)\n"
10429 : "\n"
10430 : "Parameters\n"
10431 : "----------\n"
10432 : "self: kdb::Key *\n"
10433 : "\n"
10434 : ""},
10435 : { (char *)"Key__nextMeta", (PyCFunction)_wrap_Key__nextMeta, METH_O, (char *)"\n"
10436 : "Key__nextMeta(Key self) -> Key\n"
10437 : "\n"
10438 : "Parameters\n"
10439 : "----------\n"
10440 : "self: kdb::Key *\n"
10441 : "\n"
10442 : ""},
10443 : { (char *)"Key__currentMeta", (PyCFunction)_wrap_Key__currentMeta, METH_O, (char *)"\n"
10444 : "Key__currentMeta(Key self) -> Key\n"
10445 : "\n"
10446 : "Parameters\n"
10447 : "----------\n"
10448 : "self: kdb::Key const *\n"
10449 : "\n"
10450 : ""},
10451 : { (char *)"Key_isValid", (PyCFunction)_wrap_Key_isValid, METH_O, (char *)"\n"
10452 : "Key_isValid(Key self) -> bool\n"
10453 : "\n"
10454 : "Parameters\n"
10455 : "----------\n"
10456 : "self: kdb::Key const *\n"
10457 : "\n"
10458 : ""},
10459 : { (char *)"Key_getNamespace", (PyCFunction)_wrap_Key_getNamespace, METH_O, (char *)"\n"
10460 : "Key_getNamespace(Key self) -> std::string\n"
10461 : "\n"
10462 : "Parameters\n"
10463 : "----------\n"
10464 : "self: kdb::Key const *\n"
10465 : "\n"
10466 : ""},
10467 : { (char *)"Key_isCascading", (PyCFunction)_wrap_Key_isCascading, METH_O, (char *)"\n"
10468 : "Key_isCascading(Key self) -> bool\n"
10469 : "\n"
10470 : "Parameters\n"
10471 : "----------\n"
10472 : "self: kdb::Key const *\n"
10473 : "\n"
10474 : ""},
10475 : { (char *)"Key_isSpec", (PyCFunction)_wrap_Key_isSpec, METH_O, (char *)"\n"
10476 : "Key_isSpec(Key self) -> bool\n"
10477 : "\n"
10478 : "Parameters\n"
10479 : "----------\n"
10480 : "self: kdb::Key const *\n"
10481 : "\n"
10482 : ""},
10483 : { (char *)"Key_isProc", (PyCFunction)_wrap_Key_isProc, METH_O, (char *)"\n"
10484 : "Key_isProc(Key self) -> bool\n"
10485 : "\n"
10486 : "Parameters\n"
10487 : "----------\n"
10488 : "self: kdb::Key const *\n"
10489 : "\n"
10490 : ""},
10491 : { (char *)"Key_isDir", (PyCFunction)_wrap_Key_isDir, METH_O, (char *)"\n"
10492 : "Key_isDir(Key self) -> bool\n"
10493 : "\n"
10494 : "Parameters\n"
10495 : "----------\n"
10496 : "self: kdb::Key const *\n"
10497 : "\n"
10498 : ""},
10499 : { (char *)"Key_isUser", (PyCFunction)_wrap_Key_isUser, METH_O, (char *)"\n"
10500 : "Key_isUser(Key self) -> bool\n"
10501 : "\n"
10502 : "Parameters\n"
10503 : "----------\n"
10504 : "self: kdb::Key const *\n"
10505 : "\n"
10506 : ""},
10507 : { (char *)"Key_isSystem", (PyCFunction)_wrap_Key_isSystem, METH_O, (char *)"\n"
10508 : "Key_isSystem(Key self) -> bool\n"
10509 : "\n"
10510 : "Parameters\n"
10511 : "----------\n"
10512 : "self: kdb::Key const *\n"
10513 : "\n"
10514 : ""},
10515 : { (char *)"Key_isString", (PyCFunction)_wrap_Key_isString, METH_O, (char *)"\n"
10516 : "Key_isString(Key self) -> bool\n"
10517 : "\n"
10518 : "Parameters\n"
10519 : "----------\n"
10520 : "self: kdb::Key const *\n"
10521 : "\n"
10522 : ""},
10523 : { (char *)"Key_isBinary", (PyCFunction)_wrap_Key_isBinary, METH_O, (char *)"\n"
10524 : "Key_isBinary(Key self) -> bool\n"
10525 : "\n"
10526 : "Parameters\n"
10527 : "----------\n"
10528 : "self: kdb::Key const *\n"
10529 : "\n"
10530 : ""},
10531 : { (char *)"Key_isInactive", (PyCFunction)_wrap_Key_isInactive, METH_O, (char *)"\n"
10532 : "Key_isInactive(Key self) -> bool\n"
10533 : "\n"
10534 : "Parameters\n"
10535 : "----------\n"
10536 : "self: kdb::Key const *\n"
10537 : "\n"
10538 : ""},
10539 : { (char *)"Key_isBelow", _wrap_Key_isBelow, METH_VARARGS, (char *)"\n"
10540 : "Key_isBelow(Key self, Key k) -> bool\n"
10541 : "\n"
10542 : "Parameters\n"
10543 : "----------\n"
10544 : "self: kdb::Key const *\n"
10545 : "k: kdb::Key const &\n"
10546 : "\n"
10547 : ""},
10548 : { (char *)"Key_isBelowOrSame", _wrap_Key_isBelowOrSame, METH_VARARGS, (char *)"\n"
10549 : "Key_isBelowOrSame(Key self, Key k) -> bool\n"
10550 : "\n"
10551 : "Parameters\n"
10552 : "----------\n"
10553 : "self: kdb::Key const *\n"
10554 : "k: kdb::Key const &\n"
10555 : "\n"
10556 : ""},
10557 : { (char *)"Key_isDirectBelow", _wrap_Key_isDirectBelow, METH_VARARGS, (char *)"\n"
10558 : "Key_isDirectBelow(Key self, Key k) -> bool\n"
10559 : "\n"
10560 : "Parameters\n"
10561 : "----------\n"
10562 : "self: kdb::Key const *\n"
10563 : "k: kdb::Key const &\n"
10564 : "\n"
10565 : ""},
10566 : { (char *)"new_Key", _wrap_new_Key, METH_VARARGS, (char *)"\n"
10567 : "Key()\n"
10568 : "Key(ckdb::Key * k)\n"
10569 : "\n"
10570 : "Parameters\n"
10571 : "----------\n"
10572 : "k: ckdb::Key *\n"
10573 : "\n"
10574 : "Key(Key k)\n"
10575 : "\n"
10576 : "Parameters\n"
10577 : "----------\n"
10578 : "k: kdb::Key &\n"
10579 : "\n"
10580 : "Key(char const * name, int flags=0)\n"
10581 : "\n"
10582 : "Parameters\n"
10583 : "----------\n"
10584 : "name: char const *\n"
10585 : "flags: int\n"
10586 : "\n"
10587 : "new_Key(char const * name) -> Key\n"
10588 : "\n"
10589 : "Parameters\n"
10590 : "----------\n"
10591 : "name: char const *\n"
10592 : "\n"
10593 : ""},
10594 : { (char *)"Key___cmp__", _wrap_Key___cmp__, METH_VARARGS, (char *)"\n"
10595 : "Key___cmp__(Key self, Key o) -> int\n"
10596 : "\n"
10597 : "Parameters\n"
10598 : "----------\n"
10599 : "self: kdb::Key *\n"
10600 : "o: kdb::Key const *\n"
10601 : "\n"
10602 : ""},
10603 : { (char *)"Key___copy__", (PyCFunction)_wrap_Key___copy__, METH_O, (char *)"\n"
10604 : "Key___copy__(Key self) -> Key\n"
10605 : "\n"
10606 : "Parameters\n"
10607 : "----------\n"
10608 : "self: kdb::Key *\n"
10609 : "\n"
10610 : ""},
10611 : { (char *)"Key___iter__", (PyCFunction)_wrap_Key___iter__, METH_O, (char *)"\n"
10612 : "Key___iter__(Key self) -> SwigPyIterator\n"
10613 : "\n"
10614 : "Parameters\n"
10615 : "----------\n"
10616 : "self: kdb::Key *\n"
10617 : "\n"
10618 : ""},
10619 : { (char *)"Key___reversed__", (PyCFunction)_wrap_Key___reversed__, METH_O, (char *)"\n"
10620 : "Key___reversed__(Key self) -> SwigPyIterator\n"
10621 : "\n"
10622 : "Parameters\n"
10623 : "----------\n"
10624 : "self: kdb::Key *\n"
10625 : "\n"
10626 : ""},
10627 : { (char *)"Key__getMeta", _wrap_Key__getMeta, METH_VARARGS, (char *)"\n"
10628 : "Key__getMeta(Key self, std::string const & metaName) -> Key\n"
10629 : "\n"
10630 : "Parameters\n"
10631 : "----------\n"
10632 : "self: kdb::Key const *\n"
10633 : "metaName: std::string const &\n"
10634 : "\n"
10635 : ""},
10636 : { (char *)"Key__setMeta", _wrap_Key__setMeta, METH_VARARGS, (char *)"\n"
10637 : "Key__setMeta(Key self, std::string const & metaName, std::string x)\n"
10638 : "\n"
10639 : "Parameters\n"
10640 : "----------\n"
10641 : "self: kdb::Key *\n"
10642 : "metaName: std::string const &\n"
10643 : "x: std::string\n"
10644 : "\n"
10645 : ""},
10646 : { (char *)"Key_swigregister", Key_swigregister, METH_VARARGS, NULL},
10647 : { (char *)"Key_swiginit", Key_swiginit, METH_VARARGS, NULL},
10648 : { (char *)"delete_KeySet", (PyCFunction)_wrap_delete_KeySet, METH_O, (char *)"\n"
10649 : "delete_KeySet(KeySet self)\n"
10650 : "\n"
10651 : "Parameters\n"
10652 : "----------\n"
10653 : "self: kdb::KeySet *\n"
10654 : "\n"
10655 : ""},
10656 : { (char *)"KeySet_release", (PyCFunction)_wrap_KeySet_release, METH_O, (char *)"\n"
10657 : "KeySet_release(KeySet self) -> ckdb::KeySet *\n"
10658 : "\n"
10659 : "Parameters\n"
10660 : "----------\n"
10661 : "self: kdb::KeySet *\n"
10662 : "\n"
10663 : ""},
10664 : { (char *)"KeySet_getKeySet", (PyCFunction)_wrap_KeySet_getKeySet, METH_O, (char *)"\n"
10665 : "KeySet_getKeySet(KeySet self) -> ckdb::KeySet *\n"
10666 : "\n"
10667 : "Parameters\n"
10668 : "----------\n"
10669 : "self: kdb::KeySet const *\n"
10670 : "\n"
10671 : ""},
10672 : { (char *)"KeySet_setKeySet", _wrap_KeySet_setKeySet, METH_VARARGS, (char *)"\n"
10673 : "KeySet_setKeySet(KeySet self, ckdb::KeySet * k)\n"
10674 : "\n"
10675 : "Parameters\n"
10676 : "----------\n"
10677 : "self: kdb::KeySet *\n"
10678 : "k: ckdb::KeySet *\n"
10679 : "\n"
10680 : ""},
10681 : { (char *)"KeySet___len__", (PyCFunction)_wrap_KeySet___len__, METH_O, (char *)"\n"
10682 : "KeySet___len__(KeySet self) -> ssize_t\n"
10683 : "\n"
10684 : "Parameters\n"
10685 : "----------\n"
10686 : "self: kdb::KeySet const *\n"
10687 : "\n"
10688 : ""},
10689 : { (char *)"KeySet_dup", (PyCFunction)_wrap_KeySet_dup, METH_O, (char *)"\n"
10690 : "KeySet_dup(KeySet self) -> ckdb::KeySet *\n"
10691 : "\n"
10692 : "Parameters\n"
10693 : "----------\n"
10694 : "self: kdb::KeySet const *\n"
10695 : "\n"
10696 : ""},
10697 : { (char *)"KeySet_copy", _wrap_KeySet_copy, METH_VARARGS, (char *)"\n"
10698 : "KeySet_copy(KeySet self, KeySet other)\n"
10699 : "\n"
10700 : "Parameters\n"
10701 : "----------\n"
10702 : "self: kdb::KeySet *\n"
10703 : "other: kdb::KeySet const &\n"
10704 : "\n"
10705 : ""},
10706 : { (char *)"KeySet_clear", (PyCFunction)_wrap_KeySet_clear, METH_O, (char *)"\n"
10707 : "KeySet_clear(KeySet self)\n"
10708 : "\n"
10709 : "Parameters\n"
10710 : "----------\n"
10711 : "self: kdb::KeySet *\n"
10712 : "\n"
10713 : ""},
10714 : { (char *)"KeySet_append", _wrap_KeySet_append, METH_VARARGS, (char *)"\n"
10715 : "append(Key toAppend) -> ssize_t\n"
10716 : "\n"
10717 : "Parameters\n"
10718 : "----------\n"
10719 : "toAppend: kdb::Key const &\n"
10720 : "\n"
10721 : "KeySet_append(KeySet self, KeySet toAppend) -> ssize_t\n"
10722 : "\n"
10723 : "Parameters\n"
10724 : "----------\n"
10725 : "self: kdb::KeySet *\n"
10726 : "toAppend: kdb::KeySet const &\n"
10727 : "\n"
10728 : ""},
10729 : { (char *)"KeySet_head", (PyCFunction)_wrap_KeySet_head, METH_O, (char *)"\n"
10730 : "KeySet_head(KeySet self) -> Key\n"
10731 : "\n"
10732 : "Parameters\n"
10733 : "----------\n"
10734 : "self: kdb::KeySet const *\n"
10735 : "\n"
10736 : ""},
10737 : { (char *)"KeySet_tail", (PyCFunction)_wrap_KeySet_tail, METH_O, (char *)"\n"
10738 : "KeySet_tail(KeySet self) -> Key\n"
10739 : "\n"
10740 : "Parameters\n"
10741 : "----------\n"
10742 : "self: kdb::KeySet const *\n"
10743 : "\n"
10744 : ""},
10745 : { (char *)"KeySet_setCursor", _wrap_KeySet_setCursor, METH_VARARGS, (char *)"\n"
10746 : "KeySet_setCursor(KeySet self, cursor_t cursor)\n"
10747 : "\n"
10748 : "Parameters\n"
10749 : "----------\n"
10750 : "self: kdb::KeySet const *\n"
10751 : "cursor: cursor_t\n"
10752 : "\n"
10753 : ""},
10754 : { (char *)"KeySet_getCursor", (PyCFunction)_wrap_KeySet_getCursor, METH_O, (char *)"\n"
10755 : "KeySet_getCursor(KeySet self) -> cursor_t\n"
10756 : "\n"
10757 : "Parameters\n"
10758 : "----------\n"
10759 : "self: kdb::KeySet const *\n"
10760 : "\n"
10761 : ""},
10762 : { (char *)"KeySet_pop", (PyCFunction)_wrap_KeySet_pop, METH_O, (char *)"\n"
10763 : "KeySet_pop(KeySet self) -> Key\n"
10764 : "\n"
10765 : "Parameters\n"
10766 : "----------\n"
10767 : "self: kdb::KeySet *\n"
10768 : "\n"
10769 : ""},
10770 : { (char *)"KeySet_cut", _wrap_KeySet_cut, METH_VARARGS, (char *)"\n"
10771 : "KeySet_cut(KeySet self, Key k) -> KeySet\n"
10772 : "\n"
10773 : "Parameters\n"
10774 : "----------\n"
10775 : "self: kdb::KeySet *\n"
10776 : "k: kdb::Key\n"
10777 : "\n"
10778 : ""},
10779 : { (char *)"KeySet__lookup", _wrap_KeySet__lookup, METH_VARARGS, (char *)"\n"
10780 : "_lookup(cursor_t pos) -> Key\n"
10781 : "\n"
10782 : "Parameters\n"
10783 : "----------\n"
10784 : "pos: cursor_t\n"
10785 : "\n"
10786 : "_lookup(Key k, option_t const options=KDB_O_NONE) -> Key\n"
10787 : "\n"
10788 : "Parameters\n"
10789 : "----------\n"
10790 : "k: kdb::Key const &\n"
10791 : "options: option_t const\n"
10792 : "\n"
10793 : "_lookup(Key k) -> Key\n"
10794 : "\n"
10795 : "Parameters\n"
10796 : "----------\n"
10797 : "k: kdb::Key const &\n"
10798 : "\n"
10799 : "_lookup(std::string const & name, option_t const options=KDB_O_NONE) -> Key\n"
10800 : "\n"
10801 : "Parameters\n"
10802 : "----------\n"
10803 : "name: std::string const &\n"
10804 : "options: option_t const\n"
10805 : "\n"
10806 : "KeySet__lookup(KeySet self, std::string const & name) -> Key\n"
10807 : "\n"
10808 : "Parameters\n"
10809 : "----------\n"
10810 : "self: kdb::KeySet const *\n"
10811 : "name: std::string const &\n"
10812 : "\n"
10813 : ""},
10814 : { (char *)"new_KeySet", _wrap_new_KeySet, METH_VARARGS, (char *)"\n"
10815 : "KeySet()\n"
10816 : "KeySet(ckdb::KeySet * k)\n"
10817 : "\n"
10818 : "Parameters\n"
10819 : "----------\n"
10820 : "k: ckdb::KeySet *\n"
10821 : "\n"
10822 : "KeySet(KeySet other)\n"
10823 : "\n"
10824 : "Parameters\n"
10825 : "----------\n"
10826 : "other: kdb::KeySet const &\n"
10827 : "\n"
10828 : "new_KeySet(size_t alloc) -> KeySet\n"
10829 : "\n"
10830 : "Parameters\n"
10831 : "----------\n"
10832 : "alloc: size_t\n"
10833 : "\n"
10834 : ""},
10835 : { (char *)"KeySet___copy__", (PyCFunction)_wrap_KeySet___copy__, METH_O, (char *)"\n"
10836 : "KeySet___copy__(KeySet self) -> KeySet\n"
10837 : "\n"
10838 : "Parameters\n"
10839 : "----------\n"
10840 : "self: kdb::KeySet *\n"
10841 : "\n"
10842 : ""},
10843 : { (char *)"KeySet___deepcopy__", _wrap_KeySet___deepcopy__, METH_VARARGS, (char *)"\n"
10844 : "KeySet___deepcopy__(KeySet self, PyObject * memo) -> KeySet\n"
10845 : "\n"
10846 : "Parameters\n"
10847 : "----------\n"
10848 : "self: kdb::KeySet *\n"
10849 : "memo: PyObject *\n"
10850 : "\n"
10851 : ""},
10852 : { (char *)"KeySet___iter__", (PyCFunction)_wrap_KeySet___iter__, METH_O, (char *)"\n"
10853 : "KeySet___iter__(KeySet self) -> SwigPyIterator\n"
10854 : "\n"
10855 : "Parameters\n"
10856 : "----------\n"
10857 : "self: kdb::KeySet *\n"
10858 : "\n"
10859 : ""},
10860 : { (char *)"KeySet___reversed__", (PyCFunction)_wrap_KeySet___reversed__, METH_O, (char *)"\n"
10861 : "KeySet___reversed__(KeySet self) -> SwigPyIterator\n"
10862 : "\n"
10863 : "Parameters\n"
10864 : "----------\n"
10865 : "self: kdb::KeySet *\n"
10866 : "\n"
10867 : ""},
10868 : { (char *)"KeySet_swigregister", KeySet_swigregister, METH_VARARGS, NULL},
10869 : { (char *)"KeySet_swiginit", KeySet_swiginit, METH_VARARGS, NULL},
10870 : { (char *)"__eq__", _wrap___eq__, METH_VARARGS, (char *)"\n"
10871 : "__eq__(KeySet lhs, KeySet rhs) -> bool\n"
10872 : "\n"
10873 : "Parameters\n"
10874 : "----------\n"
10875 : "lhs: kdb::KeySet const &\n"
10876 : "rhs: kdb::KeySet const &\n"
10877 : "\n"
10878 : ""},
10879 : { (char *)"__ne__", _wrap___ne__, METH_VARARGS, (char *)"\n"
10880 : "__ne__(KeySet lhs, KeySet rhs) -> bool\n"
10881 : "\n"
10882 : "Parameters\n"
10883 : "----------\n"
10884 : "lhs: kdb::KeySet const &\n"
10885 : "rhs: kdb::KeySet const &\n"
10886 : "\n"
10887 : ""},
10888 : { (char *)"new_KDB", _wrap_new_KDB, METH_VARARGS, (char *)"\n"
10889 : "KDB()\n"
10890 : "new_KDB(Key errorKey) -> KDB\n"
10891 : "\n"
10892 : "Parameters\n"
10893 : "----------\n"
10894 : "errorKey: kdb::Key &\n"
10895 : "\n"
10896 : ""},
10897 : { (char *)"delete_KDB", (PyCFunction)_wrap_delete_KDB, METH_O, (char *)"\n"
10898 : "delete_KDB(KDB self)\n"
10899 : "\n"
10900 : "Parameters\n"
10901 : "----------\n"
10902 : "self: kdb::KDB *\n"
10903 : "\n"
10904 : ""},
10905 : { (char *)"KDB_open", _wrap_KDB_open, METH_VARARGS, (char *)"\n"
10906 : "KDB_open(KDB self, Key errorKey)\n"
10907 : "\n"
10908 : "Parameters\n"
10909 : "----------\n"
10910 : "self: kdb::KDB *\n"
10911 : "errorKey: kdb::Key &\n"
10912 : "\n"
10913 : ""},
10914 : { (char *)"KDB_close", _wrap_KDB_close, METH_VARARGS, (char *)"\n"
10915 : "close()\n"
10916 : "KDB_close(KDB self, Key errorKey)\n"
10917 : "\n"
10918 : "Parameters\n"
10919 : "----------\n"
10920 : "self: kdb::KDB *\n"
10921 : "errorKey: kdb::Key &\n"
10922 : "\n"
10923 : ""},
10924 : { (char *)"KDB_get", _wrap_KDB_get, METH_VARARGS, (char *)"\n"
10925 : "get(KeySet returned, std::string const & keyname) -> int\n"
10926 : "\n"
10927 : "Parameters\n"
10928 : "----------\n"
10929 : "returned: kdb::KeySet &\n"
10930 : "keyname: std::string const &\n"
10931 : "\n"
10932 : "KDB_get(KDB self, KeySet returned, Key parentKey) -> int\n"
10933 : "\n"
10934 : "Parameters\n"
10935 : "----------\n"
10936 : "self: kdb::KDB *\n"
10937 : "returned: kdb::KeySet &\n"
10938 : "parentKey: kdb::Key &\n"
10939 : "\n"
10940 : ""},
10941 : { (char *)"KDB_set", _wrap_KDB_set, METH_VARARGS, (char *)"\n"
10942 : "set(KeySet returned, std::string const & keyname) -> int\n"
10943 : "\n"
10944 : "Parameters\n"
10945 : "----------\n"
10946 : "returned: kdb::KeySet &\n"
10947 : "keyname: std::string const &\n"
10948 : "\n"
10949 : "KDB_set(KDB self, KeySet returned, Key parentKey) -> int\n"
10950 : "\n"
10951 : "Parameters\n"
10952 : "----------\n"
10953 : "self: kdb::KDB *\n"
10954 : "returned: kdb::KeySet &\n"
10955 : "parentKey: kdb::Key &\n"
10956 : "\n"
10957 : ""},
10958 : { (char *)"KDB_ensure", _wrap_KDB_ensure, METH_VARARGS, (char *)"\n"
10959 : "KDB_ensure(KDB self, KeySet contract, Key parentKey) -> int\n"
10960 : "\n"
10961 : "Parameters\n"
10962 : "----------\n"
10963 : "self: kdb::KDB *\n"
10964 : "contract: kdb::KeySet const &\n"
10965 : "parentKey: kdb::Key &\n"
10966 : "\n"
10967 : ""},
10968 : { (char *)"KDB_swigregister", KDB_swigregister, METH_VARARGS, NULL},
10969 : { (char *)"KDB_swiginit", KDB_swiginit, METH_VARARGS, NULL},
10970 : { NULL, NULL, 0, NULL }
10971 : };
10972 :
10973 :
10974 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
10975 :
10976 0 : static void *_p_kdb__ExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
10977 0 : return (void *)((std::exception *) ((kdb::Exception *) x));
10978 : }
10979 0 : static void *_p_kdb__KeyExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
10980 0 : return (void *)((std::exception *) (kdb::Exception *) ((kdb::KeyException *) x));
10981 : }
10982 0 : static void *_p_kdb__KeyNotFoundExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
10983 0 : return (void *)((std::exception *) (kdb::Exception *) ((kdb::KeyNotFoundException *) x));
10984 : }
10985 0 : static void *_p_kdb__KeyTypeMismatchTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
10986 0 : return (void *)((std::exception *) (kdb::Exception *)(kdb::KeyException *) ((kdb::KeyTypeMismatch *) x));
10987 : }
10988 0 : static void *_p_kdb__KDBExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
10989 0 : return (void *)((std::exception *) (kdb::Exception *) ((kdb::KDBException *) x));
10990 : }
10991 0 : static void *_p_kdb__ContractExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
10992 0 : return (void *)((std::exception *) (kdb::Exception *)(kdb::KDBException *) ((kdb::ContractException *) x));
10993 : }
10994 0 : static void *_p_kdb__KeyTypeConversionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
10995 0 : return (void *)((std::exception *) (kdb::Exception *)(kdb::KeyException *) ((kdb::KeyTypeConversion *) x));
10996 : }
10997 0 : static void *_p_kdb__KeyInvalidNameTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
10998 0 : return (void *)((std::exception *) (kdb::Exception *)(kdb::KeyException *) ((kdb::KeyInvalidName *) x));
10999 : }
11000 0 : static void *_p_kdb__KeyExceptionTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
11001 0 : return (void *)((kdb::Exception *) ((kdb::KeyException *) x));
11002 : }
11003 0 : static void *_p_kdb__KeyNotFoundExceptionTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
11004 0 : return (void *)((kdb::Exception *) ((kdb::KeyNotFoundException *) x));
11005 : }
11006 0 : static void *_p_kdb__KeyTypeMismatchTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
11007 0 : return (void *)((kdb::Exception *) (kdb::KeyException *) ((kdb::KeyTypeMismatch *) x));
11008 : }
11009 0 : static void *_p_kdb__KDBExceptionTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
11010 0 : return (void *)((kdb::Exception *) ((kdb::KDBException *) x));
11011 : }
11012 0 : static void *_p_kdb__ContractExceptionTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
11013 0 : return (void *)((kdb::Exception *) (kdb::KDBException *) ((kdb::ContractException *) x));
11014 : }
11015 0 : static void *_p_kdb__KeyTypeConversionTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
11016 0 : return (void *)((kdb::Exception *) (kdb::KeyException *) ((kdb::KeyTypeConversion *) x));
11017 : }
11018 0 : static void *_p_kdb__KeyInvalidNameTo_p_kdb__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
11019 0 : return (void *)((kdb::Exception *) (kdb::KeyException *) ((kdb::KeyInvalidName *) x));
11020 : }
11021 0 : static void *_p_kdb__KeyTypeMismatchTo_p_kdb__KeyException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
11022 0 : return (void *)((kdb::KeyException *) ((kdb::KeyTypeMismatch *) x));
11023 : }
11024 0 : static void *_p_kdb__KeyTypeConversionTo_p_kdb__KeyException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
11025 0 : return (void *)((kdb::KeyException *) ((kdb::KeyTypeConversion *) x));
11026 : }
11027 0 : static void *_p_kdb__KeyInvalidNameTo_p_kdb__KeyException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
11028 0 : return (void *)((kdb::KeyException *) ((kdb::KeyInvalidName *) x));
11029 : }
11030 0 : static void *_p_kdb__ContractExceptionTo_p_kdb__KDBException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
11031 0 : return (void *)((kdb::KDBException *) ((kdb::ContractException *) x));
11032 : }
11033 : static swig_type_info _swigt__p_Key = {"_p_Key", "Key *", 0, 0, (void*)0, 0};
11034 : static swig_type_info _swigt__p__Key = {"_p__Key", "_Key *|ckdb::Key *", 0, 0, (void*)0, 0};
11035 : static swig_type_info _swigt__p__KeySet = {"_p__KeySet", "_KeySet *|ckdb::KeySet *", 0, 0, (void*)0, 0};
11036 : static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
11037 : static swig_type_info _swigt__p_f___void = {"_p_f___void", "void (*)()|kdb::Key::func_t", 0, 0, (void*)0, 0};
11038 : static swig_type_info _swigt__p_f_p__KeySet_p__Key_p__Key_option_t__p__Key = {"_p_f_p__KeySet_p__Key_p__Key_option_t__p__Key", "_Key *(*)(_KeySet *,_Key *,_Key *,option_t)|kdb::Key::callback_t", 0, 0, (void*)0, 0};
11039 : static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0};
11040 : static swig_type_info _swigt__p_kdb__ContractException = {"_p_kdb__ContractException", "kdb::ContractException *", 0, 0, (void*)0, 0};
11041 : static swig_type_info _swigt__p_kdb__Exception = {"_p_kdb__Exception", "kdb::Exception *", 0, 0, (void*)0, 0};
11042 : static swig_type_info _swigt__p_kdb__KDB = {"_p_kdb__KDB", "kdb::KDB *", 0, 0, (void*)0, 0};
11043 : static swig_type_info _swigt__p_kdb__KDBException = {"_p_kdb__KDBException", "kdb::KDBException *", 0, 0, (void*)0, 0};
11044 : static swig_type_info _swigt__p_kdb__Key = {"_p_kdb__Key", "kdb::Key *", 0, 0, (void*)0, 0};
11045 : static swig_type_info _swigt__p_kdb__KeyException = {"_p_kdb__KeyException", "kdb::KeyException *", 0, 0, (void*)0, 0};
11046 : static swig_type_info _swigt__p_kdb__KeyInvalidName = {"_p_kdb__KeyInvalidName", "kdb::KeyInvalidName *", 0, 0, (void*)0, 0};
11047 : static swig_type_info _swigt__p_kdb__KeyNotFoundException = {"_p_kdb__KeyNotFoundException", "kdb::KeyNotFoundException *", 0, 0, (void*)0, 0};
11048 : static swig_type_info _swigt__p_kdb__KeySet = {"_p_kdb__KeySet", "kdb::KeySet *", 0, 0, (void*)0, 0};
11049 : static swig_type_info _swigt__p_kdb__KeyTypeConversion = {"_p_kdb__KeyTypeConversion", "kdb::KeyTypeConversion *", 0, 0, (void*)0, 0};
11050 : static swig_type_info _swigt__p_kdb__KeyTypeMismatch = {"_p_kdb__KeyTypeMismatch", "kdb::KeyTypeMismatch *", 0, 0, (void*)0, 0};
11051 : static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
11052 : static swig_type_info _swigt__p_option_t = {"_p_option_t", "option_t *", 0, 0, (void*)0, 0};
11053 : static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
11054 : static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
11055 : static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
11056 : static swig_type_info _swigt__p_std__exception = {"_p_std__exception", "std::exception *", 0, 0, (void*)0, 0};
11057 : static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
11058 : static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
11059 : static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
11060 : static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
11061 : static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
11062 : static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
11063 : static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
11064 :
11065 : static swig_type_info *swig_type_initial[] = {
11066 : &_swigt__p_Key,
11067 : &_swigt__p__Key,
11068 : &_swigt__p__KeySet,
11069 : &_swigt__p_char,
11070 : &_swigt__p_f___void,
11071 : &_swigt__p_f_p__KeySet_p__Key_p__Key_option_t__p__Key,
11072 : &_swigt__p_int,
11073 : &_swigt__p_kdb__ContractException,
11074 : &_swigt__p_kdb__Exception,
11075 : &_swigt__p_kdb__KDB,
11076 : &_swigt__p_kdb__KDBException,
11077 : &_swigt__p_kdb__Key,
11078 : &_swigt__p_kdb__KeyException,
11079 : &_swigt__p_kdb__KeyInvalidName,
11080 : &_swigt__p_kdb__KeyNotFoundException,
11081 : &_swigt__p_kdb__KeySet,
11082 : &_swigt__p_kdb__KeyTypeConversion,
11083 : &_swigt__p_kdb__KeyTypeMismatch,
11084 : &_swigt__p_long_long,
11085 : &_swigt__p_option_t,
11086 : &_swigt__p_p_PyObject,
11087 : &_swigt__p_short,
11088 : &_swigt__p_signed_char,
11089 : &_swigt__p_std__exception,
11090 : &_swigt__p_std__invalid_argument,
11091 : &_swigt__p_swig__SwigPyIterator,
11092 : &_swigt__p_unsigned_char,
11093 : &_swigt__p_unsigned_int,
11094 : &_swigt__p_unsigned_long_long,
11095 : &_swigt__p_unsigned_short,
11096 : &_swigt__p_void,
11097 : };
11098 :
11099 : static swig_cast_info _swigc__p_Key[] = { {&_swigt__p_Key, 0, 0, 0},{0, 0, 0, 0}};
11100 : static swig_cast_info _swigc__p__Key[] = { {&_swigt__p__Key, 0, 0, 0},{0, 0, 0, 0}};
11101 : static swig_cast_info _swigc__p__KeySet[] = { {&_swigt__p__KeySet, 0, 0, 0},{0, 0, 0, 0}};
11102 : static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
11103 : static swig_cast_info _swigc__p_f___void[] = { {&_swigt__p_f___void, 0, 0, 0},{0, 0, 0, 0}};
11104 : static swig_cast_info _swigc__p_f_p__KeySet_p__Key_p__Key_option_t__p__Key[] = { {&_swigt__p_f_p__KeySet_p__Key_p__Key_option_t__p__Key, 0, 0, 0},{0, 0, 0, 0}};
11105 : static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
11106 : static swig_cast_info _swigc__p_kdb__ContractException[] = { {&_swigt__p_kdb__ContractException, 0, 0, 0},{0, 0, 0, 0}};
11107 : static swig_cast_info _swigc__p_kdb__Exception[] = { {&_swigt__p_kdb__Exception, 0, 0, 0}, {&_swigt__p_kdb__KeyException, _p_kdb__KeyExceptionTo_p_kdb__Exception, 0, 0}, {&_swigt__p_kdb__KeyTypeMismatch, _p_kdb__KeyTypeMismatchTo_p_kdb__Exception, 0, 0}, {&_swigt__p_kdb__KeyNotFoundException, _p_kdb__KeyNotFoundExceptionTo_p_kdb__Exception, 0, 0}, {&_swigt__p_kdb__KDBException, _p_kdb__KDBExceptionTo_p_kdb__Exception, 0, 0}, {&_swigt__p_kdb__ContractException, _p_kdb__ContractExceptionTo_p_kdb__Exception, 0, 0}, {&_swigt__p_kdb__KeyTypeConversion, _p_kdb__KeyTypeConversionTo_p_kdb__Exception, 0, 0}, {&_swigt__p_kdb__KeyInvalidName, _p_kdb__KeyInvalidNameTo_p_kdb__Exception, 0, 0},{0, 0, 0, 0}};
11108 : static swig_cast_info _swigc__p_kdb__KDB[] = { {&_swigt__p_kdb__KDB, 0, 0, 0},{0, 0, 0, 0}};
11109 : static swig_cast_info _swigc__p_kdb__KDBException[] = { {&_swigt__p_kdb__KDBException, 0, 0, 0}, {&_swigt__p_kdb__ContractException, _p_kdb__ContractExceptionTo_p_kdb__KDBException, 0, 0},{0, 0, 0, 0}};
11110 : static swig_cast_info _swigc__p_kdb__Key[] = { {&_swigt__p_kdb__Key, 0, 0, 0},{0, 0, 0, 0}};
11111 : static swig_cast_info _swigc__p_kdb__KeyException[] = { {&_swigt__p_kdb__KeyException, 0, 0, 0}, {&_swigt__p_kdb__KeyTypeMismatch, _p_kdb__KeyTypeMismatchTo_p_kdb__KeyException, 0, 0}, {&_swigt__p_kdb__KeyTypeConversion, _p_kdb__KeyTypeConversionTo_p_kdb__KeyException, 0, 0}, {&_swigt__p_kdb__KeyInvalidName, _p_kdb__KeyInvalidNameTo_p_kdb__KeyException, 0, 0},{0, 0, 0, 0}};
11112 : static swig_cast_info _swigc__p_kdb__KeyInvalidName[] = { {&_swigt__p_kdb__KeyInvalidName, 0, 0, 0},{0, 0, 0, 0}};
11113 : static swig_cast_info _swigc__p_kdb__KeyNotFoundException[] = { {&_swigt__p_kdb__KeyNotFoundException, 0, 0, 0},{0, 0, 0, 0}};
11114 : static swig_cast_info _swigc__p_kdb__KeySet[] = { {&_swigt__p_kdb__KeySet, 0, 0, 0},{0, 0, 0, 0}};
11115 : static swig_cast_info _swigc__p_kdb__KeyTypeConversion[] = { {&_swigt__p_kdb__KeyTypeConversion, 0, 0, 0},{0, 0, 0, 0}};
11116 : static swig_cast_info _swigc__p_kdb__KeyTypeMismatch[] = { {&_swigt__p_kdb__KeyTypeMismatch, 0, 0, 0},{0, 0, 0, 0}};
11117 : static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
11118 : static swig_cast_info _swigc__p_option_t[] = { {&_swigt__p_option_t, 0, 0, 0},{0, 0, 0, 0}};
11119 : static swig_cast_info _swigc__p_p_PyObject[] = { {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
11120 : static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
11121 : static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
11122 : static swig_cast_info _swigc__p_std__exception[] = { {&_swigt__p_std__exception, 0, 0, 0}, {&_swigt__p_kdb__Exception, _p_kdb__ExceptionTo_p_std__exception, 0, 0}, {&_swigt__p_kdb__KeyException, _p_kdb__KeyExceptionTo_p_std__exception, 0, 0}, {&_swigt__p_kdb__KeyTypeMismatch, _p_kdb__KeyTypeMismatchTo_p_std__exception, 0, 0}, {&_swigt__p_kdb__KeyNotFoundException, _p_kdb__KeyNotFoundExceptionTo_p_std__exception, 0, 0}, {&_swigt__p_kdb__KDBException, _p_kdb__KDBExceptionTo_p_std__exception, 0, 0}, {&_swigt__p_kdb__ContractException, _p_kdb__ContractExceptionTo_p_std__exception, 0, 0}, {&_swigt__p_kdb__KeyTypeConversion, _p_kdb__KeyTypeConversionTo_p_std__exception, 0, 0}, {&_swigt__p_kdb__KeyInvalidName, _p_kdb__KeyInvalidNameTo_p_std__exception, 0, 0},{0, 0, 0, 0}};
11123 : static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
11124 : static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
11125 : static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
11126 : static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
11127 : static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
11128 : static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
11129 : static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
11130 :
11131 : static swig_cast_info *swig_cast_initial[] = {
11132 : _swigc__p_Key,
11133 : _swigc__p__Key,
11134 : _swigc__p__KeySet,
11135 : _swigc__p_char,
11136 : _swigc__p_f___void,
11137 : _swigc__p_f_p__KeySet_p__Key_p__Key_option_t__p__Key,
11138 : _swigc__p_int,
11139 : _swigc__p_kdb__ContractException,
11140 : _swigc__p_kdb__Exception,
11141 : _swigc__p_kdb__KDB,
11142 : _swigc__p_kdb__KDBException,
11143 : _swigc__p_kdb__Key,
11144 : _swigc__p_kdb__KeyException,
11145 : _swigc__p_kdb__KeyInvalidName,
11146 : _swigc__p_kdb__KeyNotFoundException,
11147 : _swigc__p_kdb__KeySet,
11148 : _swigc__p_kdb__KeyTypeConversion,
11149 : _swigc__p_kdb__KeyTypeMismatch,
11150 : _swigc__p_long_long,
11151 : _swigc__p_option_t,
11152 : _swigc__p_p_PyObject,
11153 : _swigc__p_short,
11154 : _swigc__p_signed_char,
11155 : _swigc__p_std__exception,
11156 : _swigc__p_std__invalid_argument,
11157 : _swigc__p_swig__SwigPyIterator,
11158 : _swigc__p_unsigned_char,
11159 : _swigc__p_unsigned_int,
11160 : _swigc__p_unsigned_long_long,
11161 : _swigc__p_unsigned_short,
11162 : _swigc__p_void,
11163 : };
11164 :
11165 :
11166 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
11167 :
11168 : static swig_const_info swig_const_table[] = {
11169 : {0, 0, 0, 0.0, 0, 0}};
11170 :
11171 : #ifdef __cplusplus
11172 : }
11173 : #endif
11174 : /* -----------------------------------------------------------------------------
11175 : * Type initialization:
11176 : * This problem is tough by the requirement that no dynamic
11177 : * memory is used. Also, since swig_type_info structures store pointers to
11178 : * swig_cast_info structures and swig_cast_info structures store pointers back
11179 : * to swig_type_info structures, we need some lookup code at initialization.
11180 : * The idea is that swig generates all the structures that are needed.
11181 : * The runtime then collects these partially filled structures.
11182 : * The SWIG_InitializeModule function takes these initial arrays out of
11183 : * swig_module, and does all the lookup, filling in the swig_module.types
11184 : * array with the correct data and linking the correct swig_cast_info
11185 : * structures together.
11186 : *
11187 : * The generated swig_type_info structures are assigned statically to an initial
11188 : * array. We just loop through that array, and handle each type individually.
11189 : * First we lookup if this type has been already loaded, and if so, use the
11190 : * loaded structure instead of the generated one. Then we have to fill in the
11191 : * cast linked list. The cast data is initially stored in something like a
11192 : * two-dimensional array. Each row corresponds to a type (there are the same
11193 : * number of rows as there are in the swig_type_initial array). Each entry in
11194 : * a column is one of the swig_cast_info structures for that type.
11195 : * The cast_initial array is actually an array of arrays, because each row has
11196 : * a variable number of columns. So to actually build the cast linked list,
11197 : * we find the array of casts associated with the type, and loop through it
11198 : * adding the casts to the list. The one last trick we need to do is making
11199 : * sure the type pointer in the swig_cast_info struct is correct.
11200 : *
11201 : * First off, we lookup the cast->type name to see if it is already loaded.
11202 : * There are three cases to handle:
11203 : * 1) If the cast->type has already been loaded AND the type we are adding
11204 : * casting info to has not been loaded (it is in this module), THEN we
11205 : * replace the cast->type pointer with the type pointer that has already
11206 : * been loaded.
11207 : * 2) If BOTH types (the one we are adding casting info to, and the
11208 : * cast->type) are loaded, THEN the cast info has already been loaded by
11209 : * the previous module so we just ignore it.
11210 : * 3) Finally, if cast->type has not already been loaded, then we add that
11211 : * swig_cast_info to the linked list (because the cast->type) pointer will
11212 : * be correct.
11213 : * ----------------------------------------------------------------------------- */
11214 :
11215 : #ifdef __cplusplus
11216 : extern "C" {
11217 : #if 0
11218 : } /* c-mode */
11219 : #endif
11220 : #endif
11221 :
11222 : #if 0
11223 : #define SWIGRUNTIME_DEBUG
11224 : #endif
11225 :
11226 :
11227 : SWIGRUNTIME void
11228 3 : SWIG_InitializeModule(void *clientdata) {
11229 : size_t i;
11230 : swig_module_info *module_head, *iter;
11231 : int init;
11232 :
11233 : /* check to see if the circular list has been setup, if not, set it up */
11234 3 : if (swig_module.next==0) {
11235 : /* Initialize the swig_module */
11236 3 : swig_module.type_initial = swig_type_initial;
11237 3 : swig_module.cast_initial = swig_cast_initial;
11238 3 : swig_module.next = &swig_module;
11239 3 : init = 1;
11240 : } else {
11241 : init = 0;
11242 : }
11243 :
11244 : /* Try and load any already created modules */
11245 3 : module_head = SWIG_GetModule(clientdata);
11246 3 : if (!module_head) {
11247 : /* This is the first module loaded for this interpreter */
11248 : /* so set the swig module into the interpreter */
11249 3 : SWIG_SetModule(clientdata, &swig_module);
11250 : } else {
11251 : /* the interpreter has loaded a SWIG module, but has it loaded this one? */
11252 : iter=module_head;
11253 : do {
11254 0 : if (iter==&swig_module) {
11255 : /* Our module is already in the list, so there's nothing more to do. */
11256 : return;
11257 : }
11258 0 : iter=iter->next;
11259 0 : } while (iter!= module_head);
11260 :
11261 : /* otherwise we must add our module into the list */
11262 0 : swig_module.next = module_head->next;
11263 0 : module_head->next = &swig_module;
11264 : }
11265 :
11266 : /* When multiple interpreters are used, a module could have already been initialized in
11267 : a different interpreter, but not yet have a pointer in this interpreter.
11268 : In this case, we do not want to continue adding types... everything should be
11269 : set up already */
11270 3 : if (init == 0) return;
11271 :
11272 : /* Now work on filling in swig_module.types */
11273 : #ifdef SWIGRUNTIME_DEBUG
11274 : printf("SWIG_InitializeModule: size %d\n", swig_module.size);
11275 : #endif
11276 189 : for (i = 0; i < swig_module.size; ++i) {
11277 93 : swig_type_info *type = 0;
11278 : swig_type_info *ret;
11279 : swig_cast_info *cast;
11280 :
11281 : #ifdef SWIGRUNTIME_DEBUG
11282 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
11283 : #endif
11284 :
11285 : /* if there is another module already loaded */
11286 93 : if (swig_module.next != &swig_module) {
11287 0 : type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
11288 : }
11289 93 : if (type) {
11290 : /* Overwrite clientdata field */
11291 : #ifdef SWIGRUNTIME_DEBUG
11292 : printf("SWIG_InitializeModule: found type %s\n", type->name);
11293 : #endif
11294 0 : if (swig_module.type_initial[i]->clientdata) {
11295 0 : type->clientdata = swig_module.type_initial[i]->clientdata;
11296 : #ifdef SWIGRUNTIME_DEBUG
11297 : printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
11298 : #endif
11299 : }
11300 : } else {
11301 93 : type = swig_module.type_initial[i];
11302 : }
11303 :
11304 : /* Insert casting types */
11305 93 : cast = swig_module.cast_initial[i];
11306 243 : while (cast->type) {
11307 : /* Don't need to add information already in the list */
11308 150 : ret = 0;
11309 : #ifdef SWIGRUNTIME_DEBUG
11310 : printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
11311 : #endif
11312 150 : if (swig_module.next != &swig_module) {
11313 0 : ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
11314 : #ifdef SWIGRUNTIME_DEBUG
11315 : if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
11316 : #endif
11317 : }
11318 150 : if (ret) {
11319 0 : if (type == swig_module.type_initial[i]) {
11320 : #ifdef SWIGRUNTIME_DEBUG
11321 : printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
11322 : #endif
11323 0 : cast->type = ret;
11324 0 : ret = 0;
11325 : } else {
11326 : /* Check for casting already in the list */
11327 0 : swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
11328 : #ifdef SWIGRUNTIME_DEBUG
11329 : if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
11330 : #endif
11331 0 : if (!ocast) ret = 0;
11332 : }
11333 : }
11334 :
11335 150 : if (!ret) {
11336 : #ifdef SWIGRUNTIME_DEBUG
11337 : printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
11338 : #endif
11339 150 : if (type->cast) {
11340 57 : type->cast->prev = cast;
11341 57 : cast->next = type->cast;
11342 : }
11343 150 : type->cast = cast;
11344 : }
11345 150 : cast++;
11346 : }
11347 : /* Set entry in modules->types array equal to the type */
11348 93 : swig_module.types[i] = type;
11349 : }
11350 3 : swig_module.types[i] = 0;
11351 :
11352 : #ifdef SWIGRUNTIME_DEBUG
11353 : printf("**** SWIG_InitializeModule: Cast List ******\n");
11354 : for (i = 0; i < swig_module.size; ++i) {
11355 : int j = 0;
11356 : swig_cast_info *cast = swig_module.cast_initial[i];
11357 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
11358 : while (cast->type) {
11359 : printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
11360 : cast++;
11361 : ++j;
11362 : }
11363 : printf("---- Total casts: %d\n",j);
11364 : }
11365 : printf("**** SWIG_InitializeModule: Cast List ******\n");
11366 : #endif
11367 : }
11368 :
11369 : /* This function will propagate the clientdata field of type to
11370 : * any new swig_type_info structures that have been added into the list
11371 : * of equivalent types. It is like calling
11372 : * SWIG_TypeClientData(type, clientdata) a second time.
11373 : */
11374 : SWIGRUNTIME void
11375 : SWIG_PropagateClientData(void) {
11376 : size_t i;
11377 : swig_cast_info *equiv;
11378 : static int init_run = 0;
11379 :
11380 : if (init_run) return;
11381 : init_run = 1;
11382 :
11383 : for (i = 0; i < swig_module.size; i++) {
11384 : if (swig_module.types[i]->clientdata) {
11385 : equiv = swig_module.types[i]->cast;
11386 : while (equiv) {
11387 : if (!equiv->converter) {
11388 : if (equiv->type && !equiv->type->clientdata)
11389 : SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
11390 : }
11391 : equiv = equiv->next;
11392 : }
11393 : }
11394 : }
11395 : }
11396 :
11397 : #ifdef __cplusplus
11398 : #if 0
11399 : {
11400 : /* c-mode */
11401 : #endif
11402 : }
11403 : #endif
11404 :
11405 :
11406 :
11407 : #ifdef __cplusplus
11408 : extern "C" {
11409 : #endif
11410 :
11411 : /* Python-specific SWIG API */
11412 : #define SWIG_newvarlink() SWIG_Python_newvarlink()
11413 : #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
11414 : #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
11415 :
11416 : /* -----------------------------------------------------------------------------
11417 : * global variable support code.
11418 : * ----------------------------------------------------------------------------- */
11419 :
11420 : typedef struct swig_globalvar {
11421 : char *name; /* Name of global variable */
11422 : PyObject *(*get_attr)(void); /* Return the current value */
11423 : int (*set_attr)(PyObject *); /* Set the value */
11424 : struct swig_globalvar *next;
11425 : } swig_globalvar;
11426 :
11427 : typedef struct swig_varlinkobject {
11428 : PyObject_HEAD
11429 : swig_globalvar *vars;
11430 : } swig_varlinkobject;
11431 :
11432 : SWIGINTERN PyObject *
11433 : swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
11434 : #if PY_VERSION_HEX >= 0x03000000
11435 : return PyUnicode_InternFromString("<Swig global variables>");
11436 : #else
11437 : return PyString_FromString("<Swig global variables>");
11438 : #endif
11439 : }
11440 :
11441 : SWIGINTERN PyObject *
11442 : swig_varlink_str(swig_varlinkobject *v) {
11443 : #if PY_VERSION_HEX >= 0x03000000
11444 : PyObject *str = PyUnicode_InternFromString("(");
11445 : PyObject *tail;
11446 : PyObject *joined;
11447 : swig_globalvar *var;
11448 : for (var = v->vars; var; var=var->next) {
11449 : tail = PyUnicode_FromString(var->name);
11450 : joined = PyUnicode_Concat(str, tail);
11451 : Py_DecRef(str);
11452 : Py_DecRef(tail);
11453 : str = joined;
11454 : if (var->next) {
11455 : tail = PyUnicode_InternFromString(", ");
11456 : joined = PyUnicode_Concat(str, tail);
11457 : Py_DecRef(str);
11458 : Py_DecRef(tail);
11459 : str = joined;
11460 : }
11461 : }
11462 : tail = PyUnicode_InternFromString(")");
11463 : joined = PyUnicode_Concat(str, tail);
11464 : Py_DecRef(str);
11465 : Py_DecRef(tail);
11466 : str = joined;
11467 : #else
11468 : PyObject *str = PyString_FromString("(");
11469 : swig_globalvar *var;
11470 : for (var = v->vars; var; var=var->next) {
11471 : PyString_ConcatAndDel(&str,PyString_FromString(var->name));
11472 : if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
11473 : }
11474 : PyString_ConcatAndDel(&str,PyString_FromString(")"));
11475 : #endif
11476 : return str;
11477 : }
11478 :
11479 : SWIGINTERN int
11480 : swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
11481 : char *tmp;
11482 : PyObject *str = swig_varlink_str(v);
11483 : fprintf(fp,"Swig global variables ");
11484 : fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
11485 : SWIG_Python_str_DelForPy3(tmp);
11486 : Py_DECREF(str);
11487 : return 0;
11488 : }
11489 :
11490 : SWIGINTERN void
11491 : swig_varlink_dealloc(swig_varlinkobject *v) {
11492 : swig_globalvar *var = v->vars;
11493 : while (var) {
11494 : swig_globalvar *n = var->next;
11495 : free(var->name);
11496 : free(var);
11497 : var = n;
11498 : }
11499 : }
11500 :
11501 : SWIGINTERN PyObject *
11502 : swig_varlink_getattr(swig_varlinkobject *v, char *n) {
11503 : PyObject *res = NULL;
11504 : swig_globalvar *var = v->vars;
11505 : while (var) {
11506 : if (strcmp(var->name,n) == 0) {
11507 : res = (*var->get_attr)();
11508 : break;
11509 : }
11510 : var = var->next;
11511 : }
11512 : if (res == NULL && !PyErr_Occurred()) {
11513 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
11514 : }
11515 : return res;
11516 : }
11517 :
11518 : SWIGINTERN int
11519 : swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
11520 : int res = 1;
11521 : swig_globalvar *var = v->vars;
11522 : while (var) {
11523 : if (strcmp(var->name,n) == 0) {
11524 : res = (*var->set_attr)(p);
11525 : break;
11526 : }
11527 : var = var->next;
11528 : }
11529 : if (res == 1 && !PyErr_Occurred()) {
11530 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
11531 : }
11532 : return res;
11533 : }
11534 :
11535 : SWIGINTERN PyTypeObject*
11536 : swig_varlink_type(void) {
11537 : static char varlink__doc__[] = "Swig var link object";
11538 : static PyTypeObject varlink_type;
11539 : static int type_init = 0;
11540 : if (!type_init) {
11541 : const PyTypeObject tmp = {
11542 : /* PyObject header changed in Python 3 */
11543 : #if PY_VERSION_HEX >= 0x03000000
11544 : PyVarObject_HEAD_INIT(NULL, 0)
11545 : #else
11546 : PyObject_HEAD_INIT(NULL)
11547 : 0, /* ob_size */
11548 : #endif
11549 : (char *)"swigvarlink", /* tp_name */
11550 : sizeof(swig_varlinkobject), /* tp_basicsize */
11551 : 0, /* tp_itemsize */
11552 : (destructor) swig_varlink_dealloc, /* tp_dealloc */
11553 : (printfunc) swig_varlink_print, /* tp_print */
11554 : (getattrfunc) swig_varlink_getattr, /* tp_getattr */
11555 : (setattrfunc) swig_varlink_setattr, /* tp_setattr */
11556 : 0, /* tp_compare */
11557 : (reprfunc) swig_varlink_repr, /* tp_repr */
11558 : 0, /* tp_as_number */
11559 : 0, /* tp_as_sequence */
11560 : 0, /* tp_as_mapping */
11561 : 0, /* tp_hash */
11562 : 0, /* tp_call */
11563 : (reprfunc) swig_varlink_str, /* tp_str */
11564 : 0, /* tp_getattro */
11565 : 0, /* tp_setattro */
11566 : 0, /* tp_as_buffer */
11567 : 0, /* tp_flags */
11568 : varlink__doc__, /* tp_doc */
11569 : 0, /* tp_traverse */
11570 : 0, /* tp_clear */
11571 : 0, /* tp_richcompare */
11572 : 0, /* tp_weaklistoffset */
11573 : #if PY_VERSION_HEX >= 0x02020000
11574 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
11575 : #endif
11576 : #if PY_VERSION_HEX >= 0x02030000
11577 : 0, /* tp_del */
11578 : #endif
11579 : #if PY_VERSION_HEX >= 0x02060000
11580 : 0, /* tp_version_tag */
11581 : #endif
11582 : #if PY_VERSION_HEX >= 0x03040000
11583 : 0, /* tp_finalize */
11584 : #endif
11585 : #ifdef COUNT_ALLOCS
11586 : 0, /* tp_allocs */
11587 : 0, /* tp_frees */
11588 : 0, /* tp_maxalloc */
11589 : #if PY_VERSION_HEX >= 0x02050000
11590 : 0, /* tp_prev */
11591 : #endif
11592 : 0 /* tp_next */
11593 : #endif
11594 : };
11595 : varlink_type = tmp;
11596 : type_init = 1;
11597 : #if PY_VERSION_HEX < 0x02020000
11598 : varlink_type.ob_type = &PyType_Type;
11599 : #else
11600 : if (PyType_Ready(&varlink_type) < 0)
11601 : return NULL;
11602 : #endif
11603 : }
11604 : return &varlink_type;
11605 : }
11606 :
11607 : /* Create a variable linking object for use later */
11608 : SWIGINTERN PyObject *
11609 : SWIG_Python_newvarlink(void) {
11610 : swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
11611 : if (result) {
11612 : result->vars = 0;
11613 : }
11614 : return ((PyObject*) result);
11615 : }
11616 :
11617 : SWIGINTERN void
11618 : SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
11619 : swig_varlinkobject *v = (swig_varlinkobject *) p;
11620 : swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
11621 : if (gv) {
11622 : size_t size = strlen(name)+1;
11623 : gv->name = (char *)malloc(size);
11624 : if (gv->name) {
11625 : strncpy(gv->name,name,size);
11626 : gv->get_attr = get_attr;
11627 : gv->set_attr = set_attr;
11628 : gv->next = v->vars;
11629 : }
11630 : }
11631 : v->vars = gv;
11632 : }
11633 :
11634 : SWIGINTERN PyObject *
11635 : SWIG_globals(void) {
11636 : static PyObject *_SWIG_globals = 0;
11637 : if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
11638 : return _SWIG_globals;
11639 : }
11640 :
11641 : /* -----------------------------------------------------------------------------
11642 : * constants/methods manipulation
11643 : * ----------------------------------------------------------------------------- */
11644 :
11645 : /* Install Constants */
11646 : SWIGINTERN void
11647 3 : SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
11648 3 : PyObject *obj = 0;
11649 : size_t i;
11650 3 : for (i = 0; constants[i].type; ++i) {
11651 0 : switch(constants[i].type) {
11652 : case SWIG_PY_POINTER:
11653 0 : obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
11654 0 : break;
11655 : case SWIG_PY_BINARY:
11656 0 : obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
11657 : break;
11658 : default:
11659 : obj = 0;
11660 : break;
11661 : }
11662 0 : if (obj) {
11663 0 : PyDict_SetItemString(d, constants[i].name, obj);
11664 0 : Py_DECREF(obj);
11665 : }
11666 : }
11667 3 : }
11668 :
11669 : /* -----------------------------------------------------------------------------*/
11670 : /* Fix SwigMethods to carry the callback ptrs when needed */
11671 : /* -----------------------------------------------------------------------------*/
11672 :
11673 : SWIGINTERN void
11674 3 : SWIG_Python_FixMethods(PyMethodDef *methods,
11675 : swig_const_info *const_table,
11676 : swig_type_info **types,
11677 : swig_type_info **types_initial) {
11678 : size_t i;
11679 471 : for (i = 0; methods[i].ml_name; ++i) {
11680 468 : const char *c = methods[i].ml_doc;
11681 468 : if (!c) continue;
11682 345 : c = strstr(c, "swig_ptr: ");
11683 345 : if (c) {
11684 : int j;
11685 0 : swig_const_info *ci = 0;
11686 0 : const char *name = c + 10;
11687 0 : for (j = 0; const_table[j].type; ++j) {
11688 0 : if (strncmp(const_table[j].name, name,
11689 0 : strlen(const_table[j].name)) == 0) {
11690 : ci = &(const_table[j]);
11691 : break;
11692 : }
11693 : }
11694 0 : if (ci) {
11695 0 : void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
11696 0 : if (ptr) {
11697 0 : size_t shift = (ci->ptype) - types;
11698 0 : swig_type_info *ty = types_initial[shift];
11699 0 : size_t ldoc = (c - methods[i].ml_doc);
11700 0 : size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
11701 0 : char *ndoc = (char*)malloc(ldoc + lptr + 10);
11702 0 : if (ndoc) {
11703 0 : char *buff = ndoc;
11704 0 : strncpy(buff, methods[i].ml_doc, ldoc);
11705 0 : buff += ldoc;
11706 0 : strncpy(buff, "swig_ptr: ", 10);
11707 0 : buff += 10;
11708 0 : SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
11709 0 : methods[i].ml_doc = ndoc;
11710 : }
11711 : }
11712 : }
11713 : }
11714 : }
11715 3 : }
11716 :
11717 : #ifdef __cplusplus
11718 : }
11719 : #endif
11720 :
11721 : /* -----------------------------------------------------------------------------*
11722 : * Partial Init method
11723 : * -----------------------------------------------------------------------------*/
11724 :
11725 : #ifdef __cplusplus
11726 : extern "C"
11727 : #endif
11728 :
11729 : SWIGEXPORT
11730 : #if PY_VERSION_HEX >= 0x03000000
11731 : PyObject*
11732 : #else
11733 : void
11734 : #endif
11735 3 : SWIG_init(void) {
11736 : PyObject *m, *d, *md;
11737 : #if PY_VERSION_HEX >= 0x03000000
11738 : static struct PyModuleDef SWIG_module = {
11739 : # if PY_VERSION_HEX >= 0x03020000
11740 : PyModuleDef_HEAD_INIT,
11741 : # else
11742 : {
11743 : PyObject_HEAD_INIT(NULL)
11744 : NULL, /* m_init */
11745 : 0, /* m_index */
11746 : NULL, /* m_copy */
11747 : },
11748 : # endif
11749 : (char *) SWIG_name,
11750 : NULL,
11751 : -1,
11752 : SwigMethods,
11753 : NULL,
11754 : NULL,
11755 : NULL,
11756 : NULL
11757 : };
11758 : #endif
11759 :
11760 : #if defined(SWIGPYTHON_BUILTIN)
11761 : static SwigPyClientData SwigPyObject_clientdata = {
11762 : 0, 0, 0, 0, 0, 0, 0
11763 : };
11764 : static PyGetSetDef this_getset_def = {
11765 : (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
11766 : };
11767 : static SwigPyGetSet thisown_getset_closure = {
11768 : (PyCFunction) SwigPyObject_own,
11769 : (PyCFunction) SwigPyObject_own
11770 : };
11771 : static PyGetSetDef thisown_getset_def = {
11772 : (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
11773 : };
11774 : PyObject *metatype_args;
11775 : PyTypeObject *builtin_pytype;
11776 : int builtin_base_count;
11777 : swig_type_info *builtin_basetype;
11778 : PyObject *tuple;
11779 : PyGetSetDescrObject *static_getset;
11780 : PyTypeObject *metatype;
11781 : SwigPyClientData *cd;
11782 : PyObject *public_interface, *public_symbol;
11783 : PyObject *this_descr;
11784 : PyObject *thisown_descr;
11785 : PyObject *self = 0;
11786 : int i;
11787 :
11788 : (void)builtin_pytype;
11789 : (void)builtin_base_count;
11790 : (void)builtin_basetype;
11791 : (void)tuple;
11792 : (void)static_getset;
11793 : (void)self;
11794 :
11795 : /* metatype is used to implement static member variables. */
11796 : metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
11797 : assert(metatype_args);
11798 : metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
11799 : assert(metatype);
11800 : Py_DECREF(metatype_args);
11801 : metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
11802 : assert(PyType_Ready(metatype) >= 0);
11803 : #endif
11804 :
11805 : /* Fix SwigMethods to carry the callback ptrs when needed */
11806 3 : SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
11807 :
11808 : #if PY_VERSION_HEX >= 0x03000000
11809 : m = PyModule_Create(&SWIG_module);
11810 : #else
11811 3 : m = Py_InitModule((char *) SWIG_name, SwigMethods);
11812 : #endif
11813 :
11814 3 : md = d = PyModule_GetDict(m);
11815 : (void)md;
11816 :
11817 3 : SWIG_InitializeModule(0);
11818 :
11819 : #ifdef SWIGPYTHON_BUILTIN
11820 : SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
11821 : assert(SwigPyObject_stype);
11822 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
11823 : if (!cd) {
11824 : SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
11825 : SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
11826 : } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
11827 : PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
11828 : # if PY_VERSION_HEX >= 0x03000000
11829 : return NULL;
11830 : # else
11831 : return;
11832 : # endif
11833 : }
11834 :
11835 : /* All objects have a 'this' attribute */
11836 : this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
11837 : (void)this_descr;
11838 :
11839 : /* All objects have a 'thisown' attribute */
11840 : thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
11841 : (void)thisown_descr;
11842 :
11843 : public_interface = PyList_New(0);
11844 : public_symbol = 0;
11845 : (void)public_symbol;
11846 :
11847 : PyDict_SetItemString(md, "__all__", public_interface);
11848 : Py_DECREF(public_interface);
11849 : for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
11850 : SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
11851 : for (i = 0; swig_const_table[i].name != 0; ++i)
11852 : SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
11853 : #endif
11854 :
11855 3 : SWIG_InstallConstants(d,swig_const_table);
11856 :
11857 3 : SWIG_Python_SetConstant(d, "DB_SYSTEM",SWIG_FromCharPtr(KDB_DB_SYSTEM));
11858 3 : SWIG_Python_SetConstant(d, "DB_USER",SWIG_FromCharPtr(KDB_DB_USER));
11859 3 : SWIG_Python_SetConstant(d, "DB_HOME",SWIG_FromCharPtr(KDB_DB_HOME));
11860 3 : SWIG_Python_SetConstant(d, "DEBUG",SWIG_From_bool(static_cast< bool >(DEBUG)));
11861 6 : SWIG_Python_SetConstant(d, "KS_END",SWIG_NewPointerObj(SWIG_as_voidptr(KS_END),SWIGTYPE_p_void, 0 ));
11862 3 : SWIG_Python_SetConstant(d, "VERSION",SWIG_FromCharPtr(KDB_VERSION));
11863 3 : SWIG_Python_SetConstant(d, "VERSION_MAJOR",SWIG_From_short(static_cast< short >(KDB_VERSION_MAJOR)));
11864 3 : SWIG_Python_SetConstant(d, "VERSION_MINOR",SWIG_From_short(static_cast< short >(KDB_VERSION_MINOR)));
11865 3 : SWIG_Python_SetConstant(d, "VERSION_MICRO",SWIG_From_short(static_cast< short >(KDB_VERSION_MICRO)));
11866 3 : SWIG_Python_SetConstant(d, "KDB_VERSION",SWIG_FromCharPtr("0.9.0"));
11867 3 : SWIG_Python_SetConstant(d, "KDB_VERSION_MAJOR",SWIG_From_int(static_cast< int >(0)));
11868 3 : SWIG_Python_SetConstant(d, "KDB_VERSION_MINOR",SWIG_From_int(static_cast< int >(9)));
11869 3 : SWIG_Python_SetConstant(d, "KDB_VERSION_MICRO",SWIG_From_int(static_cast< int >(0)));
11870 3 : SWIG_Python_SetConstant(d, "KEY_NAME",SWIG_From_int(static_cast< int >(KEY_NAME)));
11871 3 : SWIG_Python_SetConstant(d, "KEY_VALUE",SWIG_From_int(static_cast< int >(KEY_VALUE)));
11872 3 : SWIG_Python_SetConstant(d, "KEY_FLAGS",SWIG_From_int(static_cast< int >(KEY_FLAGS)));
11873 3 : SWIG_Python_SetConstant(d, "KEY_OWNER",SWIG_From_int(static_cast< int >(KEY_OWNER)));
11874 3 : SWIG_Python_SetConstant(d, "KEY_COMMENT",SWIG_From_int(static_cast< int >(KEY_COMMENT)));
11875 3 : SWIG_Python_SetConstant(d, "KEY_BINARY",SWIG_From_int(static_cast< int >(KEY_BINARY)));
11876 3 : SWIG_Python_SetConstant(d, "KEY_UID",SWIG_From_int(static_cast< int >(KEY_UID)));
11877 3 : SWIG_Python_SetConstant(d, "KEY_GID",SWIG_From_int(static_cast< int >(KEY_GID)));
11878 3 : SWIG_Python_SetConstant(d, "KEY_MODE",SWIG_From_int(static_cast< int >(KEY_MODE)));
11879 3 : SWIG_Python_SetConstant(d, "KEY_ATIME",SWIG_From_int(static_cast< int >(KEY_ATIME)));
11880 3 : SWIG_Python_SetConstant(d, "KEY_MTIME",SWIG_From_int(static_cast< int >(KEY_MTIME)));
11881 3 : SWIG_Python_SetConstant(d, "KEY_CTIME",SWIG_From_int(static_cast< int >(KEY_CTIME)));
11882 3 : SWIG_Python_SetConstant(d, "KEY_SIZE",SWIG_From_int(static_cast< int >(KEY_SIZE)));
11883 3 : SWIG_Python_SetConstant(d, "KEY_FUNC",SWIG_From_int(static_cast< int >(KEY_FUNC)));
11884 3 : SWIG_Python_SetConstant(d, "KEY_DIR",SWIG_From_int(static_cast< int >(KEY_DIR)));
11885 3 : SWIG_Python_SetConstant(d, "KEY_META",SWIG_From_int(static_cast< int >(KEY_META)));
11886 3 : SWIG_Python_SetConstant(d, "KEY_NULL",SWIG_From_int(static_cast< int >(KEY_NULL)));
11887 3 : SWIG_Python_SetConstant(d, "KEY_CASCADING_NAME",SWIG_From_int(static_cast< int >(KEY_CASCADING_NAME)));
11888 3 : SWIG_Python_SetConstant(d, "KEY_META_NAME",SWIG_From_int(static_cast< int >(KEY_META_NAME)));
11889 3 : SWIG_Python_SetConstant(d, "KEY_END",SWIG_From_int(static_cast< int >(KEY_END)));
11890 3 : SWIG_Python_SetConstant(d, "KDB_O_NONE",SWIG_From_int(static_cast< int >(KDB_O_NONE)));
11891 3 : SWIG_Python_SetConstant(d, "KDB_O_DEL",SWIG_From_int(static_cast< int >(KDB_O_DEL)));
11892 3 : SWIG_Python_SetConstant(d, "KDB_O_POP",SWIG_From_int(static_cast< int >(KDB_O_POP)));
11893 3 : SWIG_Python_SetConstant(d, "KDB_O_NODIR",SWIG_From_int(static_cast< int >(KDB_O_NODIR)));
11894 3 : SWIG_Python_SetConstant(d, "KDB_O_DIRONLY",SWIG_From_int(static_cast< int >(KDB_O_DIRONLY)));
11895 3 : SWIG_Python_SetConstant(d, "KDB_O_NOREMOVE",SWIG_From_int(static_cast< int >(KDB_O_NOREMOVE)));
11896 3 : SWIG_Python_SetConstant(d, "KDB_O_REMOVEONLY",SWIG_From_int(static_cast< int >(KDB_O_REMOVEONLY)));
11897 3 : SWIG_Python_SetConstant(d, "KDB_O_INACTIVE",SWIG_From_int(static_cast< int >(KDB_O_INACTIVE)));
11898 3 : SWIG_Python_SetConstant(d, "KDB_O_SYNC",SWIG_From_int(static_cast< int >(KDB_O_SYNC)));
11899 3 : SWIG_Python_SetConstant(d, "KDB_O_SORT",SWIG_From_int(static_cast< int >(KDB_O_SORT)));
11900 3 : SWIG_Python_SetConstant(d, "KDB_O_NORECURSIVE",SWIG_From_int(static_cast< int >(KDB_O_NORECURSIVE)));
11901 3 : SWIG_Python_SetConstant(d, "KDB_O_NOCASE",SWIG_From_int(static_cast< int >(KDB_O_NOCASE)));
11902 3 : SWIG_Python_SetConstant(d, "KDB_O_WITHOWNER",SWIG_From_int(static_cast< int >(KDB_O_WITHOWNER)));
11903 3 : SWIG_Python_SetConstant(d, "KDB_O_NOALL",SWIG_From_int(static_cast< int >(KDB_O_NOALL)));
11904 3 : SWIG_Python_SetConstant(d, "KEY_NS_NONE",SWIG_From_int(static_cast< int >(KEY_NS_NONE)));
11905 3 : SWIG_Python_SetConstant(d, "KEY_NS_EMPTY",SWIG_From_int(static_cast< int >(KEY_NS_EMPTY)));
11906 3 : SWIG_Python_SetConstant(d, "KEY_NS_META",SWIG_From_int(static_cast< int >(KEY_NS_META)));
11907 3 : SWIG_Python_SetConstant(d, "KEY_NS_CASCADING",SWIG_From_int(static_cast< int >(KEY_NS_CASCADING)));
11908 3 : SWIG_Python_SetConstant(d, "KEY_NS_FIRST",SWIG_From_int(static_cast< int >(KEY_NS_FIRST)));
11909 3 : SWIG_Python_SetConstant(d, "KEY_NS_SPEC",SWIG_From_int(static_cast< int >(KEY_NS_SPEC)));
11910 3 : SWIG_Python_SetConstant(d, "KEY_NS_PROC",SWIG_From_int(static_cast< int >(KEY_NS_PROC)));
11911 3 : SWIG_Python_SetConstant(d, "KEY_NS_DIR",SWIG_From_int(static_cast< int >(KEY_NS_DIR)));
11912 3 : SWIG_Python_SetConstant(d, "KEY_NS_USER",SWIG_From_int(static_cast< int >(KEY_NS_USER)));
11913 3 : SWIG_Python_SetConstant(d, "KEY_NS_SYSTEM",SWIG_From_int(static_cast< int >(KEY_NS_SYSTEM)));
11914 3 : SWIG_Python_SetConstant(d, "KEY_NS_LAST",SWIG_From_int(static_cast< int >(KEY_NS_LAST)));
11915 : #if PY_VERSION_HEX >= 0x03000000
11916 : return m;
11917 : #else
11918 3 : return;
11919 : #endif
11920 6 : }
11921 :
|