Line data Source code
1 : /* ----------------------------------------------------------------------------
2 : * This file was automatically generated by SWIG (http://www.swig.org).
3 : * Version 2.0.12
4 : *
5 : * This file is not intended to be easily readable and contains a number of
6 : * coding conventions designed to improve portability and efficiency. Do not make
7 : * changes to this file unless you know what you are doing--modify the SWIG
8 : * interface file instead.
9 : * ----------------------------------------------------------------------------- */
10 :
11 : #define SWIGPYTHON
12 : #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13 : #define SWIGPYTHON_BUILTIN
14 :
15 : /* -----------------------------------------------------------------------------
16 : * This section contains generic SWIG labels for method/variable
17 : * declarations/attributes, and other compiler dependent labels.
18 : * ----------------------------------------------------------------------------- */
19 :
20 : /* template workaround for compilers that cannot correctly implement the C++ standard */
21 : #ifndef SWIGTEMPLATEDISAMBIGUATOR
22 : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
23 : # define SWIGTEMPLATEDISAMBIGUATOR template
24 : # elif defined(__HP_aCC)
25 : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
26 : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
27 : # define SWIGTEMPLATEDISAMBIGUATOR template
28 : # else
29 : # define SWIGTEMPLATEDISAMBIGUATOR
30 : # endif
31 : #endif
32 :
33 : /* inline attribute */
34 : #ifndef SWIGINLINE
35 : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
36 : # define SWIGINLINE inline
37 : # else
38 : # define SWIGINLINE
39 : # endif
40 : #endif
41 :
42 : /* attribute recognised by some compilers to avoid 'unused' warnings */
43 : #ifndef SWIGUNUSED
44 : # if defined(__GNUC__)
45 : # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
46 : # define SWIGUNUSED __attribute__ ((__unused__))
47 : # else
48 : # define SWIGUNUSED
49 : # endif
50 : # elif defined(__ICC)
51 : # define SWIGUNUSED __attribute__ ((__unused__))
52 : # else
53 : # define SWIGUNUSED
54 : # endif
55 : #endif
56 :
57 : #ifndef SWIG_MSC_UNSUPPRESS_4505
58 : # if defined(_MSC_VER)
59 : # pragma warning(disable : 4505) /* unreferenced local function has been removed */
60 : # endif
61 : #endif
62 :
63 : #ifndef SWIGUNUSEDPARM
64 : # ifdef __cplusplus
65 : # define SWIGUNUSEDPARM(p)
66 : # else
67 : # define SWIGUNUSEDPARM(p) p SWIGUNUSED
68 : # endif
69 : #endif
70 :
71 : /* internal SWIG method */
72 : #ifndef SWIGINTERN
73 : # define SWIGINTERN static SWIGUNUSED
74 : #endif
75 :
76 : /* internal inline SWIG method */
77 : #ifndef SWIGINTERNINLINE
78 : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
79 : #endif
80 :
81 : /* exporting methods */
82 : #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
83 : # ifndef GCC_HASCLASSVISIBILITY
84 : # define GCC_HASCLASSVISIBILITY
85 : # endif
86 : #endif
87 :
88 : #ifndef SWIGEXPORT
89 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
90 : # if defined(STATIC_LINKED)
91 : # define SWIGEXPORT
92 : # else
93 : # define SWIGEXPORT __declspec(dllexport)
94 : # endif
95 : # else
96 : # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
97 : # define SWIGEXPORT __attribute__ ((visibility("default")))
98 : # else
99 : # define SWIGEXPORT
100 : # endif
101 : # endif
102 : #endif
103 :
104 : /* calling conventions for Windows */
105 : #ifndef SWIGSTDCALL
106 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
107 : # define SWIGSTDCALL __stdcall
108 : # else
109 : # define SWIGSTDCALL
110 : # endif
111 : #endif
112 :
113 : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
114 : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
115 : # define _CRT_SECURE_NO_DEPRECATE
116 : #endif
117 :
118 : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
119 : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
120 : # define _SCL_SECURE_NO_DEPRECATE
121 : #endif
122 :
123 :
124 :
125 : #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
126 : /* Use debug wrappers with the Python release dll */
127 : # undef _DEBUG
128 : # include <Python.h>
129 : # define _DEBUG
130 : #else
131 : # include <Python.h>
132 : #endif
133 :
134 : /* -----------------------------------------------------------------------------
135 : * swigrun.swg
136 : *
137 : * This file contains generic C API SWIG runtime support for pointer
138 : * type checking.
139 : * ----------------------------------------------------------------------------- */
140 :
141 : /* This should only be incremented when either the layout of swig_type_info changes,
142 : or for whatever reason, the runtime changes incompatibly */
143 : #define SWIG_RUNTIME_VERSION "4"
144 :
145 : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
146 : #ifdef SWIG_TYPE_TABLE
147 : # define SWIG_QUOTE_STRING(x) #x
148 : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
149 : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
150 : #else
151 : # define SWIG_TYPE_TABLE_NAME
152 : #endif
153 :
154 : /*
155 : You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
156 : creating a static or dynamic library from the SWIG runtime code.
157 : In 99.9% of the cases, SWIG just needs to declare them as 'static'.
158 :
159 : But only do this if strictly necessary, ie, if you have problems
160 : with your compiler or suchlike.
161 : */
162 :
163 : #ifndef SWIGRUNTIME
164 : # define SWIGRUNTIME SWIGINTERN
165 : #endif
166 :
167 : #ifndef SWIGRUNTIMEINLINE
168 : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
169 : #endif
170 :
171 : /* Generic buffer size */
172 : #ifndef SWIG_BUFFER_SIZE
173 : # define SWIG_BUFFER_SIZE 1024
174 : #endif
175 :
176 : /* Flags for pointer conversions */
177 : #define SWIG_POINTER_DISOWN 0x1
178 : #define SWIG_CAST_NEW_MEMORY 0x2
179 :
180 : /* Flags for new pointer objects */
181 : #define SWIG_POINTER_OWN 0x1
182 :
183 :
184 : /*
185 : Flags/methods for returning states.
186 :
187 : The SWIG conversion methods, as ConvertPtr, return an integer
188 : that tells if the conversion was successful or not. And if not,
189 : an error code can be returned (see swigerrors.swg for the codes).
190 :
191 : Use the following macros/flags to set or process the returning
192 : states.
193 :
194 : In old versions of SWIG, code such as the following was usually written:
195 :
196 : if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
197 : // success code
198 : } else {
199 : //fail code
200 : }
201 :
202 : Now you can be more explicit:
203 :
204 : int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
205 : if (SWIG_IsOK(res)) {
206 : // success code
207 : } else {
208 : // fail code
209 : }
210 :
211 : which is the same really, but now you can also do
212 :
213 : Type *ptr;
214 : int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
215 : if (SWIG_IsOK(res)) {
216 : // success code
217 : if (SWIG_IsNewObj(res) {
218 : ...
219 : delete *ptr;
220 : } else {
221 : ...
222 : }
223 : } else {
224 : // fail code
225 : }
226 :
227 : I.e., now SWIG_ConvertPtr can return new objects and you can
228 : identify the case and take care of the deallocation. Of course that
229 : also requires SWIG_ConvertPtr to return new result values, such as
230 :
231 : int SWIG_ConvertPtr(obj, ptr,...) {
232 : if (<obj is ok>) {
233 : if (<need new object>) {
234 : *ptr = <ptr to new allocated object>;
235 : return SWIG_NEWOBJ;
236 : } else {
237 : *ptr = <ptr to old object>;
238 : return SWIG_OLDOBJ;
239 : }
240 : } else {
241 : return SWIG_BADOBJ;
242 : }
243 : }
244 :
245 : Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
246 : more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
247 : SWIG errors code.
248 :
249 : Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
250 : allows to return the 'cast rank', for example, if you have this
251 :
252 : int food(double)
253 : int fooi(int);
254 :
255 : and you call
256 :
257 : food(1) // cast rank '1' (1 -> 1.0)
258 : fooi(1) // cast rank '0'
259 :
260 : just use the SWIG_AddCast()/SWIG_CheckState()
261 : */
262 :
263 : #define SWIG_OK (0)
264 : #define SWIG_ERROR (-1)
265 : #define SWIG_IsOK(r) (r >= 0)
266 : #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
267 :
268 : /* The CastRankLimit says how many bits are used for the cast rank */
269 : #define SWIG_CASTRANKLIMIT (1 << 8)
270 : /* The NewMask denotes the object was created (using new/malloc) */
271 : #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
272 : /* The TmpMask is for in/out typemaps that use temporal objects */
273 : #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
274 : /* Simple returning values */
275 : #define SWIG_BADOBJ (SWIG_ERROR)
276 : #define SWIG_OLDOBJ (SWIG_OK)
277 : #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
278 : #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
279 : /* Check, add and del mask methods */
280 : #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
281 : #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
282 : #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
283 : #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
284 : #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
285 : #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
286 :
287 : /* Cast-Rank Mode */
288 : #if defined(SWIG_CASTRANK_MODE)
289 : # ifndef SWIG_TypeRank
290 : # define SWIG_TypeRank unsigned long
291 : # endif
292 : # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
293 : # define SWIG_MAXCASTRANK (2)
294 : # endif
295 : # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
296 : # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
297 : SWIGINTERNINLINE int SWIG_AddCast(int r) {
298 : return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
299 : }
300 : SWIGINTERNINLINE int SWIG_CheckState(int r) {
301 : return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
302 : }
303 : #else /* no cast-rank mode */
304 : # define SWIG_AddCast(r) (r)
305 : # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
306 : #endif
307 :
308 :
309 : #include <string.h>
310 :
311 : #ifdef __cplusplus
312 : extern "C" {
313 : #endif
314 :
315 : typedef void *(*swig_converter_func)(void *, int *);
316 : typedef struct swig_type_info *(*swig_dycast_func)(void **);
317 :
318 : /* Structure to store information on one type */
319 : typedef struct swig_type_info {
320 : const char *name; /* mangled name of this type */
321 : const char *str; /* human readable name of this type */
322 : swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 : struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 : void *clientdata; /* language specific type data */
325 : int owndata; /* flag if the structure owns the clientdata */
326 : } swig_type_info;
327 :
328 : /* Structure to store a type and conversion function used for casting */
329 : typedef struct swig_cast_info {
330 : swig_type_info *type; /* pointer to type that is equivalent to this type */
331 : swig_converter_func converter; /* function to cast the void pointers */
332 : struct swig_cast_info *next; /* pointer to next cast in linked list */
333 : struct swig_cast_info *prev; /* pointer to the previous cast */
334 : } swig_cast_info;
335 :
336 : /* Structure used to store module information
337 : * Each module generates one structure like this, and the runtime collects
338 : * all of these structures and stores them in a circularly linked list.*/
339 : typedef struct swig_module_info {
340 : swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 : size_t size; /* Number of types in this module */
342 : struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 : swig_type_info **type_initial; /* Array of initially generated type structures */
344 : swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 : void *clientdata; /* Language specific module data */
346 : } swig_module_info;
347 :
348 : /*
349 : Compare two type names skipping the space characters, therefore
350 : "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351 :
352 : Return 0 when the two name types are equivalent, as in
353 : strncmp, but skipping ' '.
354 : */
355 : SWIGRUNTIME int
356 0 : SWIG_TypeNameComp(const char *f1, const char *l1,
357 : const char *f2, const char *l2) {
358 0 : for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 0 : while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 0 : while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 0 : if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 : }
363 0 : return (int)((l1 - f1) - (l2 - f2));
364 : }
365 :
366 : /*
367 : Check type equivalence in a name list like <name1>|<name2>|...
368 : Return 0 if equal, -1 if nb < tb, 1 if nb > tb
369 : */
370 : SWIGRUNTIME int
371 0 : SWIG_TypeCmp(const char *nb, const char *tb) {
372 0 : int equiv = 1;
373 0 : const char* te = tb + strlen(tb);
374 0 : const char* ne = nb;
375 0 : while (equiv != 0 && *ne) {
376 0 : for (nb = ne; *ne; ++ne) {
377 0 : if (*ne == '|') break;
378 : }
379 0 : equiv = SWIG_TypeNameComp(nb, ne, tb, te);
380 0 : if (*ne) ++ne;
381 : }
382 0 : return equiv;
383 : }
384 :
385 : /*
386 : Check type equivalence in a name list like <name1>|<name2>|...
387 : Return 0 if not equal, 1 if equal
388 : */
389 : SWIGRUNTIME int
390 : SWIG_TypeEquiv(const char *nb, const char *tb) {
391 0 : return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
392 : }
393 :
394 : /*
395 : Check the typename
396 : */
397 : SWIGRUNTIME swig_cast_info *
398 0 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
399 0 : if (ty) {
400 0 : swig_cast_info *iter = ty->cast;
401 0 : while (iter) {
402 0 : if (strcmp(iter->type->name, c) == 0) {
403 0 : if (iter == ty->cast)
404 0 : return iter;
405 : /* Move iter to the top of the linked list */
406 0 : iter->prev->next = iter->next;
407 0 : if (iter->next)
408 0 : iter->next->prev = iter->prev;
409 0 : iter->next = ty->cast;
410 0 : iter->prev = 0;
411 0 : if (ty->cast) ty->cast->prev = iter;
412 0 : ty->cast = iter;
413 0 : return iter;
414 : }
415 0 : iter = iter->next;
416 : }
417 : }
418 : return 0;
419 : }
420 :
421 : /*
422 : Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
423 : */
424 : SWIGRUNTIME swig_cast_info *
425 : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
426 : if (ty) {
427 : swig_cast_info *iter = ty->cast;
428 : while (iter) {
429 : if (iter->type == from) {
430 : if (iter == ty->cast)
431 : return iter;
432 : /* Move iter to the top of the linked list */
433 : iter->prev->next = iter->next;
434 : if (iter->next)
435 : iter->next->prev = iter->prev;
436 : iter->next = ty->cast;
437 : iter->prev = 0;
438 : if (ty->cast) ty->cast->prev = iter;
439 : ty->cast = iter;
440 : return iter;
441 : }
442 : iter = iter->next;
443 : }
444 : }
445 : return 0;
446 : }
447 :
448 : /*
449 : Cast a pointer up an inheritance hierarchy
450 : */
451 : SWIGRUNTIMEINLINE void *
452 : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
453 0 : return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
454 : }
455 :
456 : /*
457 : Dynamic pointer casting. Down an inheritance hierarchy
458 : */
459 : SWIGRUNTIME swig_type_info *
460 : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
461 : swig_type_info *lastty = ty;
462 : if (!ty || !ty->dcast) return ty;
463 : while (ty && (ty->dcast)) {
464 : ty = (*ty->dcast)(ptr);
465 : if (ty) lastty = ty;
466 : }
467 : return lastty;
468 : }
469 :
470 : /*
471 : Return the name associated with this type
472 : */
473 : SWIGRUNTIMEINLINE const char *
474 : SWIG_TypeName(const swig_type_info *ty) {
475 : return ty->name;
476 : }
477 :
478 : /*
479 : Return the pretty name associated with this type,
480 : that is an unmangled type name in a form presentable to the user.
481 : */
482 : SWIGRUNTIME const char *
483 : SWIG_TypePrettyName(const swig_type_info *type) {
484 : /* The "str" field contains the equivalent pretty names of the
485 : type, separated by vertical-bar characters. We choose
486 : to print the last name, as it is often (?) the most
487 : specific. */
488 0 : if (!type) return NULL;
489 0 : if (type->str != NULL) {
490 : const char *last_name = type->str;
491 : const char *s;
492 0 : for (s = type->str; *s; s++)
493 0 : if (*s == '|') last_name = s+1;
494 0 : return last_name;
495 : }
496 : else
497 0 : return type->name;
498 : }
499 :
500 : /*
501 : Set the clientdata field for a type
502 : */
503 : SWIGRUNTIME void
504 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
505 : swig_cast_info *cast = ti->cast;
506 : /* if (ti->clientdata == clientdata) return; */
507 : ti->clientdata = clientdata;
508 :
509 : while (cast) {
510 : if (!cast->converter) {
511 : swig_type_info *tc = cast->type;
512 : if (!tc->clientdata) {
513 : SWIG_TypeClientData(tc, clientdata);
514 : }
515 : }
516 : cast = cast->next;
517 : }
518 : }
519 : SWIGRUNTIME void
520 : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
521 : SWIG_TypeClientData(ti, clientdata);
522 : ti->owndata = 1;
523 : }
524 :
525 : /*
526 : Search for a swig_type_info structure only by mangled name
527 : Search is a O(log #types)
528 :
529 : We start searching at module start, and finish searching when start == end.
530 : Note: if start == end at the beginning of the function, we go all the way around
531 : the circular list.
532 : */
533 : SWIGRUNTIME swig_type_info *
534 23 : SWIG_MangledTypeQueryModule(swig_module_info *start,
535 : swig_module_info *end,
536 : const char *name) {
537 23 : swig_module_info *iter = start;
538 : do {
539 23 : if (iter->size) {
540 23 : register size_t l = 0;
541 23 : register size_t r = iter->size - 1;
542 : do {
543 : /* since l+r >= 0, we can (>> 1) instead (/ 2) */
544 115 : register size_t i = (l + r) >> 1;
545 115 : const char *iname = iter->types[i]->name;
546 115 : if (iname) {
547 115 : register int compare = strcmp(name, iname);
548 115 : if (compare == 0) {
549 23 : return iter->types[i];
550 92 : } else if (compare < 0) {
551 92 : if (i) {
552 92 : r = i - 1;
553 : } else {
554 : break;
555 : }
556 0 : } else if (compare > 0) {
557 0 : l = i + 1;
558 : }
559 : } else {
560 : break; /* should never happen */
561 : }
562 92 : } while (l <= r);
563 : }
564 0 : iter = iter->next;
565 0 : } while (iter != end);
566 : return 0;
567 : }
568 :
569 : /*
570 : Search for a swig_type_info structure for either a mangled name or a human readable name.
571 : It first searches the mangled names of the types, which is a O(log #types)
572 : If a type is not found it then searches the human readable names, which is O(#types).
573 :
574 : We start searching at module start, and finish searching when start == end.
575 : Note: if start == end at the beginning of the function, we go all the way around
576 : the circular list.
577 : */
578 : SWIGRUNTIME swig_type_info *
579 0 : SWIG_TypeQueryModule(swig_module_info *start,
580 : swig_module_info *end,
581 : const char *name) {
582 : /* STEP 1: Search the name field using binary search */
583 0 : swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
584 0 : if (ret) {
585 : return ret;
586 : } else {
587 : /* STEP 2: If the type hasn't been found, do a complete search
588 : of the str field (the human readable name) */
589 : swig_module_info *iter = start;
590 : do {
591 0 : register size_t i = 0;
592 0 : for (; i < iter->size; ++i) {
593 0 : if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
594 0 : return iter->types[i];
595 : }
596 0 : iter = iter->next;
597 0 : } while (iter != end);
598 : }
599 :
600 : /* neither found a match */
601 : return 0;
602 : }
603 :
604 : /*
605 : Pack binary data into a string
606 : */
607 : SWIGRUNTIME char *
608 : SWIG_PackData(char *c, void *ptr, size_t sz) {
609 : static const char hex[17] = "0123456789abcdef";
610 0 : register const unsigned char *u = (unsigned char *) ptr;
611 0 : register const unsigned char *eu = u + sz;
612 0 : for (; u != eu; ++u) {
613 0 : register unsigned char uu = *u;
614 0 : *(c++) = hex[(uu & 0xf0) >> 4];
615 0 : *(c++) = hex[uu & 0xf];
616 : }
617 0 : return c;
618 : }
619 :
620 : /*
621 : Unpack binary data from a string
622 : */
623 : SWIGRUNTIME const char *
624 0 : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
625 0 : register unsigned char *u = (unsigned char *) ptr;
626 0 : register const unsigned char *eu = u + sz;
627 0 : for (; u != eu; ++u) {
628 0 : register char d = *(c++);
629 : register unsigned char uu;
630 0 : if ((d >= '0') && (d <= '9'))
631 0 : uu = ((d - '0') << 4);
632 0 : else if ((d >= 'a') && (d <= 'f'))
633 0 : uu = ((d - ('a'-10)) << 4);
634 : else
635 : return (char *) 0;
636 0 : d = *(c++);
637 0 : if ((d >= '0') && (d <= '9'))
638 0 : uu |= (d - '0');
639 0 : else if ((d >= 'a') && (d <= 'f'))
640 0 : uu |= (d - ('a'-10));
641 : else
642 : return (char *) 0;
643 0 : *u = uu;
644 : }
645 0 : return c;
646 : }
647 :
648 : /*
649 : Pack 'void *' into a string buffer.
650 : */
651 : SWIGRUNTIME char *
652 0 : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
653 0 : char *r = buff;
654 0 : if ((2*sizeof(void *) + 2) > bsz) return 0;
655 0 : *(r++) = '_';
656 0 : r = SWIG_PackData(r,&ptr,sizeof(void *));
657 0 : if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
658 : strcpy(r,name);
659 0 : return buff;
660 : }
661 :
662 : SWIGRUNTIME const char *
663 0 : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
664 0 : if (*c != '_') {
665 0 : if (strcmp(c,"NULL") == 0) {
666 0 : *ptr = (void *) 0;
667 0 : return name;
668 : } else {
669 : return 0;
670 : }
671 : }
672 0 : return SWIG_UnpackData(++c,ptr,sizeof(void *));
673 : }
674 :
675 : SWIGRUNTIME char *
676 0 : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
677 0 : char *r = buff;
678 0 : size_t lname = (name ? strlen(name) : 0);
679 0 : if ((2*sz + 2 + lname) > bsz) return 0;
680 0 : *(r++) = '_';
681 0 : r = SWIG_PackData(r,ptr,sz);
682 0 : if (lname) {
683 0 : strncpy(r,name,lname+1);
684 : } else {
685 0 : *r = 0;
686 : }
687 0 : return buff;
688 : }
689 :
690 : SWIGRUNTIME const char *
691 : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
692 : if (*c != '_') {
693 : if (strcmp(c,"NULL") == 0) {
694 : memset(ptr,0,sz);
695 : return name;
696 : } else {
697 : return 0;
698 : }
699 : }
700 : return SWIG_UnpackData(++c,ptr,sz);
701 : }
702 :
703 : #ifdef __cplusplus
704 : }
705 : #endif
706 :
707 : /* Errors in SWIG */
708 : #define SWIG_UnknownError -1
709 : #define SWIG_IOError -2
710 : #define SWIG_RuntimeError -3
711 : #define SWIG_IndexError -4
712 : #define SWIG_TypeError -5
713 : #define SWIG_DivisionByZero -6
714 : #define SWIG_OverflowError -7
715 : #define SWIG_SyntaxError -8
716 : #define SWIG_ValueError -9
717 : #define SWIG_SystemError -10
718 : #define SWIG_AttributeError -11
719 : #define SWIG_MemoryError -12
720 : #define SWIG_NullReferenceError -13
721 :
722 :
723 :
724 : /* Compatibility macros for Python 3 */
725 : #if PY_VERSION_HEX >= 0x03000000
726 :
727 : #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
728 : #define PyInt_Check(x) PyLong_Check(x)
729 : #define PyInt_AsLong(x) PyLong_AsLong(x)
730 : #define PyInt_FromLong(x) PyLong_FromLong(x)
731 : #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
732 : #define PyString_Check(name) PyBytes_Check(name)
733 : #define PyString_FromString(x) PyUnicode_FromString(x)
734 : #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
735 : #define PyString_AsString(str) PyBytes_AsString(str)
736 : #define PyString_Size(str) PyBytes_Size(str)
737 : #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
738 : #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
739 : #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
740 : #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
741 :
742 : #endif
743 :
744 : #ifndef Py_TYPE
745 : # define Py_TYPE(op) ((op)->ob_type)
746 : #endif
747 :
748 : /* SWIG APIs for compatibility of both Python 2 & 3 */
749 :
750 : #if PY_VERSION_HEX >= 0x03000000
751 : # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
752 : #else
753 : # define SWIG_Python_str_FromFormat PyString_FromFormat
754 : #endif
755 :
756 :
757 : /* Warning: This function will allocate a new string in Python 3,
758 : * so please call SWIG_Python_str_DelForPy3(x) to free the space.
759 : */
760 : SWIGINTERN char*
761 0 : SWIG_Python_str_AsChar(PyObject *str)
762 : {
763 : #if PY_VERSION_HEX >= 0x03000000
764 : char *cstr;
765 : char *newstr;
766 : Py_ssize_t len;
767 0 : str = PyUnicode_AsUTF8String(str);
768 0 : PyBytes_AsStringAndSize(str, &cstr, &len);
769 0 : newstr = (char *) malloc(len+1);
770 0 : memcpy(newstr, cstr, len+1);
771 0 : Py_XDECREF(str);
772 0 : return newstr;
773 : #else
774 : return PyString_AsString(str);
775 : #endif
776 : }
777 :
778 : #if PY_VERSION_HEX >= 0x03000000
779 : # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
780 : #else
781 : # define SWIG_Python_str_DelForPy3(x)
782 : #endif
783 :
784 :
785 : SWIGINTERN PyObject*
786 : SWIG_Python_str_FromChar(const char *c)
787 : {
788 : #if PY_VERSION_HEX >= 0x03000000
789 23 : return PyUnicode_FromString(c);
790 : #else
791 : return PyString_FromString(c);
792 : #endif
793 : }
794 :
795 : /* Add PyOS_snprintf for old Pythons */
796 : #if PY_VERSION_HEX < 0x02020000
797 : # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
798 : # define PyOS_snprintf _snprintf
799 : # else
800 : # define PyOS_snprintf snprintf
801 : # endif
802 : #endif
803 :
804 : /* A crude PyString_FromFormat implementation for old Pythons */
805 : #if PY_VERSION_HEX < 0x02020000
806 :
807 : #ifndef SWIG_PYBUFFER_SIZE
808 : # define SWIG_PYBUFFER_SIZE 1024
809 : #endif
810 :
811 : static PyObject *
812 : PyString_FromFormat(const char *fmt, ...) {
813 : va_list ap;
814 : char buf[SWIG_PYBUFFER_SIZE * 2];
815 : int res;
816 : va_start(ap, fmt);
817 : res = vsnprintf(buf, sizeof(buf), fmt, ap);
818 : va_end(ap);
819 : return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
820 : }
821 : #endif
822 :
823 : /* Add PyObject_Del for old Pythons */
824 : #if PY_VERSION_HEX < 0x01060000
825 : # define PyObject_Del(op) PyMem_DEL((op))
826 : #endif
827 : #ifndef PyObject_DEL
828 : # define PyObject_DEL PyObject_Del
829 : #endif
830 :
831 : /* A crude PyExc_StopIteration exception for old Pythons */
832 : #if PY_VERSION_HEX < 0x02020000
833 : # ifndef PyExc_StopIteration
834 : # define PyExc_StopIteration PyExc_RuntimeError
835 : # endif
836 : # ifndef PyObject_GenericGetAttr
837 : # define PyObject_GenericGetAttr 0
838 : # endif
839 : #endif
840 :
841 : /* Py_NotImplemented is defined in 2.1 and up. */
842 : #if PY_VERSION_HEX < 0x02010000
843 : # ifndef Py_NotImplemented
844 : # define Py_NotImplemented PyExc_RuntimeError
845 : # endif
846 : #endif
847 :
848 : /* A crude PyString_AsStringAndSize implementation for old Pythons */
849 : #if PY_VERSION_HEX < 0x02010000
850 : # ifndef PyString_AsStringAndSize
851 : # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
852 : # endif
853 : #endif
854 :
855 : /* PySequence_Size for old Pythons */
856 : #if PY_VERSION_HEX < 0x02000000
857 : # ifndef PySequence_Size
858 : # define PySequence_Size PySequence_Length
859 : # endif
860 : #endif
861 :
862 : /* PyBool_FromLong for old Pythons */
863 : #if PY_VERSION_HEX < 0x02030000
864 : static
865 : PyObject *PyBool_FromLong(long ok)
866 : {
867 : PyObject *result = ok ? Py_True : Py_False;
868 : Py_INCREF(result);
869 : return result;
870 : }
871 : #endif
872 :
873 : /* Py_ssize_t for old Pythons */
874 : /* This code is as recommended by: */
875 : /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
876 : #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
877 : typedef int Py_ssize_t;
878 : # define PY_SSIZE_T_MAX INT_MAX
879 : # define PY_SSIZE_T_MIN INT_MIN
880 : typedef inquiry lenfunc;
881 : typedef intargfunc ssizeargfunc;
882 : typedef intintargfunc ssizessizeargfunc;
883 : typedef intobjargproc ssizeobjargproc;
884 : typedef intintobjargproc ssizessizeobjargproc;
885 : typedef getreadbufferproc readbufferproc;
886 : typedef getwritebufferproc writebufferproc;
887 : typedef getsegcountproc segcountproc;
888 : typedef getcharbufferproc charbufferproc;
889 : static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
890 : {
891 : long result = 0;
892 : PyObject *i = PyNumber_Int(x);
893 : if (i) {
894 : result = PyInt_AsLong(i);
895 : Py_DECREF(i);
896 : }
897 : return result;
898 : }
899 : #endif
900 :
901 : #if PY_VERSION_HEX < 0x02050000
902 : #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
903 : #endif
904 :
905 : #if PY_VERSION_HEX < 0x02040000
906 : #define Py_VISIT(op) \
907 : do { \
908 : if (op) { \
909 : int vret = visit((op), arg); \
910 : if (vret) \
911 : return vret; \
912 : } \
913 : } while (0)
914 : #endif
915 :
916 : #if PY_VERSION_HEX < 0x02030000
917 : typedef struct {
918 : PyTypeObject type;
919 : PyNumberMethods as_number;
920 : PyMappingMethods as_mapping;
921 : PySequenceMethods as_sequence;
922 : PyBufferProcs as_buffer;
923 : PyObject *name, *slots;
924 : } PyHeapTypeObject;
925 : #endif
926 :
927 : #if PY_VERSION_HEX < 0x02030000
928 : typedef destructor freefunc;
929 : #endif
930 :
931 : #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
932 : (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
933 : (PY_MAJOR_VERSION > 3))
934 : # define SWIGPY_USE_CAPSULE
935 : # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
936 : #endif
937 :
938 : #if PY_VERSION_HEX < 0x03020000
939 : #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
940 : #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
941 : #endif
942 :
943 : /* -----------------------------------------------------------------------------
944 : * error manipulation
945 : * ----------------------------------------------------------------------------- */
946 :
947 : SWIGRUNTIME PyObject*
948 0 : SWIG_Python_ErrorType(int code) {
949 0 : PyObject* type = 0;
950 0 : switch(code) {
951 : case SWIG_MemoryError:
952 0 : type = PyExc_MemoryError;
953 0 : break;
954 : case SWIG_IOError:
955 0 : type = PyExc_IOError;
956 0 : break;
957 : case SWIG_RuntimeError:
958 0 : type = PyExc_RuntimeError;
959 0 : break;
960 : case SWIG_IndexError:
961 0 : type = PyExc_IndexError;
962 0 : break;
963 : case SWIG_TypeError:
964 0 : type = PyExc_TypeError;
965 0 : break;
966 : case SWIG_DivisionByZero:
967 0 : type = PyExc_ZeroDivisionError;
968 0 : break;
969 : case SWIG_OverflowError:
970 0 : type = PyExc_OverflowError;
971 0 : break;
972 : case SWIG_SyntaxError:
973 0 : type = PyExc_SyntaxError;
974 0 : break;
975 : case SWIG_ValueError:
976 0 : type = PyExc_ValueError;
977 0 : break;
978 : case SWIG_SystemError:
979 0 : type = PyExc_SystemError;
980 0 : break;
981 : case SWIG_AttributeError:
982 0 : type = PyExc_AttributeError;
983 0 : break;
984 : default:
985 0 : type = PyExc_RuntimeError;
986 : }
987 0 : return type;
988 : }
989 :
990 :
991 : SWIGRUNTIME void
992 : SWIG_Python_AddErrorMsg(const char* mesg)
993 : {
994 : PyObject *type = 0;
995 : PyObject *value = 0;
996 : PyObject *traceback = 0;
997 :
998 : if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
999 : if (value) {
1000 : char *tmp;
1001 : PyObject *old_str = PyObject_Str(value);
1002 : PyErr_Clear();
1003 : Py_XINCREF(type);
1004 :
1005 : PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1006 : SWIG_Python_str_DelForPy3(tmp);
1007 : Py_DECREF(old_str);
1008 : Py_DECREF(value);
1009 : } else {
1010 : PyErr_SetString(PyExc_RuntimeError, mesg);
1011 : }
1012 : }
1013 :
1014 : #if defined(SWIG_PYTHON_NO_THREADS)
1015 : # if defined(SWIG_PYTHON_THREADS)
1016 : # undef SWIG_PYTHON_THREADS
1017 : # endif
1018 : #endif
1019 : #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1020 : # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1021 : # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1022 : # define SWIG_PYTHON_USE_GIL
1023 : # endif
1024 : # endif
1025 : # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1026 : # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1027 : # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1028 : # endif
1029 : # ifdef __cplusplus /* C++ code */
1030 : class SWIG_Python_Thread_Block {
1031 : bool status;
1032 : PyGILState_STATE state;
1033 : public:
1034 : void end() { if (status) { PyGILState_Release(state); status = false;} }
1035 : SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1036 : ~SWIG_Python_Thread_Block() { end(); }
1037 : };
1038 : class SWIG_Python_Thread_Allow {
1039 : bool status;
1040 : PyThreadState *save;
1041 : public:
1042 : void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1043 : SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1044 : ~SWIG_Python_Thread_Allow() { end(); }
1045 : };
1046 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1047 : # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1048 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1049 : # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1050 : # else /* C code */
1051 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1052 : # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1053 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1054 : # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1055 : # endif
1056 : # else /* Old thread way, not implemented, user must provide it */
1057 : # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1058 : # define SWIG_PYTHON_INITIALIZE_THREADS
1059 : # endif
1060 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1061 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1062 : # endif
1063 : # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1064 : # define SWIG_PYTHON_THREAD_END_BLOCK
1065 : # endif
1066 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1067 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1068 : # endif
1069 : # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1070 : # define SWIG_PYTHON_THREAD_END_ALLOW
1071 : # endif
1072 : # endif
1073 : #else /* No thread support */
1074 : # define SWIG_PYTHON_INITIALIZE_THREADS
1075 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1076 : # define SWIG_PYTHON_THREAD_END_BLOCK
1077 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1078 : # define SWIG_PYTHON_THREAD_END_ALLOW
1079 : #endif
1080 :
1081 : /* -----------------------------------------------------------------------------
1082 : * Python API portion that goes into the runtime
1083 : * ----------------------------------------------------------------------------- */
1084 :
1085 : #ifdef __cplusplus
1086 : extern "C" {
1087 : #endif
1088 :
1089 : /* -----------------------------------------------------------------------------
1090 : * Constant declarations
1091 : * ----------------------------------------------------------------------------- */
1092 :
1093 : /* Constant Types */
1094 : #define SWIG_PY_POINTER 4
1095 : #define SWIG_PY_BINARY 5
1096 :
1097 : /* Constant information structure */
1098 : typedef struct swig_const_info {
1099 : int type;
1100 : char *name;
1101 : long lvalue;
1102 : double dvalue;
1103 : void *pvalue;
1104 : swig_type_info **ptype;
1105 : } swig_const_info;
1106 :
1107 :
1108 : /* -----------------------------------------------------------------------------
1109 : * Wrapper of PyInstanceMethod_New() used in Python 3
1110 : * It is exported to the generated module, used for -fastproxy
1111 : * ----------------------------------------------------------------------------- */
1112 : #if PY_VERSION_HEX >= 0x03000000
1113 0 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1114 : {
1115 0 : return PyInstanceMethod_New(func);
1116 : }
1117 : #else
1118 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1119 : {
1120 : return NULL;
1121 : }
1122 : #endif
1123 :
1124 : #ifdef __cplusplus
1125 : }
1126 : #endif
1127 :
1128 :
1129 : /* -----------------------------------------------------------------------------
1130 : * pyrun.swg
1131 : *
1132 : * This file contains the runtime support for Python modules
1133 : * and includes code for managing global variables and pointer
1134 : * type checking.
1135 : *
1136 : * ----------------------------------------------------------------------------- */
1137 :
1138 : /* Common SWIG API */
1139 :
1140 : /* for raw pointers */
1141 : #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1142 : #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1143 : #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1144 :
1145 : #ifdef SWIGPYTHON_BUILTIN
1146 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1147 : #else
1148 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1149 : #endif
1150 :
1151 : #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1152 :
1153 : #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1154 : #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1155 : #define swig_owntype int
1156 :
1157 : /* for raw packed data */
1158 : #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1159 : #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1160 :
1161 : /* for class or struct pointers */
1162 : #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1163 : #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1164 :
1165 : /* for C or C++ function pointers */
1166 : #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1167 : #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1168 :
1169 : /* for C++ member pointers, ie, member methods */
1170 : #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1171 : #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1172 :
1173 :
1174 : /* Runtime API */
1175 :
1176 : #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1177 : #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1178 : #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1179 :
1180 : #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1181 : #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1182 : #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1183 : #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1184 : #define SWIG_fail goto fail
1185 :
1186 :
1187 : /* Runtime API implementation */
1188 :
1189 : /* Error manipulation */
1190 :
1191 : SWIGINTERN void
1192 : SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1193 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1194 : PyErr_SetObject(errtype, obj);
1195 : Py_DECREF(obj);
1196 : SWIG_PYTHON_THREAD_END_BLOCK;
1197 : }
1198 :
1199 : SWIGINTERN void
1200 : SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1201 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1202 0 : PyErr_SetString(errtype, msg);
1203 : SWIG_PYTHON_THREAD_END_BLOCK;
1204 : }
1205 :
1206 : #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1207 :
1208 : /* Set a constant value */
1209 :
1210 : #if defined(SWIGPYTHON_BUILTIN)
1211 :
1212 : SWIGINTERN void
1213 24265 : SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1214 24265 : PyObject *s = PyString_InternFromString(key);
1215 24265 : PyList_Append(seq, s);
1216 24265 : Py_DECREF(s);
1217 24265 : }
1218 :
1219 : SWIGINTERN void
1220 19090 : SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1221 : #if PY_VERSION_HEX < 0x02030000
1222 : PyDict_SetItemString(d, (char *)name, obj);
1223 : #else
1224 19090 : PyDict_SetItemString(d, name, obj);
1225 : #endif
1226 19090 : Py_DECREF(obj);
1227 19090 : if (public_interface)
1228 19090 : SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1229 19090 : }
1230 :
1231 : #else
1232 :
1233 : SWIGINTERN void
1234 : SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1235 : #if PY_VERSION_HEX < 0x02030000
1236 : PyDict_SetItemString(d, (char *)name, obj);
1237 : #else
1238 : PyDict_SetItemString(d, name, obj);
1239 : #endif
1240 : Py_DECREF(obj);
1241 : }
1242 :
1243 : #endif
1244 :
1245 : /* Append a value to the result obj */
1246 :
1247 : SWIGINTERN PyObject*
1248 : SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1249 : #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1250 : if (!result) {
1251 : result = obj;
1252 : } else if (result == Py_None) {
1253 : Py_DECREF(result);
1254 : result = obj;
1255 : } else {
1256 : if (!PyList_Check(result)) {
1257 : PyObject *o2 = result;
1258 : result = PyList_New(1);
1259 : PyList_SetItem(result, 0, o2);
1260 : }
1261 : PyList_Append(result,obj);
1262 : Py_DECREF(obj);
1263 : }
1264 : return result;
1265 : #else
1266 : PyObject* o2;
1267 : PyObject* o3;
1268 : if (!result) {
1269 : result = obj;
1270 : } else if (result == Py_None) {
1271 : Py_DECREF(result);
1272 : result = obj;
1273 : } else {
1274 : if (!PyTuple_Check(result)) {
1275 : o2 = result;
1276 : result = PyTuple_New(1);
1277 : PyTuple_SET_ITEM(result, 0, o2);
1278 : }
1279 : o3 = PyTuple_New(1);
1280 : PyTuple_SET_ITEM(o3, 0, obj);
1281 : o2 = result;
1282 : result = PySequence_Concat(o2, o3);
1283 : Py_DECREF(o2);
1284 : Py_DECREF(o3);
1285 : }
1286 : return result;
1287 : #endif
1288 : }
1289 :
1290 : /* Unpack the argument tuple */
1291 :
1292 : SWIGINTERN int
1293 : SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1294 : {
1295 : if (!args) {
1296 : if (!min && !max) {
1297 : return 1;
1298 : } else {
1299 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1300 : name, (min == max ? "" : "at least "), (int)min);
1301 : return 0;
1302 : }
1303 : }
1304 : if (!PyTuple_Check(args)) {
1305 : if (min <= 1 && max >= 1) {
1306 : register int i;
1307 : objs[0] = args;
1308 : for (i = 1; i < max; ++i) {
1309 : objs[i] = 0;
1310 : }
1311 : return 2;
1312 : }
1313 : PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1314 : return 0;
1315 : } else {
1316 : register Py_ssize_t l = PyTuple_GET_SIZE(args);
1317 : if (l < min) {
1318 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1319 : name, (min == max ? "" : "at least "), (int)min, (int)l);
1320 : return 0;
1321 : } else if (l > max) {
1322 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1323 : name, (min == max ? "" : "at most "), (int)max, (int)l);
1324 : return 0;
1325 : } else {
1326 : register int i;
1327 : for (i = 0; i < l; ++i) {
1328 : objs[i] = PyTuple_GET_ITEM(args, i);
1329 : }
1330 : for (; l < max; ++l) {
1331 : objs[l] = 0;
1332 : }
1333 : return i + 1;
1334 : }
1335 : }
1336 : }
1337 :
1338 : /* A functor is a function object with one single object argument */
1339 : #if PY_VERSION_HEX >= 0x02020000
1340 : #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1341 : #else
1342 : #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1343 : #endif
1344 :
1345 : /*
1346 : Helper for static pointer initialization for both C and C++ code, for example
1347 : static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1348 : */
1349 : #ifdef __cplusplus
1350 : #define SWIG_STATIC_POINTER(var) var
1351 : #else
1352 : #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1353 : #endif
1354 :
1355 : /* -----------------------------------------------------------------------------
1356 : * Pointer declarations
1357 : * ----------------------------------------------------------------------------- */
1358 :
1359 : /* Flags for new pointer objects */
1360 : #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1361 : #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1362 :
1363 : #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1364 :
1365 : #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1366 : #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1367 :
1368 : #ifdef __cplusplus
1369 : extern "C" {
1370 : #endif
1371 :
1372 : /* How to access Py_None */
1373 : #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1374 : # ifndef SWIG_PYTHON_NO_BUILD_NONE
1375 : # ifndef SWIG_PYTHON_BUILD_NONE
1376 : # define SWIG_PYTHON_BUILD_NONE
1377 : # endif
1378 : # endif
1379 : #endif
1380 :
1381 : #ifdef SWIG_PYTHON_BUILD_NONE
1382 : # ifdef Py_None
1383 : # undef Py_None
1384 : # define Py_None SWIG_Py_None()
1385 : # endif
1386 : SWIGRUNTIMEINLINE PyObject *
1387 : _SWIG_Py_None(void)
1388 : {
1389 : PyObject *none = Py_BuildValue((char*)"");
1390 : Py_DECREF(none);
1391 : return none;
1392 : }
1393 : SWIGRUNTIME PyObject *
1394 : SWIG_Py_None(void)
1395 : {
1396 : static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1397 : return none;
1398 : }
1399 : #endif
1400 :
1401 : /* The python void return value */
1402 :
1403 : SWIGRUNTIMEINLINE PyObject *
1404 : SWIG_Py_Void(void)
1405 : {
1406 881 : PyObject *none = Py_None;
1407 881 : Py_INCREF(none);
1408 : return none;
1409 : }
1410 :
1411 : /* SwigPyClientData */
1412 :
1413 : typedef struct {
1414 : PyObject *klass;
1415 : PyObject *newraw;
1416 : PyObject *newargs;
1417 : PyObject *destroy;
1418 : int delargs;
1419 : int implicitconv;
1420 : PyTypeObject *pytype;
1421 : } SwigPyClientData;
1422 :
1423 : SWIGRUNTIMEINLINE int
1424 : SWIG_Python_CheckImplicit(swig_type_info *ty)
1425 : {
1426 : SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1427 : return data ? data->implicitconv : 0;
1428 : }
1429 :
1430 : SWIGRUNTIMEINLINE PyObject *
1431 : SWIG_Python_ExceptionType(swig_type_info *desc) {
1432 : SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1433 : PyObject *klass = data ? data->klass : 0;
1434 : return (klass ? klass : PyExc_RuntimeError);
1435 : }
1436 :
1437 :
1438 : SWIGRUNTIME SwigPyClientData *
1439 : SwigPyClientData_New(PyObject* obj)
1440 : {
1441 : if (!obj) {
1442 : return 0;
1443 : } else {
1444 : SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1445 : /* the klass element */
1446 : data->klass = obj;
1447 : Py_INCREF(data->klass);
1448 : /* the newraw method and newargs arguments used to create a new raw instance */
1449 : if (PyClass_Check(obj)) {
1450 : data->newraw = 0;
1451 : data->newargs = obj;
1452 : Py_INCREF(obj);
1453 : } else {
1454 : #if (PY_VERSION_HEX < 0x02020000)
1455 : data->newraw = 0;
1456 : #else
1457 : data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1458 : #endif
1459 : if (data->newraw) {
1460 : Py_INCREF(data->newraw);
1461 : data->newargs = PyTuple_New(1);
1462 : PyTuple_SetItem(data->newargs, 0, obj);
1463 : } else {
1464 : data->newargs = obj;
1465 : }
1466 : Py_INCREF(data->newargs);
1467 : }
1468 : /* the destroy method, aka as the C++ delete method */
1469 : data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1470 : if (PyErr_Occurred()) {
1471 : PyErr_Clear();
1472 : data->destroy = 0;
1473 : }
1474 : if (data->destroy) {
1475 : int flags;
1476 : Py_INCREF(data->destroy);
1477 : flags = PyCFunction_GET_FLAGS(data->destroy);
1478 : #ifdef METH_O
1479 : data->delargs = !(flags & (METH_O));
1480 : #else
1481 : data->delargs = 0;
1482 : #endif
1483 : } else {
1484 : data->delargs = 0;
1485 : }
1486 : data->implicitconv = 0;
1487 : data->pytype = 0;
1488 : return data;
1489 : }
1490 : }
1491 :
1492 : SWIGRUNTIME void
1493 0 : SwigPyClientData_Del(SwigPyClientData *data) {
1494 0 : Py_XDECREF(data->newraw);
1495 0 : Py_XDECREF(data->newargs);
1496 0 : Py_XDECREF(data->destroy);
1497 0 : }
1498 :
1499 : /* =============== SwigPyObject =====================*/
1500 :
1501 : typedef struct {
1502 : PyObject_HEAD
1503 : void *ptr;
1504 : swig_type_info *ty;
1505 : int own;
1506 : PyObject *next;
1507 : #ifdef SWIGPYTHON_BUILTIN
1508 : PyObject *dict;
1509 : #endif
1510 : } SwigPyObject;
1511 :
1512 : SWIGRUNTIME PyObject *
1513 0 : SwigPyObject_long(SwigPyObject *v)
1514 : {
1515 0 : return PyLong_FromVoidPtr(v->ptr);
1516 : }
1517 :
1518 : SWIGRUNTIME PyObject *
1519 : SwigPyObject_format(const char* fmt, SwigPyObject *v)
1520 : {
1521 : PyObject *res = NULL;
1522 : PyObject *args = PyTuple_New(1);
1523 : if (args) {
1524 : if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1525 : PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1526 : if (ofmt) {
1527 : #if PY_VERSION_HEX >= 0x03000000
1528 : res = PyUnicode_Format(ofmt,args);
1529 : #else
1530 : res = PyString_Format(ofmt,args);
1531 : #endif
1532 : Py_DECREF(ofmt);
1533 : }
1534 : Py_DECREF(args);
1535 : }
1536 : }
1537 : return res;
1538 : }
1539 :
1540 : SWIGRUNTIME PyObject *
1541 : SwigPyObject_oct(SwigPyObject *v)
1542 : {
1543 : return SwigPyObject_format("%o",v);
1544 : }
1545 :
1546 : SWIGRUNTIME PyObject *
1547 : SwigPyObject_hex(SwigPyObject *v)
1548 : {
1549 : return SwigPyObject_format("%x",v);
1550 : }
1551 :
1552 : SWIGRUNTIME PyObject *
1553 : #ifdef METH_NOARGS
1554 0 : SwigPyObject_repr(SwigPyObject *v)
1555 : #else
1556 : SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1557 : #endif
1558 : {
1559 0 : const char *name = SWIG_TypePrettyName(v->ty);
1560 0 : PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1561 0 : if (v->next) {
1562 : # ifdef METH_NOARGS
1563 0 : PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1564 : # else
1565 : PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1566 : # endif
1567 : # if PY_VERSION_HEX >= 0x03000000
1568 0 : PyObject *joined = PyUnicode_Concat(repr, nrep);
1569 0 : Py_DecRef(repr);
1570 0 : Py_DecRef(nrep);
1571 0 : repr = joined;
1572 : # else
1573 : PyString_ConcatAndDel(&repr,nrep);
1574 : # endif
1575 : }
1576 0 : return repr;
1577 : }
1578 :
1579 : SWIGRUNTIME int
1580 0 : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1581 : {
1582 98 : void *i = v->ptr;
1583 98 : void *j = w->ptr;
1584 98 : return (i < j) ? -1 : ((i > j) ? 1 : 0);
1585 : }
1586 :
1587 : /* Added for Python 3.x, would it also be useful for Python 2.x? */
1588 : SWIGRUNTIME PyObject*
1589 98 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1590 : {
1591 : PyObject* res;
1592 98 : if( op != Py_EQ && op != Py_NE ) {
1593 0 : Py_INCREF(Py_NotImplemented);
1594 0 : return Py_NotImplemented;
1595 : }
1596 196 : res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1597 98 : return res;
1598 : }
1599 :
1600 :
1601 : SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1602 :
1603 : #ifdef SWIGPYTHON_BUILTIN
1604 : static swig_type_info *SwigPyObject_stype = 0;
1605 : SWIGRUNTIME PyTypeObject*
1606 : SwigPyObject_type(void) {
1607 : SwigPyClientData *cd;
1608 : assert(SwigPyObject_stype);
1609 7450 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1610 : assert(cd);
1611 : assert(cd->pytype);
1612 7026 : return cd->pytype;
1613 : }
1614 : #else
1615 : SWIGRUNTIME PyTypeObject*
1616 : SwigPyObject_type(void) {
1617 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1618 : return type;
1619 : }
1620 : #endif
1621 :
1622 : SWIGRUNTIMEINLINE int
1623 5889 : SwigPyObject_Check(PyObject *op) {
1624 : #ifdef SWIGPYTHON_BUILTIN
1625 5889 : PyTypeObject *target_tp = SwigPyObject_type();
1626 5889 : if (PyType_IsSubtype(op->ob_type, target_tp))
1627 : return 1;
1628 4 : return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1629 : #else
1630 : return (Py_TYPE(op) == SwigPyObject_type())
1631 : || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1632 : #endif
1633 : }
1634 :
1635 : SWIGRUNTIME PyObject *
1636 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1637 :
1638 : SWIGRUNTIME void
1639 412 : SwigPyObject_dealloc(PyObject *v)
1640 : {
1641 412 : SwigPyObject *sobj = (SwigPyObject *) v;
1642 412 : PyObject *next = sobj->next;
1643 412 : if (sobj->own == SWIG_POINTER_OWN) {
1644 0 : swig_type_info *ty = sobj->ty;
1645 0 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1646 0 : PyObject *destroy = data ? data->destroy : 0;
1647 0 : if (destroy) {
1648 : /* destroy is always a VARARGS method */
1649 : PyObject *res;
1650 0 : if (data->delargs) {
1651 : /* we need to create a temporary object to carry the destroy operation */
1652 0 : PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1653 0 : res = SWIG_Python_CallFunctor(destroy, tmp);
1654 0 : Py_DECREF(tmp);
1655 : } else {
1656 0 : PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1657 0 : PyObject *mself = PyCFunction_GET_SELF(destroy);
1658 0 : res = ((*meth)(mself, v));
1659 : }
1660 0 : Py_XDECREF(res);
1661 : }
1662 : #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1663 : else {
1664 0 : const char *name = SWIG_TypePrettyName(ty);
1665 0 : printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1666 : }
1667 : #endif
1668 : }
1669 412 : Py_XDECREF(next);
1670 412 : PyObject_DEL(v);
1671 412 : }
1672 :
1673 : SWIGRUNTIME PyObject*
1674 0 : SwigPyObject_append(PyObject* v, PyObject* next)
1675 : {
1676 0 : SwigPyObject *sobj = (SwigPyObject *) v;
1677 : #ifndef METH_O
1678 : PyObject *tmp = 0;
1679 : if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1680 : next = tmp;
1681 : #endif
1682 0 : if (!SwigPyObject_Check(next)) {
1683 : return NULL;
1684 : }
1685 0 : sobj->next = next;
1686 0 : Py_INCREF(next);
1687 0 : return SWIG_Py_Void();
1688 : }
1689 :
1690 : SWIGRUNTIME PyObject*
1691 : #ifdef METH_NOARGS
1692 0 : SwigPyObject_next(PyObject* v)
1693 : #else
1694 : SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1695 : #endif
1696 : {
1697 0 : SwigPyObject *sobj = (SwigPyObject *) v;
1698 0 : if (sobj->next) {
1699 0 : Py_INCREF(sobj->next);
1700 0 : return sobj->next;
1701 : } else {
1702 0 : return SWIG_Py_Void();
1703 : }
1704 : }
1705 :
1706 : SWIGINTERN PyObject*
1707 : #ifdef METH_NOARGS
1708 0 : SwigPyObject_disown(PyObject *v)
1709 : #else
1710 : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1711 : #endif
1712 : {
1713 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1714 0 : sobj->own = 0;
1715 0 : return SWIG_Py_Void();
1716 : }
1717 :
1718 : SWIGINTERN PyObject*
1719 : #ifdef METH_NOARGS
1720 0 : SwigPyObject_acquire(PyObject *v)
1721 : #else
1722 : SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1723 : #endif
1724 : {
1725 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1726 0 : sobj->own = SWIG_POINTER_OWN;
1727 0 : return SWIG_Py_Void();
1728 : }
1729 :
1730 : SWIGINTERN PyObject*
1731 0 : SwigPyObject_own(PyObject *v, PyObject *args)
1732 : {
1733 0 : PyObject *val = 0;
1734 : #if (PY_VERSION_HEX < 0x02020000)
1735 : if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1736 : #elif (PY_VERSION_HEX < 0x02050000)
1737 : if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1738 : #else
1739 0 : if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1740 : #endif
1741 : {
1742 : return NULL;
1743 : }
1744 : else
1745 : {
1746 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1747 0 : PyObject *obj = PyBool_FromLong(sobj->own);
1748 0 : if (val) {
1749 : #ifdef METH_NOARGS
1750 0 : if (PyObject_IsTrue(val)) {
1751 : SwigPyObject_acquire(v);
1752 : } else {
1753 : SwigPyObject_disown(v);
1754 : }
1755 : #else
1756 : if (PyObject_IsTrue(val)) {
1757 : SwigPyObject_acquire(v,args);
1758 : } else {
1759 : SwigPyObject_disown(v,args);
1760 : }
1761 : #endif
1762 : }
1763 0 : return obj;
1764 : }
1765 : }
1766 :
1767 : #ifdef METH_O
1768 : static PyMethodDef
1769 : swigobject_methods[] = {
1770 : {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1771 : {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1772 : {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1773 : {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1774 : {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1775 : {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1776 : {0, 0, 0, 0}
1777 : };
1778 : #else
1779 : static PyMethodDef
1780 : swigobject_methods[] = {
1781 : {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1782 : {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1783 : {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1784 : {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1785 : {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1786 : {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1787 : {0, 0, 0, 0}
1788 : };
1789 : #endif
1790 :
1791 : #if PY_VERSION_HEX < 0x02020000
1792 : SWIGINTERN PyObject *
1793 : SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1794 : {
1795 : return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1796 : }
1797 : #endif
1798 :
1799 : SWIGRUNTIME PyTypeObject*
1800 23 : SwigPyObject_TypeOnce(void) {
1801 : static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1802 :
1803 : static PyNumberMethods SwigPyObject_as_number = {
1804 : (binaryfunc)0, /*nb_add*/
1805 : (binaryfunc)0, /*nb_subtract*/
1806 : (binaryfunc)0, /*nb_multiply*/
1807 : /* nb_divide removed in Python 3 */
1808 : #if PY_VERSION_HEX < 0x03000000
1809 : (binaryfunc)0, /*nb_divide*/
1810 : #endif
1811 : (binaryfunc)0, /*nb_remainder*/
1812 : (binaryfunc)0, /*nb_divmod*/
1813 : (ternaryfunc)0,/*nb_power*/
1814 : (unaryfunc)0, /*nb_negative*/
1815 : (unaryfunc)0, /*nb_positive*/
1816 : (unaryfunc)0, /*nb_absolute*/
1817 : (inquiry)0, /*nb_nonzero*/
1818 : 0, /*nb_invert*/
1819 : 0, /*nb_lshift*/
1820 : 0, /*nb_rshift*/
1821 : 0, /*nb_and*/
1822 : 0, /*nb_xor*/
1823 : 0, /*nb_or*/
1824 : #if PY_VERSION_HEX < 0x03000000
1825 : 0, /*nb_coerce*/
1826 : #endif
1827 : (unaryfunc)SwigPyObject_long, /*nb_int*/
1828 : #if PY_VERSION_HEX < 0x03000000
1829 : (unaryfunc)SwigPyObject_long, /*nb_long*/
1830 : #else
1831 : 0, /*nb_reserved*/
1832 : #endif
1833 : (unaryfunc)0, /*nb_float*/
1834 : #if PY_VERSION_HEX < 0x03000000
1835 : (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1836 : (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1837 : #endif
1838 : #if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1839 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1840 : #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1841 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1842 : #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1843 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1844 : #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1845 : 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1846 : #endif
1847 : };
1848 :
1849 : static PyTypeObject swigpyobject_type;
1850 : static int type_init = 0;
1851 23 : if (!type_init) {
1852 : const PyTypeObject tmp = {
1853 : /* PyObject header changed in Python 3 */
1854 : #if PY_VERSION_HEX >= 0x03000000
1855 : PyVarObject_HEAD_INIT(NULL, 0)
1856 : #else
1857 : PyObject_HEAD_INIT(NULL)
1858 : 0, /* ob_size */
1859 : #endif
1860 : (char *)"SwigPyObject", /* tp_name */
1861 : sizeof(SwigPyObject), /* tp_basicsize */
1862 : 0, /* tp_itemsize */
1863 : (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1864 : 0, /* tp_print */
1865 : #if PY_VERSION_HEX < 0x02020000
1866 : (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1867 : #else
1868 : (getattrfunc)0, /* tp_getattr */
1869 : #endif
1870 : (setattrfunc)0, /* tp_setattr */
1871 : #if PY_VERSION_HEX >= 0x03000000
1872 : 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1873 : #else
1874 : (cmpfunc)SwigPyObject_compare, /* tp_compare */
1875 : #endif
1876 : (reprfunc)SwigPyObject_repr, /* tp_repr */
1877 : &SwigPyObject_as_number, /* tp_as_number */
1878 : 0, /* tp_as_sequence */
1879 : 0, /* tp_as_mapping */
1880 : (hashfunc)0, /* tp_hash */
1881 : (ternaryfunc)0, /* tp_call */
1882 : 0, /* tp_str */
1883 : PyObject_GenericGetAttr, /* tp_getattro */
1884 : 0, /* tp_setattro */
1885 : 0, /* tp_as_buffer */
1886 : Py_TPFLAGS_DEFAULT, /* tp_flags */
1887 : swigobject_doc, /* tp_doc */
1888 : 0, /* tp_traverse */
1889 : 0, /* tp_clear */
1890 : (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1891 : 0, /* tp_weaklistoffset */
1892 : #if PY_VERSION_HEX >= 0x02020000
1893 : 0, /* tp_iter */
1894 : 0, /* tp_iternext */
1895 : swigobject_methods, /* tp_methods */
1896 : 0, /* tp_members */
1897 : 0, /* tp_getset */
1898 : 0, /* tp_base */
1899 : 0, /* tp_dict */
1900 : 0, /* tp_descr_get */
1901 : 0, /* tp_descr_set */
1902 : 0, /* tp_dictoffset */
1903 : 0, /* tp_init */
1904 : 0, /* tp_alloc */
1905 : 0, /* tp_new */
1906 : 0, /* tp_free */
1907 : 0, /* tp_is_gc */
1908 : 0, /* tp_bases */
1909 : 0, /* tp_mro */
1910 : 0, /* tp_cache */
1911 : 0, /* tp_subclasses */
1912 : 0, /* tp_weaklist */
1913 : #endif
1914 : #if PY_VERSION_HEX >= 0x02030000
1915 : 0, /* tp_del */
1916 : #endif
1917 : #if PY_VERSION_HEX >= 0x02060000
1918 : 0, /* tp_version */
1919 : #endif
1920 : #ifdef COUNT_ALLOCS
1921 : 0,0,0,0 /* tp_alloc -> tp_next */
1922 : #endif
1923 : };
1924 23 : swigpyobject_type = tmp;
1925 23 : type_init = 1;
1926 : #if PY_VERSION_HEX < 0x02020000
1927 : swigpyobject_type.ob_type = &PyType_Type;
1928 : #else
1929 23 : if (PyType_Ready(&swigpyobject_type) < 0)
1930 : return NULL;
1931 : #endif
1932 : }
1933 : return &swigpyobject_type;
1934 : }
1935 :
1936 : SWIGRUNTIME PyObject *
1937 424 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1938 : {
1939 424 : SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1940 424 : if (sobj) {
1941 424 : sobj->ptr = ptr;
1942 424 : sobj->ty = ty;
1943 424 : sobj->own = own;
1944 424 : sobj->next = 0;
1945 : }
1946 424 : return (PyObject *)sobj;
1947 : }
1948 :
1949 : /* -----------------------------------------------------------------------------
1950 : * Implements a simple Swig Packed type, and use it instead of string
1951 : * ----------------------------------------------------------------------------- */
1952 :
1953 : typedef struct {
1954 : PyObject_HEAD
1955 : void *pack;
1956 : swig_type_info *ty;
1957 : size_t size;
1958 : } SwigPyPacked;
1959 :
1960 : SWIGRUNTIME int
1961 0 : SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1962 : {
1963 : char result[SWIG_BUFFER_SIZE];
1964 0 : fputs("<Swig Packed ", fp);
1965 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1966 0 : fputs("at ", fp);
1967 0 : fputs(result, fp);
1968 : }
1969 0 : fputs(v->ty->name,fp);
1970 0 : fputs(">", fp);
1971 0 : return 0;
1972 : }
1973 :
1974 : SWIGRUNTIME PyObject *
1975 0 : SwigPyPacked_repr(SwigPyPacked *v)
1976 : {
1977 : char result[SWIG_BUFFER_SIZE];
1978 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1979 0 : return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1980 : } else {
1981 0 : return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1982 : }
1983 : }
1984 :
1985 : SWIGRUNTIME PyObject *
1986 0 : SwigPyPacked_str(SwigPyPacked *v)
1987 : {
1988 : char result[SWIG_BUFFER_SIZE];
1989 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1990 0 : return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1991 : } else {
1992 0 : return SWIG_Python_str_FromChar(v->ty->name);
1993 : }
1994 : }
1995 :
1996 : SWIGRUNTIME int
1997 : SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
1998 : {
1999 : size_t i = v->size;
2000 : size_t j = w->size;
2001 : int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2002 : return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2003 : }
2004 :
2005 : SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2006 :
2007 : SWIGRUNTIME PyTypeObject*
2008 : SwigPyPacked_type(void) {
2009 0 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2010 0 : return type;
2011 : }
2012 :
2013 : SWIGRUNTIMEINLINE int
2014 0 : SwigPyPacked_Check(PyObject *op) {
2015 0 : return ((op)->ob_type == SwigPyPacked_TypeOnce())
2016 0 : || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2017 : }
2018 :
2019 : SWIGRUNTIME void
2020 0 : SwigPyPacked_dealloc(PyObject *v)
2021 : {
2022 0 : if (SwigPyPacked_Check(v)) {
2023 0 : SwigPyPacked *sobj = (SwigPyPacked *) v;
2024 0 : free(sobj->pack);
2025 : }
2026 0 : PyObject_DEL(v);
2027 0 : }
2028 :
2029 : SWIGRUNTIME PyTypeObject*
2030 0 : SwigPyPacked_TypeOnce(void) {
2031 : static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2032 : static PyTypeObject swigpypacked_type;
2033 : static int type_init = 0;
2034 0 : if (!type_init) {
2035 : const PyTypeObject tmp = {
2036 : /* PyObject header changed in Python 3 */
2037 : #if PY_VERSION_HEX>=0x03000000
2038 : PyVarObject_HEAD_INIT(NULL, 0)
2039 : #else
2040 : PyObject_HEAD_INIT(NULL)
2041 : 0, /* ob_size */
2042 : #endif
2043 : (char *)"SwigPyPacked", /* tp_name */
2044 : sizeof(SwigPyPacked), /* tp_basicsize */
2045 : 0, /* tp_itemsize */
2046 : (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2047 : (printfunc)SwigPyPacked_print, /* tp_print */
2048 : (getattrfunc)0, /* tp_getattr */
2049 : (setattrfunc)0, /* tp_setattr */
2050 : #if PY_VERSION_HEX>=0x03000000
2051 : 0, /* tp_reserved in 3.0.1 */
2052 : #else
2053 : (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2054 : #endif
2055 : (reprfunc)SwigPyPacked_repr, /* tp_repr */
2056 : 0, /* tp_as_number */
2057 : 0, /* tp_as_sequence */
2058 : 0, /* tp_as_mapping */
2059 : (hashfunc)0, /* tp_hash */
2060 : (ternaryfunc)0, /* tp_call */
2061 : (reprfunc)SwigPyPacked_str, /* tp_str */
2062 : PyObject_GenericGetAttr, /* tp_getattro */
2063 : 0, /* tp_setattro */
2064 : 0, /* tp_as_buffer */
2065 : Py_TPFLAGS_DEFAULT, /* tp_flags */
2066 : swigpacked_doc, /* tp_doc */
2067 : 0, /* tp_traverse */
2068 : 0, /* tp_clear */
2069 : 0, /* tp_richcompare */
2070 : 0, /* tp_weaklistoffset */
2071 : #if PY_VERSION_HEX >= 0x02020000
2072 : 0, /* tp_iter */
2073 : 0, /* tp_iternext */
2074 : 0, /* tp_methods */
2075 : 0, /* tp_members */
2076 : 0, /* tp_getset */
2077 : 0, /* tp_base */
2078 : 0, /* tp_dict */
2079 : 0, /* tp_descr_get */
2080 : 0, /* tp_descr_set */
2081 : 0, /* tp_dictoffset */
2082 : 0, /* tp_init */
2083 : 0, /* tp_alloc */
2084 : 0, /* tp_new */
2085 : 0, /* tp_free */
2086 : 0, /* tp_is_gc */
2087 : 0, /* tp_bases */
2088 : 0, /* tp_mro */
2089 : 0, /* tp_cache */
2090 : 0, /* tp_subclasses */
2091 : 0, /* tp_weaklist */
2092 : #endif
2093 : #if PY_VERSION_HEX >= 0x02030000
2094 : 0, /* tp_del */
2095 : #endif
2096 : #if PY_VERSION_HEX >= 0x02060000
2097 : 0, /* tp_version */
2098 : #endif
2099 : #ifdef COUNT_ALLOCS
2100 : 0,0,0,0 /* tp_alloc -> tp_next */
2101 : #endif
2102 : };
2103 0 : swigpypacked_type = tmp;
2104 0 : type_init = 1;
2105 : #if PY_VERSION_HEX < 0x02020000
2106 : swigpypacked_type.ob_type = &PyType_Type;
2107 : #else
2108 0 : if (PyType_Ready(&swigpypacked_type) < 0)
2109 : return NULL;
2110 : #endif
2111 : }
2112 : return &swigpypacked_type;
2113 : }
2114 :
2115 : SWIGRUNTIME PyObject *
2116 0 : SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2117 : {
2118 0 : SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2119 0 : if (sobj) {
2120 0 : void *pack = malloc(size);
2121 0 : if (pack) {
2122 : memcpy(pack, ptr, size);
2123 0 : sobj->pack = pack;
2124 0 : sobj->ty = ty;
2125 0 : sobj->size = size;
2126 : } else {
2127 0 : PyObject_DEL((PyObject *) sobj);
2128 0 : sobj = 0;
2129 : }
2130 : }
2131 0 : return (PyObject *) sobj;
2132 : }
2133 :
2134 : SWIGRUNTIME swig_type_info *
2135 : SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2136 : {
2137 : if (SwigPyPacked_Check(obj)) {
2138 : SwigPyPacked *sobj = (SwigPyPacked *)obj;
2139 : if (sobj->size != size) return 0;
2140 : memcpy(ptr, sobj->pack, size);
2141 : return sobj->ty;
2142 : } else {
2143 : return 0;
2144 : }
2145 : }
2146 :
2147 : /* -----------------------------------------------------------------------------
2148 : * pointers/data manipulation
2149 : * ----------------------------------------------------------------------------- */
2150 :
2151 : SWIGRUNTIMEINLINE PyObject *
2152 : _SWIG_This(void)
2153 : {
2154 : return SWIG_Python_str_FromChar("this");
2155 : }
2156 :
2157 : static PyObject *swig_this = NULL;
2158 :
2159 : SWIGRUNTIME PyObject *
2160 23 : SWIG_This(void)
2161 : {
2162 23 : if (swig_this == NULL)
2163 23 : swig_this = _SWIG_This();
2164 23 : return swig_this;
2165 : }
2166 :
2167 : /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2168 :
2169 : /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2170 : #if PY_VERSION_HEX>=0x03000000
2171 : #define SWIG_PYTHON_SLOW_GETSET_THIS
2172 : #endif
2173 :
2174 : SWIGRUNTIME SwigPyObject *
2175 5877 : SWIG_Python_GetSwigThis(PyObject *pyobj)
2176 : {
2177 : PyObject *obj;
2178 :
2179 5877 : if (SwigPyObject_Check(pyobj))
2180 : return (SwigPyObject *) pyobj;
2181 :
2182 : #ifdef SWIGPYTHON_BUILTIN
2183 : (void)obj;
2184 : # ifdef PyWeakref_CheckProxy
2185 0 : if (PyWeakref_CheckProxy(pyobj)) {
2186 0 : pyobj = PyWeakref_GET_OBJECT(pyobj);
2187 0 : if (pyobj && SwigPyObject_Check(pyobj))
2188 0 : return (SwigPyObject*) pyobj;
2189 : }
2190 : # endif
2191 : return NULL;
2192 : #else
2193 :
2194 : obj = 0;
2195 :
2196 : #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2197 : if (PyInstance_Check(pyobj)) {
2198 : obj = _PyInstance_Lookup(pyobj, SWIG_This());
2199 : } else {
2200 : PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2201 : if (dictptr != NULL) {
2202 : PyObject *dict = *dictptr;
2203 : obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2204 : } else {
2205 : #ifdef PyWeakref_CheckProxy
2206 : if (PyWeakref_CheckProxy(pyobj)) {
2207 : PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2208 : return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2209 : }
2210 : #endif
2211 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2212 : if (obj) {
2213 : Py_DECREF(obj);
2214 : } else {
2215 : if (PyErr_Occurred()) PyErr_Clear();
2216 : return 0;
2217 : }
2218 : }
2219 : }
2220 : #else
2221 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2222 : if (obj) {
2223 : Py_DECREF(obj);
2224 : } else {
2225 : if (PyErr_Occurred()) PyErr_Clear();
2226 : return 0;
2227 : }
2228 : #endif
2229 : if (obj && !SwigPyObject_Check(obj)) {
2230 : /* a PyObject is called 'this', try to get the 'real this'
2231 : SwigPyObject from it */
2232 : return SWIG_Python_GetSwigThis(obj);
2233 : }
2234 : return (SwigPyObject *)obj;
2235 : #endif
2236 : }
2237 :
2238 : /* Acquire a pointer value */
2239 :
2240 : SWIGRUNTIME int
2241 : SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2242 : if (own == SWIG_POINTER_OWN) {
2243 : SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2244 : if (sobj) {
2245 : int oldown = sobj->own;
2246 : sobj->own = own;
2247 : return oldown;
2248 : }
2249 : }
2250 : return 0;
2251 : }
2252 :
2253 : /* Convert a pointer value */
2254 :
2255 : SWIGRUNTIME int
2256 5923 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2257 : int res;
2258 : SwigPyObject *sobj;
2259 5923 : int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2260 :
2261 5923 : if (!obj)
2262 : return SWIG_ERROR;
2263 5923 : if (obj == Py_None && !implicit_conv) {
2264 46 : if (ptr)
2265 46 : *ptr = 0;
2266 : return SWIG_OK;
2267 : }
2268 :
2269 5877 : res = SWIG_ERROR;
2270 :
2271 5877 : sobj = SWIG_Python_GetSwigThis(obj);
2272 5877 : if (own)
2273 0 : *own = 0;
2274 5877 : while (sobj) {
2275 5877 : void *vptr = sobj->ptr;
2276 5877 : if (ty) {
2277 5877 : swig_type_info *to = sobj->ty;
2278 5877 : if (to == ty) {
2279 : /* no type cast needed */
2280 5877 : if (ptr) *ptr = vptr;
2281 : break;
2282 : } else {
2283 0 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2284 0 : if (!tc) {
2285 0 : sobj = (SwigPyObject *)sobj->next;
2286 : } else {
2287 0 : if (ptr) {
2288 0 : int newmemory = 0;
2289 0 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2290 0 : if (newmemory == SWIG_CAST_NEW_MEMORY) {
2291 : assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2292 0 : if (own)
2293 0 : *own = *own | SWIG_CAST_NEW_MEMORY;
2294 : }
2295 : }
2296 : break;
2297 : }
2298 : }
2299 : } else {
2300 0 : if (ptr) *ptr = vptr;
2301 : break;
2302 : }
2303 : }
2304 5877 : if (sobj) {
2305 5877 : if (own)
2306 0 : *own = *own | sobj->own;
2307 5877 : if (flags & SWIG_POINTER_DISOWN) {
2308 0 : sobj->own = 0;
2309 : }
2310 : res = SWIG_OK;
2311 : } else {
2312 0 : if (implicit_conv) {
2313 0 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2314 0 : if (data && !data->implicitconv) {
2315 0 : PyObject *klass = data->klass;
2316 0 : if (klass) {
2317 : PyObject *impconv;
2318 0 : data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2319 0 : impconv = SWIG_Python_CallFunctor(klass, obj);
2320 0 : data->implicitconv = 0;
2321 0 : if (PyErr_Occurred()) {
2322 0 : PyErr_Clear();
2323 0 : impconv = 0;
2324 : }
2325 0 : if (impconv) {
2326 0 : SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2327 0 : if (iobj) {
2328 : void *vptr;
2329 0 : res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2330 0 : if (SWIG_IsOK(res)) {
2331 0 : if (ptr) {
2332 0 : *ptr = vptr;
2333 : /* transfer the ownership to 'ptr' */
2334 0 : iobj->own = 0;
2335 0 : res = SWIG_AddCast(res);
2336 0 : res = SWIG_AddNewMask(res);
2337 : } else {
2338 : res = SWIG_AddCast(res);
2339 : }
2340 : }
2341 : }
2342 0 : Py_DECREF(impconv);
2343 : }
2344 : }
2345 : }
2346 : }
2347 0 : if (!SWIG_IsOK(res) && obj == Py_None) {
2348 0 : if (ptr)
2349 0 : *ptr = 0;
2350 0 : if (PyErr_Occurred())
2351 0 : PyErr_Clear();
2352 : res = SWIG_OK;
2353 : }
2354 : }
2355 5877 : return res;
2356 : }
2357 :
2358 : /* Convert a function ptr value */
2359 :
2360 : SWIGRUNTIME int
2361 0 : SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2362 0 : if (!PyCFunction_Check(obj)) {
2363 0 : return SWIG_ConvertPtr(obj, ptr, ty, 0);
2364 : } else {
2365 0 : void *vptr = 0;
2366 :
2367 : /* here we get the method pointer for callbacks */
2368 0 : const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2369 0 : const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2370 0 : if (desc)
2371 0 : desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2372 0 : if (!desc)
2373 : return SWIG_ERROR;
2374 0 : if (ty) {
2375 0 : swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2376 0 : if (tc) {
2377 0 : int newmemory = 0;
2378 0 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2379 : assert(!newmemory); /* newmemory handling not yet implemented */
2380 : } else {
2381 : return SWIG_ERROR;
2382 : }
2383 : } else {
2384 0 : *ptr = vptr;
2385 : }
2386 : return SWIG_OK;
2387 : }
2388 : }
2389 :
2390 : /* Convert a packed value value */
2391 :
2392 : SWIGRUNTIME int
2393 : SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2394 : swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2395 : if (!to) return SWIG_ERROR;
2396 : if (ty) {
2397 : if (to != ty) {
2398 : /* check type cast? */
2399 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2400 : if (!tc) return SWIG_ERROR;
2401 : }
2402 : }
2403 : return SWIG_OK;
2404 : }
2405 :
2406 : /* -----------------------------------------------------------------------------
2407 : * Create a new pointer object
2408 : * ----------------------------------------------------------------------------- */
2409 :
2410 : /*
2411 : Create a new instance object, without calling __init__, and set the
2412 : 'this' attribute.
2413 : */
2414 :
2415 : SWIGRUNTIME PyObject*
2416 0 : SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2417 : {
2418 : #if (PY_VERSION_HEX >= 0x02020000)
2419 0 : PyObject *inst = 0;
2420 0 : PyObject *newraw = data->newraw;
2421 0 : if (newraw) {
2422 0 : inst = PyObject_Call(newraw, data->newargs, NULL);
2423 0 : if (inst) {
2424 : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2425 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2426 : if (dictptr != NULL) {
2427 : PyObject *dict = *dictptr;
2428 : if (dict == NULL) {
2429 : dict = PyDict_New();
2430 : *dictptr = dict;
2431 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2432 : }
2433 : }
2434 : #else
2435 0 : PyObject *key = SWIG_This();
2436 0 : PyObject_SetAttr(inst, key, swig_this);
2437 : #endif
2438 : }
2439 : } else {
2440 : #if PY_VERSION_HEX >= 0x03000000
2441 0 : inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2442 0 : if (inst) {
2443 0 : PyObject_SetAttr(inst, SWIG_This(), swig_this);
2444 0 : Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2445 : }
2446 : #else
2447 : PyObject *dict = PyDict_New();
2448 : if (dict) {
2449 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2450 : inst = PyInstance_NewRaw(data->newargs, dict);
2451 : Py_DECREF(dict);
2452 : }
2453 : #endif
2454 : }
2455 0 : return inst;
2456 : #else
2457 : #if (PY_VERSION_HEX >= 0x02010000)
2458 : PyObject *inst = 0;
2459 : PyObject *dict = PyDict_New();
2460 : if (dict) {
2461 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2462 : inst = PyInstance_NewRaw(data->newargs, dict);
2463 : Py_DECREF(dict);
2464 : }
2465 : return (PyObject *) inst;
2466 : #else
2467 : PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2468 : if (inst == NULL) {
2469 : return NULL;
2470 : }
2471 : inst->in_class = (PyClassObject *)data->newargs;
2472 : Py_INCREF(inst->in_class);
2473 : inst->in_dict = PyDict_New();
2474 : if (inst->in_dict == NULL) {
2475 : Py_DECREF(inst);
2476 : return NULL;
2477 : }
2478 : #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2479 : inst->in_weakreflist = NULL;
2480 : #endif
2481 : #ifdef Py_TPFLAGS_GC
2482 : PyObject_GC_Init(inst);
2483 : #endif
2484 : PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2485 : return (PyObject *) inst;
2486 : #endif
2487 : #endif
2488 : }
2489 :
2490 : SWIGRUNTIME void
2491 : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2492 : {
2493 : PyObject *dict;
2494 : #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2495 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2496 : if (dictptr != NULL) {
2497 : dict = *dictptr;
2498 : if (dict == NULL) {
2499 : dict = PyDict_New();
2500 : *dictptr = dict;
2501 : }
2502 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2503 : return;
2504 : }
2505 : #endif
2506 : dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2507 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2508 : Py_DECREF(dict);
2509 : }
2510 :
2511 :
2512 : SWIGINTERN PyObject *
2513 : SWIG_Python_InitShadowInstance(PyObject *args) {
2514 : PyObject *obj[2];
2515 : if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2516 : return NULL;
2517 : } else {
2518 : SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2519 : if (sthis) {
2520 : SwigPyObject_append((PyObject*) sthis, obj[1]);
2521 : } else {
2522 : SWIG_Python_SetSwigThis(obj[0], obj[1]);
2523 : }
2524 : return SWIG_Py_Void();
2525 : }
2526 : }
2527 :
2528 : /* Create a new pointer object */
2529 :
2530 : SWIGRUNTIME PyObject *
2531 1481 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2532 : SwigPyClientData *clientdata;
2533 : PyObject * robj;
2534 : int own;
2535 :
2536 1481 : if (!ptr)
2537 16 : return SWIG_Py_Void();
2538 :
2539 1465 : clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2540 1465 : own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2541 1465 : if (clientdata && clientdata->pytype) {
2542 : SwigPyObject *newobj;
2543 1041 : if (flags & SWIG_BUILTIN_TP_INIT) {
2544 0 : newobj = (SwigPyObject*) self;
2545 0 : if (newobj->ptr) {
2546 0 : PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2547 0 : while (newobj->next)
2548 : newobj = (SwigPyObject *) newobj->next;
2549 0 : newobj->next = next_self;
2550 0 : newobj = (SwigPyObject *)next_self;
2551 : }
2552 : } else {
2553 1041 : newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2554 : }
2555 1041 : if (newobj) {
2556 1041 : newobj->ptr = ptr;
2557 1041 : newobj->ty = type;
2558 1041 : newobj->own = own;
2559 1041 : newobj->next = 0;
2560 : #ifdef SWIGPYTHON_BUILTIN
2561 1041 : newobj->dict = 0;
2562 : #endif
2563 1041 : return (PyObject*) newobj;
2564 : }
2565 0 : return SWIG_Py_Void();
2566 : }
2567 :
2568 : assert(!(flags & SWIG_BUILTIN_TP_INIT));
2569 :
2570 424 : robj = SwigPyObject_New(ptr, type, own);
2571 424 : if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2572 0 : PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2573 0 : Py_DECREF(robj);
2574 0 : robj = inst;
2575 : }
2576 424 : return robj;
2577 : }
2578 :
2579 : /* Create a new packed object */
2580 :
2581 : SWIGRUNTIMEINLINE PyObject *
2582 : SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2583 0 : return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2584 : }
2585 :
2586 : /* -----------------------------------------------------------------------------*
2587 : * Get type list
2588 : * -----------------------------------------------------------------------------*/
2589 :
2590 : #ifdef SWIG_LINK_RUNTIME
2591 : void *SWIG_ReturnGlobalTypeList(void *);
2592 : #endif
2593 :
2594 : SWIGRUNTIME swig_module_info *
2595 23 : SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2596 : static void *type_pointer = (void *)0;
2597 : /* first check if module already created */
2598 23 : if (!type_pointer) {
2599 : #ifdef SWIG_LINK_RUNTIME
2600 : type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2601 : #else
2602 : # ifdef SWIGPY_USE_CAPSULE
2603 23 : type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2604 : # else
2605 : type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2606 : (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2607 : # endif
2608 23 : if (PyErr_Occurred()) {
2609 23 : PyErr_Clear();
2610 23 : type_pointer = (void *)0;
2611 : }
2612 : #endif
2613 : }
2614 23 : return (swig_module_info *) type_pointer;
2615 : }
2616 :
2617 : #if PY_MAJOR_VERSION < 2
2618 : /* PyModule_AddObject function was introduced in Python 2.0. The following function
2619 : is copied out of Python/modsupport.c in python version 2.3.4 */
2620 : SWIGINTERN int
2621 : PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2622 : {
2623 : PyObject *dict;
2624 : if (!PyModule_Check(m)) {
2625 : PyErr_SetString(PyExc_TypeError,
2626 : "PyModule_AddObject() needs module as first arg");
2627 : return SWIG_ERROR;
2628 : }
2629 : if (!o) {
2630 : PyErr_SetString(PyExc_TypeError,
2631 : "PyModule_AddObject() needs non-NULL value");
2632 : return SWIG_ERROR;
2633 : }
2634 :
2635 : dict = PyModule_GetDict(m);
2636 : if (dict == NULL) {
2637 : /* Internal error -- modules must have a dict! */
2638 : PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2639 : PyModule_GetName(m));
2640 : return SWIG_ERROR;
2641 : }
2642 : if (PyDict_SetItemString(dict, name, o))
2643 : return SWIG_ERROR;
2644 : Py_DECREF(o);
2645 : return SWIG_OK;
2646 : }
2647 : #endif
2648 :
2649 : SWIGRUNTIME void
2650 : #ifdef SWIGPY_USE_CAPSULE
2651 23 : SWIG_Python_DestroyModule(PyObject *obj)
2652 : #else
2653 : SWIG_Python_DestroyModule(void *vptr)
2654 : #endif
2655 : {
2656 : #ifdef SWIGPY_USE_CAPSULE
2657 23 : swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2658 : #else
2659 : swig_module_info *swig_module = (swig_module_info *) vptr;
2660 : #endif
2661 23 : swig_type_info **types = swig_module->types;
2662 : size_t i;
2663 1978 : for (i =0; i < swig_module->size; ++i) {
2664 1955 : swig_type_info *ty = types[i];
2665 1955 : if (ty->owndata) {
2666 0 : SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2667 0 : if (data) SwigPyClientData_Del(data);
2668 : }
2669 : }
2670 23 : Py_DECREF(SWIG_This());
2671 23 : swig_this = NULL;
2672 23 : }
2673 :
2674 : SWIGRUNTIME void
2675 23 : SWIG_Python_SetModule(swig_module_info *swig_module) {
2676 : #if PY_VERSION_HEX >= 0x03000000
2677 : /* Add a dummy module object into sys.modules */
2678 23 : PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2679 : #else
2680 : static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2681 : PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2682 : #endif
2683 : #ifdef SWIGPY_USE_CAPSULE
2684 23 : PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2685 23 : if (pointer && module) {
2686 23 : PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2687 : } else {
2688 0 : Py_XDECREF(pointer);
2689 : }
2690 : #else
2691 : PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2692 : if (pointer && module) {
2693 : PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2694 : } else {
2695 : Py_XDECREF(pointer);
2696 : }
2697 : #endif
2698 23 : }
2699 :
2700 : /* The python cached type query */
2701 : SWIGRUNTIME PyObject *
2702 : SWIG_Python_TypeCache(void) {
2703 : static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2704 : return cache;
2705 : }
2706 :
2707 : SWIGRUNTIME swig_type_info *
2708 : SWIG_Python_TypeQuery(const char *type)
2709 : {
2710 : PyObject *cache = SWIG_Python_TypeCache();
2711 : PyObject *key = SWIG_Python_str_FromChar(type);
2712 : PyObject *obj = PyDict_GetItem(cache, key);
2713 : swig_type_info *descriptor;
2714 : if (obj) {
2715 : #ifdef SWIGPY_USE_CAPSULE
2716 : descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2717 : #else
2718 : descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2719 : #endif
2720 : } else {
2721 : swig_module_info *swig_module = SWIG_GetModule(0);
2722 : descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2723 : if (descriptor) {
2724 : #ifdef SWIGPY_USE_CAPSULE
2725 : obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2726 : #else
2727 : obj = PyCObject_FromVoidPtr(descriptor, NULL);
2728 : #endif
2729 : PyDict_SetItem(cache, key, obj);
2730 : Py_DECREF(obj);
2731 : }
2732 : }
2733 : Py_DECREF(key);
2734 : return descriptor;
2735 : }
2736 :
2737 : /*
2738 : For backward compatibility only
2739 : */
2740 : #define SWIG_POINTER_EXCEPTION 0
2741 : #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2742 : #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2743 :
2744 : SWIGRUNTIME int
2745 : SWIG_Python_AddErrMesg(const char* mesg, int infront)
2746 : {
2747 : if (PyErr_Occurred()) {
2748 : PyObject *type = 0;
2749 : PyObject *value = 0;
2750 : PyObject *traceback = 0;
2751 : PyErr_Fetch(&type, &value, &traceback);
2752 : if (value) {
2753 : char *tmp;
2754 : PyObject *old_str = PyObject_Str(value);
2755 : Py_XINCREF(type);
2756 : PyErr_Clear();
2757 : if (infront) {
2758 : PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2759 : } else {
2760 : PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2761 : }
2762 : SWIG_Python_str_DelForPy3(tmp);
2763 : Py_DECREF(old_str);
2764 : }
2765 : return 1;
2766 : } else {
2767 : return 0;
2768 : }
2769 : }
2770 :
2771 : SWIGRUNTIME int
2772 : SWIG_Python_ArgFail(int argnum)
2773 : {
2774 : if (PyErr_Occurred()) {
2775 : /* add information about failing argument */
2776 : char mesg[256];
2777 : PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2778 : return SWIG_Python_AddErrMesg(mesg, 1);
2779 : } else {
2780 : return 0;
2781 : }
2782 : }
2783 :
2784 : SWIGRUNTIMEINLINE const char *
2785 : SwigPyObject_GetDesc(PyObject *self)
2786 : {
2787 : SwigPyObject *v = (SwigPyObject *)self;
2788 : swig_type_info *ty = v ? v->ty : 0;
2789 : return ty ? ty->str : "";
2790 : }
2791 :
2792 : SWIGRUNTIME void
2793 : SWIG_Python_TypeError(const char *type, PyObject *obj)
2794 : {
2795 : if (type) {
2796 : #if defined(SWIG_COBJECT_TYPES)
2797 : if (obj && SwigPyObject_Check(obj)) {
2798 : const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2799 : if (otype) {
2800 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2801 : type, otype);
2802 : return;
2803 : }
2804 : } else
2805 : #endif
2806 : {
2807 : const char *otype = (obj ? obj->ob_type->tp_name : 0);
2808 : if (otype) {
2809 : PyObject *str = PyObject_Str(obj);
2810 : const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2811 : if (cstr) {
2812 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2813 : type, otype, cstr);
2814 : SWIG_Python_str_DelForPy3(cstr);
2815 : } else {
2816 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2817 : type, otype);
2818 : }
2819 : Py_XDECREF(str);
2820 : return;
2821 : }
2822 : }
2823 : PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2824 : } else {
2825 : PyErr_Format(PyExc_TypeError, "unexpected type is received");
2826 : }
2827 : }
2828 :
2829 :
2830 : /* Convert a pointer value, signal an exception on a type mismatch */
2831 : SWIGRUNTIME void *
2832 : SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2833 : void *result;
2834 : if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2835 : PyErr_Clear();
2836 : #if SWIG_POINTER_EXCEPTION
2837 : if (flags) {
2838 : SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2839 : SWIG_Python_ArgFail(argnum);
2840 : }
2841 : #endif
2842 : }
2843 : return result;
2844 : }
2845 :
2846 : #ifdef SWIGPYTHON_BUILTIN
2847 : SWIGRUNTIME int
2848 : SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2849 : PyTypeObject *tp = obj->ob_type;
2850 : PyObject *descr;
2851 : PyObject *encoded_name;
2852 : descrsetfunc f;
2853 : int res = -1;
2854 :
2855 : # ifdef Py_USING_UNICODE
2856 : if (PyString_Check(name)) {
2857 : name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2858 : if (!name)
2859 : return -1;
2860 : } else if (!PyUnicode_Check(name))
2861 : # else
2862 : if (!PyString_Check(name))
2863 : # endif
2864 : {
2865 : PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2866 : return -1;
2867 : } else {
2868 : Py_INCREF(name);
2869 : }
2870 :
2871 : if (!tp->tp_dict) {
2872 : if (PyType_Ready(tp) < 0)
2873 : goto done;
2874 : }
2875 :
2876 : descr = _PyType_Lookup(tp, name);
2877 : f = NULL;
2878 : if (descr != NULL)
2879 : f = descr->ob_type->tp_descr_set;
2880 : if (!f) {
2881 : if (PyString_Check(name)) {
2882 : encoded_name = name;
2883 : Py_INCREF(name);
2884 : } else {
2885 : encoded_name = PyUnicode_AsUTF8String(name);
2886 : }
2887 : PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2888 : Py_DECREF(encoded_name);
2889 : } else {
2890 : res = f(descr, obj, value);
2891 : }
2892 :
2893 : done:
2894 : Py_DECREF(name);
2895 : return res;
2896 : }
2897 : #endif
2898 :
2899 :
2900 : #ifdef __cplusplus
2901 : }
2902 : #endif
2903 :
2904 : #define SWIGPY_UNARYFUNC_CLOSURE(wrapper) \
2905 : SWIGINTERN PyObject * \
2906 : wrapper##_closure(PyObject *a) { \
2907 : return wrapper(a, NULL); \
2908 : }
2909 :
2910 : #define SWIGPY_DESTRUCTOR_CLOSURE(wrapper) \
2911 : SWIGINTERN void \
2912 : wrapper##_closure(PyObject *a) { \
2913 : SwigPyObject *sobj; \
2914 : sobj = (SwigPyObject *)a; \
2915 : if (sobj->own) { \
2916 : PyObject *o = wrapper(a, NULL); \
2917 : Py_XDECREF(o); \
2918 : } \
2919 : if (PyType_IS_GC(a->ob_type)) { \
2920 : PyObject_GC_Del(a); \
2921 : } else { \
2922 : PyObject_Del(a); \
2923 : } \
2924 : }
2925 :
2926 : #define SWIGPY_INQUIRY_CLOSURE(wrapper) \
2927 : SWIGINTERN int \
2928 : wrapper##_closure(PyObject *a) { \
2929 : PyObject *pyresult; \
2930 : int result; \
2931 : pyresult = wrapper(a, NULL); \
2932 : result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0; \
2933 : Py_XDECREF(pyresult); \
2934 : return result; \
2935 : }
2936 :
2937 : #define SWIGPY_BINARYFUNC_CLOSURE(wrapper) \
2938 : SWIGINTERN PyObject * \
2939 : wrapper##_closure(PyObject *a, PyObject *b) { \
2940 : PyObject *tuple, *result; \
2941 : tuple = PyTuple_New(1); \
2942 : assert(tuple); \
2943 : PyTuple_SET_ITEM(tuple, 0, b); \
2944 : Py_XINCREF(b); \
2945 : result = wrapper(a, tuple); \
2946 : Py_DECREF(tuple); \
2947 : return result; \
2948 : }
2949 :
2950 : typedef ternaryfunc ternarycallfunc;
2951 :
2952 : #define SWIGPY_TERNARYFUNC_CLOSURE(wrapper) \
2953 : SWIGINTERN PyObject * \
2954 : wrapper##_closure(PyObject *a, PyObject *b, PyObject *c) { \
2955 : PyObject *tuple, *result; \
2956 : tuple = PyTuple_New(2); \
2957 : assert(tuple); \
2958 : PyTuple_SET_ITEM(tuple, 0, b); \
2959 : PyTuple_SET_ITEM(tuple, 1, c); \
2960 : Py_XINCREF(b); \
2961 : Py_XINCREF(c); \
2962 : result = wrapper(a, tuple); \
2963 : Py_DECREF(tuple); \
2964 : return result; \
2965 : }
2966 :
2967 : #define SWIGPY_TERNARYCALLFUNC_CLOSURE(wrapper) \
2968 : SWIGINTERN PyObject * \
2969 : wrapper##_closure(PyObject *callable_object, PyObject *args, PyObject *) { \
2970 : return wrapper(callable_object, args); \
2971 : }
2972 :
2973 : #define SWIGPY_LENFUNC_CLOSURE(wrapper) \
2974 : SWIGINTERN Py_ssize_t \
2975 : wrapper##_closure(PyObject *a) { \
2976 : PyObject *resultobj; \
2977 : Py_ssize_t result; \
2978 : resultobj = wrapper(a, NULL); \
2979 : result = PyNumber_AsSsize_t(resultobj, NULL); \
2980 : Py_DECREF(resultobj); \
2981 : return result; \
2982 : }
2983 :
2984 : #define SWIGPY_SSIZESSIZEARGFUNC_CLOSURE(wrapper) \
2985 : SWIGINTERN PyObject * \
2986 : wrapper##_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c) { \
2987 : PyObject *tuple, *result; \
2988 : tuple = PyTuple_New(2); \
2989 : assert(tuple); \
2990 : PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b)); \
2991 : PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c)); \
2992 : result = wrapper(a, tuple); \
2993 : Py_DECREF(tuple); \
2994 : return result; \
2995 : }
2996 :
2997 : #define SWIGPY_SSIZESSIZEOBJARGPROC_CLOSURE(wrapper) \
2998 : SWIGINTERN int \
2999 : wrapper##_closure(PyObject *a, Py_ssize_t b, Py_ssize_t c, PyObject *d) { \
3000 : PyObject *tuple, *resultobj; \
3001 : int result; \
3002 : tuple = PyTuple_New(d ? 3 : 2); \
3003 : assert(tuple); \
3004 : PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b)); \
3005 : PyTuple_SET_ITEM(tuple, 1, _PyLong_FromSsize_t(c)); \
3006 : if (d) { \
3007 : PyTuple_SET_ITEM(tuple, 2, d); \
3008 : Py_INCREF(d); \
3009 : } \
3010 : resultobj = wrapper(a, tuple); \
3011 : result = resultobj ? 0 : -1; \
3012 : Py_DECREF(tuple); \
3013 : Py_XDECREF(resultobj); \
3014 : return result; \
3015 : }
3016 :
3017 : #define SWIGPY_SSIZEARGFUNC_CLOSURE(wrapper) \
3018 : SWIGINTERN PyObject * \
3019 : wrapper##_closure(PyObject *a, Py_ssize_t b) { \
3020 : PyObject *tuple, *result; \
3021 : tuple = PyTuple_New(1); \
3022 : assert(tuple); \
3023 : PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b)); \
3024 : result = wrapper(a, tuple); \
3025 : Py_DECREF(tuple); \
3026 : return result; \
3027 : }
3028 :
3029 : #define SWIGPY_FUNPACK_SSIZEARGFUNC_CLOSURE(wrapper) \
3030 : SWIGINTERN PyObject * \
3031 : wrapper##_closure(PyObject *a, Py_ssize_t b) { \
3032 : PyObject *arg, *result; \
3033 : arg = _PyLong_FromSsize_t(b); \
3034 : result = wrapper(a, arg); \
3035 : Py_DECREF(arg); \
3036 : return result; \
3037 : }
3038 :
3039 : #define SWIGPY_SSIZEOBJARGPROC_CLOSURE(wrapper) \
3040 : SWIGINTERN int \
3041 : wrapper##_closure(PyObject *a, Py_ssize_t b, PyObject *c) { \
3042 : PyObject *tuple, *resultobj; \
3043 : int result; \
3044 : tuple = PyTuple_New(2); \
3045 : assert(tuple); \
3046 : PyTuple_SET_ITEM(tuple, 0, _PyLong_FromSsize_t(b)); \
3047 : PyTuple_SET_ITEM(tuple, 1, c); \
3048 : Py_XINCREF(c); \
3049 : resultobj = wrapper(a, tuple); \
3050 : result = resultobj ? 0 : -1; \
3051 : Py_XDECREF(resultobj); \
3052 : Py_DECREF(tuple); \
3053 : return result; \
3054 : }
3055 :
3056 : #define SWIGPY_OBJOBJARGPROC_CLOSURE(wrapper) \
3057 : SWIGINTERN int \
3058 : wrapper##_closure(PyObject *a, PyObject *b, PyObject *c) { \
3059 : PyObject *tuple, *resultobj; \
3060 : int result; \
3061 : tuple = PyTuple_New(c ? 2 : 1); \
3062 : assert(tuple); \
3063 : PyTuple_SET_ITEM(tuple, 0, b); \
3064 : Py_XINCREF(b); \
3065 : if (c) { \
3066 : PyTuple_SET_ITEM(tuple, 1, c); \
3067 : Py_XINCREF(c); \
3068 : } \
3069 : resultobj = wrapper(a, tuple); \
3070 : result = resultobj ? 0 : -1; \
3071 : Py_XDECREF(resultobj); \
3072 : Py_DECREF(tuple); \
3073 : return result; \
3074 : }
3075 :
3076 : #define SWIGPY_REPRFUNC_CLOSURE(wrapper) \
3077 : SWIGINTERN PyObject * \
3078 : wrapper##_closure(PyObject *a) { \
3079 : return wrapper(a, NULL); \
3080 : }
3081 :
3082 : #define SWIGPY_HASHFUNC_CLOSURE(wrapper) \
3083 : SWIGINTERN long \
3084 : wrapper##_closure(PyObject *a) { \
3085 : PyObject *pyresult; \
3086 : long result; \
3087 : pyresult = wrapper(a, NULL); \
3088 : if (!pyresult || !PyLong_Check(pyresult)) \
3089 : return -1; \
3090 : result = PyLong_AsLong(pyresult); \
3091 : Py_DECREF(pyresult); \
3092 : return result; \
3093 : }
3094 :
3095 : #define SWIGPY_ITERNEXT_CLOSURE(wrapper) \
3096 : SWIGINTERN PyObject * \
3097 : wrapper##_closure(PyObject *a) { \
3098 : PyObject *result; \
3099 : result = wrapper(a, NULL); \
3100 : if (result && result == Py_None) { \
3101 : Py_DECREF(result); \
3102 : result = NULL; \
3103 : } \
3104 : return result; \
3105 : }
3106 :
3107 : #ifdef __cplusplus
3108 : extern "C" {
3109 : #endif
3110 :
3111 : SWIGINTERN int
3112 : SwigPyBuiltin_BadInit(PyObject *self, PyObject *SWIGUNUSEDPARM(args), PyObject *SWIGUNUSEDPARM(kwds)) {
3113 : PyErr_Format(PyExc_TypeError, "Cannot create new instances of type '%.300s'", self->ob_type->tp_name);
3114 : return -1;
3115 : }
3116 :
3117 : SWIGINTERN void
3118 : SwigPyBuiltin_BadDealloc(PyObject *pyobj) {
3119 : SwigPyObject *sobj;
3120 : sobj = (SwigPyObject *)pyobj;
3121 : if (sobj->own) {
3122 : PyErr_Format(PyExc_TypeError, "Swig detected a memory leak in type '%.300s': no callable destructor found.", pyobj->ob_type->tp_name);
3123 : }
3124 : }
3125 :
3126 : typedef struct {
3127 : PyCFunction get;
3128 : PyCFunction set;
3129 : } SwigPyGetSet;
3130 :
3131 : SWIGINTERN PyObject *
3132 4019 : SwigPyBuiltin_GetterClosure (PyObject *obj, void *closure) {
3133 : SwigPyGetSet *getset;
3134 : PyObject *tuple, *result;
3135 4019 : if (!closure)
3136 0 : return SWIG_Py_Void();
3137 4019 : getset = (SwigPyGetSet *)closure;
3138 4019 : if (!getset->get)
3139 0 : return SWIG_Py_Void();
3140 4019 : tuple = PyTuple_New(0);
3141 : assert(tuple);
3142 4019 : result = (*getset->get)(obj, tuple);
3143 4019 : Py_DECREF(tuple);
3144 4019 : return result;
3145 : }
3146 :
3147 : SWIGINTERN PyObject *
3148 : SwigPyBuiltin_FunpackGetterClosure (PyObject *obj, void *closure) {
3149 : SwigPyGetSet *getset;
3150 : PyObject *result;
3151 : if (!closure)
3152 : return SWIG_Py_Void();
3153 : getset = (SwigPyGetSet *)closure;
3154 : if (!getset->get)
3155 : return SWIG_Py_Void();
3156 : result = (*getset->get)(obj, NULL);
3157 : return result;
3158 : }
3159 :
3160 : SWIGINTERN int
3161 0 : SwigPyBuiltin_SetterClosure (PyObject *obj, PyObject *val, void *closure) {
3162 : SwigPyGetSet *getset;
3163 : PyObject *tuple, *result;
3164 0 : if (!closure) {
3165 0 : PyErr_Format(PyExc_TypeError, "Missing getset closure");
3166 0 : return -1;
3167 : }
3168 0 : getset = (SwigPyGetSet *)closure;
3169 0 : if (!getset->set) {
3170 0 : PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
3171 0 : return -1;
3172 : }
3173 0 : tuple = PyTuple_New(1);
3174 : assert(tuple);
3175 0 : PyTuple_SET_ITEM(tuple, 0, val);
3176 0 : Py_XINCREF(val);
3177 0 : result = (*getset->set)(obj, tuple);
3178 0 : Py_DECREF(tuple);
3179 0 : Py_XDECREF(result);
3180 0 : return result ? 0 : -1;
3181 : }
3182 :
3183 : SWIGINTERN int
3184 : SwigPyBuiltin_FunpackSetterClosure (PyObject *obj, PyObject *val, void *closure) {
3185 : SwigPyGetSet *getset;
3186 : PyObject *result;
3187 : if (!closure) {
3188 : PyErr_Format(PyExc_TypeError, "Missing getset closure");
3189 : return -1;
3190 : }
3191 : getset = (SwigPyGetSet *)closure;
3192 : if (!getset->set) {
3193 : PyErr_Format(PyExc_TypeError, "Illegal member variable assignment in type '%.300s'", obj->ob_type->tp_name);
3194 : return -1;
3195 : }
3196 : result = (*getset->set)(obj, val);
3197 : Py_XDECREF(result);
3198 : return result ? 0 : -1;
3199 : }
3200 :
3201 : SWIGINTERN void
3202 : SwigPyStaticVar_dealloc(PyDescrObject *descr) {
3203 : _PyObject_GC_UNTRACK(descr);
3204 : Py_XDECREF(PyDescr_TYPE(descr));
3205 : Py_XDECREF(PyDescr_NAME(descr));
3206 : PyObject_GC_Del(descr);
3207 : }
3208 :
3209 : SWIGINTERN PyObject *
3210 : SwigPyStaticVar_repr(PyGetSetDescrObject *descr) {
3211 : #if PY_VERSION_HEX >= 0x03000000
3212 :
3213 : return PyUnicode_FromFormat("<class attribute '%S' of type '%s'>", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
3214 : #else
3215 : return PyString_FromFormat("<class attribute '%s' of type '%s'>", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
3216 : #endif
3217 : }
3218 :
3219 : SWIGINTERN int
3220 : SwigPyStaticVar_traverse(PyObject *self, visitproc visit, void *arg) {
3221 : PyDescrObject *descr;
3222 : descr = (PyDescrObject *)self;
3223 : Py_VISIT((PyObject*) PyDescr_TYPE(descr));
3224 : return 0;
3225 : }
3226 :
3227 : SWIGINTERN PyObject *
3228 : SwigPyStaticVar_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *SWIGUNUSEDPARM(type)) {
3229 : if (descr->d_getset->get != NULL)
3230 : return descr->d_getset->get(obj, descr->d_getset->closure);
3231 : #if PY_VERSION_HEX >= 0x03000000
3232 : PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not readable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
3233 : #else
3234 : PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not readable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
3235 : #endif
3236 : return NULL;
3237 : }
3238 :
3239 : SWIGINTERN int
3240 : SwigPyStaticVar_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
3241 : if (descr->d_getset->set != NULL)
3242 : return descr->d_getset->set(obj, value, descr->d_getset->closure);
3243 : #if PY_VERSION_HEX >= 0x03000000
3244 : PyErr_Format(PyExc_AttributeError, "attribute '%.300S' of '%.100s' objects is not writable", PyDescr_NAME(descr), PyDescr_TYPE(descr)->tp_name);
3245 : #else
3246 : PyErr_Format(PyExc_AttributeError, "attribute '%.300s' of '%.100s' objects is not writable", PyString_AsString(PyDescr_NAME(descr)), PyDescr_TYPE(descr)->tp_name);
3247 : #endif
3248 : return -1;
3249 : }
3250 :
3251 : SWIGINTERN int
3252 0 : SwigPyObjectType_setattro(PyTypeObject *type, PyObject *name, PyObject *value) {
3253 : PyObject *attribute;
3254 : descrsetfunc local_set;
3255 0 : attribute = _PyType_Lookup(type, name);
3256 0 : if (attribute != NULL) {
3257 : /* Implement descriptor functionality, if any */
3258 0 : local_set = attribute->ob_type->tp_descr_set;
3259 0 : if (local_set != NULL)
3260 0 : return local_set(attribute, (PyObject *)type, value);
3261 : #if PY_VERSION_HEX >= 0x03000000
3262 0 : PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400S'", type->tp_name, name);
3263 : #else
3264 : PyErr_Format(PyExc_AttributeError, "cannot modify read-only attribute '%.50s.%.400s'", type->tp_name, PyString_AS_STRING(name));
3265 : #endif
3266 : } else {
3267 : #if PY_VERSION_HEX >= 0x03000000
3268 0 : PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400S'", type->tp_name, name);
3269 : #else
3270 : PyErr_Format(PyExc_AttributeError, "type '%.50s' has no attribute '%.400s'", type->tp_name, PyString_AS_STRING(name));
3271 : #endif
3272 : }
3273 :
3274 : return -1;
3275 : }
3276 :
3277 : SWIGINTERN PyTypeObject*
3278 : SwigPyStaticVar_Type(void) {
3279 : static PyTypeObject staticvar_type;
3280 : static int type_init = 0;
3281 : if (!type_init) {
3282 : const PyTypeObject tmp = {
3283 : /* PyObject header changed in Python 3 */
3284 : #if PY_VERSION_HEX >= 0x03000000
3285 : PyVarObject_HEAD_INIT(&PyType_Type, 0)
3286 : #else
3287 : PyObject_HEAD_INIT(&PyType_Type)
3288 : 0,
3289 : #endif
3290 : "swig_static_var_getset_descriptor",
3291 : sizeof(PyGetSetDescrObject),
3292 : 0,
3293 : (destructor)SwigPyStaticVar_dealloc, /* tp_dealloc */
3294 : 0, /* tp_print */
3295 : 0, /* tp_getattr */
3296 : 0, /* tp_setattr */
3297 : 0, /* tp_compare */
3298 : (reprfunc)SwigPyStaticVar_repr, /* tp_repr */
3299 : 0, /* tp_as_number */
3300 : 0, /* tp_as_sequence */
3301 : 0, /* tp_as_mapping */
3302 : 0, /* tp_hash */
3303 : 0, /* tp_call */
3304 : 0, /* tp_str */
3305 : PyObject_GenericGetAttr, /* tp_getattro */
3306 : 0, /* tp_setattro */
3307 : 0, /* tp_as_buffer */
3308 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_CLASS, /* tp_flags */
3309 : 0, /* tp_doc */
3310 : SwigPyStaticVar_traverse, /* tp_traverse */
3311 : 0, /* tp_clear */
3312 : 0, /* tp_richcompare */
3313 : 0, /* tp_weaklistoffset */
3314 : 0, /* tp_iter */
3315 : 0, /* tp_iternext */
3316 : 0, /* tp_methods */
3317 : 0, /* tp_members */
3318 : 0, /* tp_getset */
3319 : 0, /* tp_base */
3320 : 0, /* tp_dict */
3321 : (descrgetfunc)SwigPyStaticVar_get, /* tp_descr_get */
3322 : (descrsetfunc)SwigPyStaticVar_set, /* tp_descr_set */
3323 : 0, /* tp_dictoffset */
3324 : 0, /* tp_init */
3325 : 0, /* tp_alloc */
3326 : 0, /* tp_new */
3327 : 0, /* tp_free */
3328 : 0, /* tp_is_gc */
3329 : 0, /* tp_bases */
3330 : 0, /* tp_mro */
3331 : 0, /* tp_cache */
3332 : 0, /* tp_subclasses */
3333 : 0, /* tp_weaklist */
3334 : #if PY_VERSION_HEX >= 0x02030000
3335 : 0, /* tp_del */
3336 : #endif
3337 : #if PY_VERSION_HEX >= 0x02060000
3338 : 0, /* tp_version */
3339 : #endif
3340 : #ifdef COUNT_ALLOCS
3341 : 0,0,0,0 /* tp_alloc -> tp_next */
3342 : #endif
3343 : };
3344 : staticvar_type = tmp;
3345 : type_init = 1;
3346 : #if PY_VERSION_HEX < 0x02020000
3347 : staticvar_type.ob_type = &PyType_Type;
3348 : #else
3349 : if (PyType_Ready(&staticvar_type) < 0)
3350 : return NULL;
3351 : #endif
3352 : }
3353 : return &staticvar_type;
3354 : }
3355 :
3356 : SWIGINTERN PyGetSetDescrObject *
3357 : SwigPyStaticVar_new_getset(PyTypeObject *type, PyGetSetDef *getset) {
3358 :
3359 : PyGetSetDescrObject *descr;
3360 : descr = (PyGetSetDescrObject *)PyType_GenericAlloc(SwigPyStaticVar_Type(), 0);
3361 : assert(descr);
3362 : Py_XINCREF(type);
3363 : PyDescr_TYPE(descr) = type;
3364 : PyDescr_NAME(descr) = PyString_InternFromString(getset->name);
3365 : descr->d_getset = getset;
3366 : if (PyDescr_NAME(descr) == NULL) {
3367 : Py_DECREF(descr);
3368 : descr = NULL;
3369 : }
3370 : return descr;
3371 : }
3372 :
3373 : SWIGINTERN void
3374 667 : SwigPyBuiltin_InitBases (PyTypeObject *type, PyTypeObject **bases) {
3375 667 : int base_count = 0;
3376 : PyTypeObject **b;
3377 : PyObject *tuple;
3378 : int i;
3379 :
3380 667 : if (!bases[0]) {
3381 667 : bases[0] = SwigPyObject_type();
3382 667 : bases[1] = NULL;
3383 : }
3384 667 : type->tp_base = bases[0];
3385 667 : Py_INCREF((PyObject *)bases[0]);
3386 1334 : for (b = bases; *b != NULL; ++b)
3387 667 : ++base_count;
3388 667 : tuple = PyTuple_New(base_count);
3389 1334 : for (i = 0; i < base_count; ++i) {
3390 667 : PyTuple_SET_ITEM(tuple, i, (PyObject *)bases[i]);
3391 667 : Py_INCREF((PyObject *)bases[i]);
3392 : }
3393 667 : type->tp_bases = tuple;
3394 667 : }
3395 :
3396 : SWIGINTERN PyObject *
3397 0 : SwigPyBuiltin_ThisClosure (PyObject *self, void *SWIGUNUSEDPARM(closure)) {
3398 : PyObject *result;
3399 0 : result = (PyObject *)SWIG_Python_GetSwigThis(self);
3400 0 : Py_XINCREF(result);
3401 0 : return result;
3402 : }
3403 :
3404 : SWIGINTERN void
3405 0 : SwigPyBuiltin_SetMetaType (PyTypeObject *type, PyTypeObject *metatype)
3406 : {
3407 : #if PY_VERSION_HEX >= 0x03000000
3408 667 : type->ob_base.ob_base.ob_type = metatype;
3409 : #else
3410 : type->ob_type = metatype;
3411 : #endif
3412 0 : }
3413 :
3414 : #ifdef __cplusplus
3415 : }
3416 : #endif
3417 :
3418 :
3419 :
3420 :
3421 : #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3422 :
3423 : #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
3424 :
3425 :
3426 :
3427 : /* -------- TYPES TABLE (BEGIN) -------- */
3428 :
3429 : #define SWIGTYPE_p_FILE swig_types[0]
3430 : #define SWIGTYPE_p_SwigPyObject swig_types[1]
3431 : #define SWIGTYPE_p__gpgme_attr_t swig_types[2]
3432 : #define SWIGTYPE_p__gpgme_engine_info swig_types[3]
3433 : #define SWIGTYPE_p__gpgme_import_status swig_types[4]
3434 : #define SWIGTYPE_p__gpgme_invalid_key swig_types[5]
3435 : #define SWIGTYPE_p__gpgme_key swig_types[6]
3436 : #define SWIGTYPE_p__gpgme_key_sig swig_types[7]
3437 : #define SWIGTYPE_p__gpgme_new_signature swig_types[8]
3438 : #define SWIGTYPE_p__gpgme_op_assuan_result swig_types[9]
3439 : #define SWIGTYPE_p__gpgme_op_decrypt_result swig_types[10]
3440 : #define SWIGTYPE_p__gpgme_op_encrypt_result swig_types[11]
3441 : #define SWIGTYPE_p__gpgme_op_genkey_result swig_types[12]
3442 : #define SWIGTYPE_p__gpgme_op_import_result swig_types[13]
3443 : #define SWIGTYPE_p__gpgme_op_keylist_result swig_types[14]
3444 : #define SWIGTYPE_p__gpgme_op_sign_result swig_types[15]
3445 : #define SWIGTYPE_p__gpgme_op_verify_result swig_types[16]
3446 : #define SWIGTYPE_p__gpgme_op_vfs_mount_result swig_types[17]
3447 : #define SWIGTYPE_p__gpgme_recipient swig_types[18]
3448 : #define SWIGTYPE_p__gpgme_sig_notation swig_types[19]
3449 : #define SWIGTYPE_p__gpgme_sig_stat_t swig_types[20]
3450 : #define SWIGTYPE_p__gpgme_signature swig_types[21]
3451 : #define SWIGTYPE_p__gpgme_subkey swig_types[22]
3452 : #define SWIGTYPE_p__gpgme_tofu_info swig_types[23]
3453 : #define SWIGTYPE_p__gpgme_trust_item swig_types[24]
3454 : #define SWIGTYPE_p__gpgme_user_id swig_types[25]
3455 : #define SWIGTYPE_p_a___p__gpgme_key swig_types[26]
3456 : #define SWIGTYPE_p_char swig_types[27]
3457 : #define SWIGTYPE_p_f_p_void__void swig_types[28]
3458 : #define SWIGTYPE_p_f_p_void_enum_gpgme_event_io_t_p_void__void swig_types[29]
3459 : #define SWIGTYPE_p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t swig_types[30]
3460 : #define SWIGTYPE_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t swig_types[31]
3461 : #define SWIGTYPE_p_f_p_void_off_t_int__off_t swig_types[32]
3462 : #define SWIGTYPE_p_f_p_void_p_q_const__char_int_int_int__void swig_types[33]
3463 : #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t swig_types[34]
3464 : #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t swig_types[35]
3465 : #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t swig_types[36]
3466 : #define SWIGTYPE_p_f_p_void_p_q_const__void_size_t__gpg_error_t swig_types[37]
3467 : #define SWIGTYPE_p_f_p_void_p_q_const__void_size_t__ssize_t swig_types[38]
3468 : #define SWIGTYPE_p_f_p_void_p_void_size_t__ssize_t swig_types[39]
3469 : #define SWIGTYPE_p_gpg_err_code_t swig_types[40]
3470 : #define SWIGTYPE_p_gpg_err_source_t swig_types[41]
3471 : #define SWIGTYPE_p_gpg_error_t swig_types[42]
3472 : #define SWIGTYPE_p_gpgme_conf_arg swig_types[43]
3473 : #define SWIGTYPE_p_gpgme_conf_arg_value swig_types[44]
3474 : #define SWIGTYPE_p_gpgme_conf_comp swig_types[45]
3475 : #define SWIGTYPE_p_gpgme_conf_level_t swig_types[46]
3476 : #define SWIGTYPE_p_gpgme_conf_opt swig_types[47]
3477 : #define SWIGTYPE_p_gpgme_conf_type_t swig_types[48]
3478 : #define SWIGTYPE_p_gpgme_context swig_types[49]
3479 : #define SWIGTYPE_p_gpgme_data swig_types[50]
3480 : #define SWIGTYPE_p_gpgme_data_cbs swig_types[51]
3481 : #define SWIGTYPE_p_gpgme_data_encoding_t swig_types[52]
3482 : #define SWIGTYPE_p_gpgme_data_type_t swig_types[53]
3483 : #define SWIGTYPE_p_gpgme_encrypt_flags_t swig_types[54]
3484 : #define SWIGTYPE_p_gpgme_event_io_t swig_types[55]
3485 : #define SWIGTYPE_p_gpgme_hash_algo_t swig_types[56]
3486 : #define SWIGTYPE_p_gpgme_io_cbs swig_types[57]
3487 : #define SWIGTYPE_p_gpgme_io_event_done_data swig_types[58]
3488 : #define SWIGTYPE_p_gpgme_pinentry_mode_t swig_types[59]
3489 : #define SWIGTYPE_p_gpgme_protocol_t swig_types[60]
3490 : #define SWIGTYPE_p_gpgme_pubkey_algo_t swig_types[61]
3491 : #define SWIGTYPE_p_gpgme_sig_mode_t swig_types[62]
3492 : #define SWIGTYPE_p_gpgme_sigsum_t swig_types[63]
3493 : #define SWIGTYPE_p_gpgme_status_code_t swig_types[64]
3494 : #define SWIGTYPE_p_gpgme_tofu_policy_t swig_types[65]
3495 : #define SWIGTYPE_p_gpgme_validity_t swig_types[66]
3496 : #define SWIGTYPE_p_off_t swig_types[67]
3497 : #define SWIGTYPE_p_p__gpgme_engine_info swig_types[68]
3498 : #define SWIGTYPE_p_p__gpgme_key swig_types[69]
3499 : #define SWIGTYPE_p_p__gpgme_trust_item swig_types[70]
3500 : #define SWIGTYPE_p_p_char swig_types[71]
3501 : #define SWIGTYPE_p_p_f_p_void_p_q_const__char_int_int_int__void swig_types[72]
3502 : #define SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t swig_types[73]
3503 : #define SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t swig_types[74]
3504 : #define SWIGTYPE_p_p_gpgme_conf_arg swig_types[75]
3505 : #define SWIGTYPE_p_p_gpgme_conf_comp swig_types[76]
3506 : #define SWIGTYPE_p_p_gpgme_conf_opt swig_types[77]
3507 : #define SWIGTYPE_p_p_gpgme_context swig_types[78]
3508 : #define SWIGTYPE_p_p_gpgme_data swig_types[79]
3509 : #define SWIGTYPE_p_p_void swig_types[80]
3510 : #define SWIGTYPE_p_size_t swig_types[81]
3511 : #define SWIGTYPE_p_ssize_t swig_types[82]
3512 : #define SWIGTYPE_p_unsigned_int swig_types[83]
3513 : #define SWIGTYPE_p_void swig_types[84]
3514 : static swig_type_info *swig_types[86];
3515 : static swig_module_info swig_module = {swig_types, 85, 0, 0, 0, 0};
3516 : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3517 : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3518 :
3519 : /* -------- TYPES TABLE (END) -------- */
3520 :
3521 : #if (PY_VERSION_HEX <= 0x02000000)
3522 : # if !defined(SWIG_PYTHON_CLASSIC)
3523 : # error "This python version requires swig to be run with the '-classic' option"
3524 : # endif
3525 : #endif
3526 :
3527 : /*-----------------------------------------------
3528 : @(target):= _gpgme.so
3529 : ------------------------------------------------*/
3530 : #if PY_VERSION_HEX >= 0x03000000
3531 : # define SWIG_init PyInit__gpgme
3532 :
3533 : #else
3534 : # define SWIG_init init_gpgme
3535 :
3536 : #endif
3537 : #define SWIG_name "_gpgme"
3538 :
3539 : #define SWIGVERSION 0x020012
3540 : #define SWIG_VERSION SWIGVERSION
3541 :
3542 :
3543 : #define SWIG_as_voidptr(a) (void *)((const void *)(a))
3544 : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3545 :
3546 :
3547 : #include <stddef.h>
3548 :
3549 :
3550 : #include "src/data.h" /* For struct gpgme_data. */
3551 :
3552 :
3553 : #include <gpgme.h>
3554 :
3555 :
3556 : SWIGINTERN swig_type_info*
3557 0 : SWIG_pchar_descriptor(void)
3558 : {
3559 : static int init = 0;
3560 : static swig_type_info* info = 0;
3561 0 : if (!init) {
3562 0 : info = SWIG_TypeQuery("_p_char");
3563 0 : init = 1;
3564 : }
3565 0 : return info;
3566 : }
3567 :
3568 :
3569 : SWIGINTERN int
3570 0 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3571 : {
3572 : #if PY_VERSION_HEX>=0x03000000
3573 0 : if (PyUnicode_Check(obj))
3574 : #else
3575 : if (PyString_Check(obj))
3576 : #endif
3577 : {
3578 : char *cstr; Py_ssize_t len;
3579 : #if PY_VERSION_HEX>=0x03000000
3580 0 : if (!alloc && cptr) {
3581 : /* We can't allow converting without allocation, since the internal
3582 : representation of string in Python 3 is UCS-2/UCS-4 but we require
3583 : a UTF-8 representation.
3584 : TODO(bhy) More detailed explanation */
3585 : return SWIG_RuntimeError;
3586 : }
3587 0 : obj = PyUnicode_AsUTF8String(obj);
3588 0 : PyBytes_AsStringAndSize(obj, &cstr, &len);
3589 0 : if(alloc) *alloc = SWIG_NEWOBJ;
3590 : #else
3591 : PyString_AsStringAndSize(obj, &cstr, &len);
3592 : #endif
3593 0 : if (cptr) {
3594 0 : if (alloc) {
3595 : /*
3596 : In python the user should not be able to modify the inner
3597 : string representation. To warranty that, if you define
3598 : SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3599 : buffer is always returned.
3600 :
3601 : The default behavior is just to return the pointer value,
3602 : so, be careful.
3603 : */
3604 : #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3605 : if (*alloc != SWIG_OLDOBJ)
3606 : #else
3607 0 : if (*alloc == SWIG_NEWOBJ)
3608 : #endif
3609 : {
3610 0 : *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3611 0 : *alloc = SWIG_NEWOBJ;
3612 : }
3613 : else {
3614 0 : *cptr = cstr;
3615 0 : *alloc = SWIG_OLDOBJ;
3616 : }
3617 : } else {
3618 : #if PY_VERSION_HEX>=0x03000000
3619 : assert(0); /* Should never reach here in Python 3 */
3620 : #endif
3621 0 : *cptr = SWIG_Python_str_AsChar(obj);
3622 : }
3623 : }
3624 0 : if (psize) *psize = len + 1;
3625 : #if PY_VERSION_HEX>=0x03000000
3626 0 : Py_XDECREF(obj);
3627 : #endif
3628 : return SWIG_OK;
3629 : } else {
3630 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3631 0 : if (pchar_descriptor) {
3632 0 : void* vptr = 0;
3633 0 : if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3634 0 : if (cptr) *cptr = (char *) vptr;
3635 0 : if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3636 0 : if (alloc) *alloc = SWIG_OLDOBJ;
3637 0 : return SWIG_OK;
3638 : }
3639 : }
3640 : }
3641 : return SWIG_TypeError;
3642 : }
3643 :
3644 :
3645 :
3646 :
3647 :
3648 : SWIGINTERNINLINE PyObject *
3649 979 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3650 : {
3651 979 : if (carray) {
3652 671 : if (size > INT_MAX) {
3653 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3654 0 : return pchar_descriptor ?
3655 0 : SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3656 : } else {
3657 : #if PY_VERSION_HEX >= 0x03000000
3658 671 : return PyUnicode_FromStringAndSize(carray, (int)(size));
3659 : #else
3660 : return PyString_FromStringAndSize(carray, (int)(size));
3661 : #endif
3662 : }
3663 : } else {
3664 308 : return SWIG_Py_Void();
3665 : }
3666 : }
3667 :
3668 :
3669 : SWIGINTERNINLINE PyObject *
3670 979 : SWIG_FromCharPtr(const char *cptr)
3671 : {
3672 979 : return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3673 : }
3674 :
3675 :
3676 : #include <limits.h>
3677 : #if !defined(SWIG_NO_LLONG_MAX)
3678 : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3679 : # define LLONG_MAX __LONG_LONG_MAX__
3680 : # define LLONG_MIN (-LLONG_MAX - 1LL)
3681 : # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3682 : # endif
3683 : #endif
3684 :
3685 :
3686 : SWIGINTERN int
3687 : SWIG_AsVal_double (PyObject *obj, double *val)
3688 : {
3689 : int res = SWIG_TypeError;
3690 : if (PyFloat_Check(obj)) {
3691 : if (val) *val = PyFloat_AsDouble(obj);
3692 : return SWIG_OK;
3693 : } else if (PyInt_Check(obj)) {
3694 : if (val) *val = PyInt_AsLong(obj);
3695 : return SWIG_OK;
3696 : } else if (PyLong_Check(obj)) {
3697 : double v = PyLong_AsDouble(obj);
3698 : if (!PyErr_Occurred()) {
3699 : if (val) *val = v;
3700 : return SWIG_OK;
3701 : } else {
3702 : PyErr_Clear();
3703 : }
3704 : }
3705 : #ifdef SWIG_PYTHON_CAST_MODE
3706 : {
3707 : int dispatch = 0;
3708 : double d = PyFloat_AsDouble(obj);
3709 : if (!PyErr_Occurred()) {
3710 : if (val) *val = d;
3711 : return SWIG_AddCast(SWIG_OK);
3712 : } else {
3713 : PyErr_Clear();
3714 : }
3715 : if (!dispatch) {
3716 : long v = PyLong_AsLong(obj);
3717 : if (!PyErr_Occurred()) {
3718 : if (val) *val = v;
3719 : return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3720 : } else {
3721 : PyErr_Clear();
3722 : }
3723 : }
3724 : }
3725 : #endif
3726 : return res;
3727 : }
3728 :
3729 :
3730 : #include <float.h>
3731 :
3732 :
3733 : #include <math.h>
3734 :
3735 :
3736 : SWIGINTERNINLINE int
3737 : SWIG_CanCastAsInteger(double *d, double min, double max) {
3738 : double x = *d;
3739 : if ((min <= x && x <= max)) {
3740 : double fx = floor(x);
3741 : double cx = ceil(x);
3742 : double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3743 : if ((errno == EDOM) || (errno == ERANGE)) {
3744 : errno = 0;
3745 : } else {
3746 : double summ, reps, diff;
3747 : if (rd < x) {
3748 : diff = x - rd;
3749 : } else if (rd > x) {
3750 : diff = rd - x;
3751 : } else {
3752 : return 1;
3753 : }
3754 : summ = rd + x;
3755 : reps = diff/summ;
3756 : if (reps < 8*DBL_EPSILON) {
3757 : *d = rd;
3758 : return 1;
3759 : }
3760 : }
3761 : }
3762 : return 0;
3763 : }
3764 :
3765 :
3766 : SWIGINTERN int
3767 31 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3768 : {
3769 : #if PY_VERSION_HEX < 0x03000000
3770 : if (PyInt_Check(obj)) {
3771 : long v = PyInt_AsLong(obj);
3772 : if (v >= 0) {
3773 : if (val) *val = v;
3774 : return SWIG_OK;
3775 : } else {
3776 : return SWIG_OverflowError;
3777 : }
3778 : } else
3779 : #endif
3780 31 : if (PyLong_Check(obj)) {
3781 31 : unsigned long v = PyLong_AsUnsignedLong(obj);
3782 31 : if (!PyErr_Occurred()) {
3783 31 : if (val) *val = v;
3784 : return SWIG_OK;
3785 : } else {
3786 0 : PyErr_Clear();
3787 : #if PY_VERSION_HEX >= 0x03000000
3788 : {
3789 0 : long v = PyLong_AsLong(obj);
3790 0 : if (!PyErr_Occurred()) {
3791 0 : if (v < 0) {
3792 : return SWIG_OverflowError;
3793 : }
3794 : } else {
3795 0 : PyErr_Clear();
3796 : }
3797 : }
3798 : #endif
3799 : }
3800 : }
3801 : #ifdef SWIG_PYTHON_CAST_MODE
3802 : {
3803 : int dispatch = 0;
3804 : unsigned long v = PyLong_AsUnsignedLong(obj);
3805 : if (!PyErr_Occurred()) {
3806 : if (val) *val = v;
3807 : return SWIG_AddCast(SWIG_OK);
3808 : } else {
3809 : PyErr_Clear();
3810 : }
3811 : if (!dispatch) {
3812 : double d;
3813 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3814 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3815 : if (val) *val = (unsigned long)(d);
3816 : return res;
3817 : }
3818 : }
3819 : }
3820 : #endif
3821 : return SWIG_TypeError;
3822 : }
3823 :
3824 :
3825 : SWIGINTERN int
3826 5 : SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3827 : {
3828 : unsigned long v;
3829 5 : int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3830 5 : if (SWIG_IsOK(res)) {
3831 5 : if ((v > UINT_MAX)) {
3832 : return SWIG_OverflowError;
3833 : } else {
3834 5 : if (val) *val = (unsigned int)(v);
3835 : }
3836 : }
3837 5 : return res;
3838 : }
3839 :
3840 :
3841 : SWIGINTERNINLINE PyObject*
3842 : SWIG_From_unsigned_SS_int (unsigned int value)
3843 : {
3844 1749 : return PyInt_FromSize_t((size_t) value);
3845 : }
3846 :
3847 :
3848 : SWIGINTERNINLINE PyObject*
3849 : SWIG_From_int (int value)
3850 : {
3851 7019 : return PyInt_FromLong((long) value);
3852 : }
3853 :
3854 :
3855 : SWIGINTERNINLINE int
3856 26 : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3857 : {
3858 : unsigned long v;
3859 26 : int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3860 26 : if (SWIG_IsOK(res) && val) *val = (size_t)(v);
3861 26 : return res;
3862 : }
3863 :
3864 :
3865 : SWIGINTERN int
3866 442 : SWIG_AsVal_long (PyObject *obj, long* val)
3867 : {
3868 442 : if (PyInt_Check(obj)) {
3869 442 : if (val) *val = PyInt_AsLong(obj);
3870 : return SWIG_OK;
3871 0 : } else if (PyLong_Check(obj)) {
3872 0 : long v = PyLong_AsLong(obj);
3873 0 : if (!PyErr_Occurred()) {
3874 0 : if (val) *val = v;
3875 : return SWIG_OK;
3876 : } else {
3877 0 : PyErr_Clear();
3878 : }
3879 : }
3880 : #ifdef SWIG_PYTHON_CAST_MODE
3881 : {
3882 : int dispatch = 0;
3883 : long v = PyInt_AsLong(obj);
3884 : if (!PyErr_Occurred()) {
3885 : if (val) *val = v;
3886 : return SWIG_AddCast(SWIG_OK);
3887 : } else {
3888 : PyErr_Clear();
3889 : }
3890 : if (!dispatch) {
3891 : double d;
3892 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3893 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3894 : if (val) *val = (long)(d);
3895 : return res;
3896 : }
3897 : }
3898 : }
3899 : #endif
3900 : return SWIG_TypeError;
3901 : }
3902 :
3903 :
3904 : SWIGINTERN int
3905 442 : SWIG_AsVal_int (PyObject * obj, int *val)
3906 : {
3907 : long v;
3908 442 : int res = SWIG_AsVal_long (obj, &v);
3909 442 : if (SWIG_IsOK(res)) {
3910 442 : if ((v < INT_MIN || v > INT_MAX)) {
3911 : return SWIG_OverflowError;
3912 : } else {
3913 442 : if (val) *val = (int)(v);
3914 : }
3915 : }
3916 442 : return res;
3917 : }
3918 :
3919 :
3920 : SWIGINTERN int
3921 0 : SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
3922 : {
3923 : unsigned long v;
3924 0 : int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3925 0 : if (SWIG_IsOK(res)) {
3926 0 : if ((v > USHRT_MAX)) {
3927 : return SWIG_OverflowError;
3928 : } else {
3929 0 : if (val) *val = (unsigned short)(v);
3930 : }
3931 : }
3932 0 : return res;
3933 : }
3934 :
3935 :
3936 : #define SWIG_From_long PyLong_FromLong
3937 :
3938 :
3939 : SWIGINTERNINLINE PyObject*
3940 28 : SWIG_From_unsigned_SS_long (unsigned long value)
3941 : {
3942 56 : return (value > LONG_MAX) ?
3943 28 : PyLong_FromUnsignedLong(value) : PyLong_FromLong((long)(value));
3944 : }
3945 :
3946 :
3947 : SWIGINTERNINLINE PyObject *
3948 : SWIG_From_unsigned_SS_short (unsigned short value)
3949 : {
3950 0 : return SWIG_From_unsigned_SS_long (value);
3951 : }
3952 :
3953 :
3954 : SWIGINTERN int
3955 0 : SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3956 : {
3957 0 : char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3958 0 : int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3959 0 : if (SWIG_IsOK(res)) {
3960 0 : if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3961 0 : if (csize <= size) {
3962 0 : if (val) {
3963 0 : if (csize) memcpy(val, cptr, csize*sizeof(char));
3964 0 : if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3965 : }
3966 0 : if (alloc == SWIG_NEWOBJ) {
3967 0 : free((char*)cptr);
3968 0 : res = SWIG_DelNewMask(res);
3969 : }
3970 0 : return res;
3971 : }
3972 0 : if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3973 : }
3974 : return SWIG_TypeError;
3975 : }
3976 :
3977 : typedef union {
3978 : unsigned int count;
3979 : unsigned int uint32;
3980 : int int32;
3981 : char *string;
3982 : } gpgme_conf_arg_value;
3983 :
3984 :
3985 :
3986 : static gpgme_ctx_t *new_gpgme_ctx_t_p() {
3987 42 : return (gpgme_ctx_t *)malloc(sizeof(gpgme_ctx_t));
3988 : }
3989 :
3990 0 : static gpgme_ctx_t *copy_gpgme_ctx_t_p(gpgme_ctx_t value) {
3991 0 : return (gpgme_ctx_t *)memcpy((gpgme_ctx_t *)malloc(sizeof(gpgme_ctx_t)),&value,sizeof(gpgme_ctx_t));
3992 : }
3993 :
3994 : static void delete_gpgme_ctx_t_p(gpgme_ctx_t *obj) {
3995 42 : if (obj) free((char*)obj);
3996 : }
3997 :
3998 : static void gpgme_ctx_t_p_assign(gpgme_ctx_t *obj, gpgme_ctx_t value) {
3999 0 : *obj = value;
4000 : }
4001 :
4002 0 : static gpgme_ctx_t gpgme_ctx_t_p_value(gpgme_ctx_t *obj) {
4003 0 : return *obj;
4004 : }
4005 :
4006 :
4007 : static gpgme_data_t *new_gpgme_data_t_p() {
4008 103 : return (gpgme_data_t *)malloc(sizeof(gpgme_data_t));
4009 : }
4010 :
4011 0 : static gpgme_data_t *copy_gpgme_data_t_p(gpgme_data_t value) {
4012 0 : return (gpgme_data_t *)memcpy((gpgme_data_t *)malloc(sizeof(gpgme_data_t)),&value,sizeof(gpgme_data_t));
4013 : }
4014 :
4015 : static void delete_gpgme_data_t_p(gpgme_data_t *obj) {
4016 103 : if (obj) free((char*)obj);
4017 : }
4018 :
4019 : static void gpgme_data_t_p_assign(gpgme_data_t *obj, gpgme_data_t value) {
4020 0 : *obj = value;
4021 : }
4022 :
4023 0 : static gpgme_data_t gpgme_data_t_p_value(gpgme_data_t *obj) {
4024 0 : return *obj;
4025 : }
4026 :
4027 :
4028 : static gpgme_key_t *new_gpgme_key_t_p() {
4029 79 : return (gpgme_key_t *)malloc(sizeof(gpgme_key_t));
4030 : }
4031 :
4032 0 : static gpgme_key_t *copy_gpgme_key_t_p(gpgme_key_t value) {
4033 0 : return (gpgme_key_t *)memcpy((gpgme_key_t *)malloc(sizeof(gpgme_key_t)),&value,sizeof(gpgme_key_t));
4034 : }
4035 :
4036 : static void delete_gpgme_key_t_p(gpgme_key_t *obj) {
4037 79 : if (obj) free((char*)obj);
4038 : }
4039 :
4040 : static void gpgme_key_t_p_assign(gpgme_key_t *obj, gpgme_key_t value) {
4041 0 : *obj = value;
4042 : }
4043 :
4044 0 : static gpgme_key_t gpgme_key_t_p_value(gpgme_key_t *obj) {
4045 0 : return *obj;
4046 : }
4047 :
4048 :
4049 : static gpgme_error_t *new_gpgme_error_t_p() {
4050 11 : return (gpgme_error_t *)malloc(sizeof(gpgme_error_t));
4051 : }
4052 :
4053 0 : static gpgme_error_t *copy_gpgme_error_t_p(gpgme_error_t value) {
4054 0 : return (gpgme_error_t *)memcpy((gpgme_error_t *)malloc(sizeof(gpgme_error_t)),&value,sizeof(gpgme_error_t));
4055 : }
4056 :
4057 : static void delete_gpgme_error_t_p(gpgme_error_t *obj) {
4058 11 : if (obj) free((char*)obj);
4059 : }
4060 :
4061 : static void gpgme_error_t_p_assign(gpgme_error_t *obj, gpgme_error_t value) {
4062 0 : *obj = value;
4063 : }
4064 :
4065 0 : static gpgme_error_t gpgme_error_t_p_value(gpgme_error_t *obj) {
4066 0 : return *obj;
4067 : }
4068 :
4069 :
4070 : static gpgme_trust_item_t *new_gpgme_trust_item_t_p() {
4071 2 : return (gpgme_trust_item_t *)malloc(sizeof(gpgme_trust_item_t));
4072 : }
4073 :
4074 0 : static gpgme_trust_item_t *copy_gpgme_trust_item_t_p(gpgme_trust_item_t value) {
4075 0 : return (gpgme_trust_item_t *)memcpy((gpgme_trust_item_t *)malloc(sizeof(gpgme_trust_item_t)),&value,sizeof(gpgme_trust_item_t));
4076 : }
4077 :
4078 : static void delete_gpgme_trust_item_t_p(gpgme_trust_item_t *obj) {
4079 2 : if (obj) free((char*)obj);
4080 : }
4081 :
4082 : static void gpgme_trust_item_t_p_assign(gpgme_trust_item_t *obj, gpgme_trust_item_t value) {
4083 0 : *obj = value;
4084 : }
4085 :
4086 0 : static gpgme_trust_item_t gpgme_trust_item_t_p_value(gpgme_trust_item_t *obj) {
4087 0 : return *obj;
4088 : }
4089 :
4090 :
4091 : static gpgme_engine_info_t *new_gpgme_engine_info_t_p() {
4092 0 : return (gpgme_engine_info_t *)malloc(sizeof(gpgme_engine_info_t));
4093 : }
4094 :
4095 0 : static gpgme_engine_info_t *copy_gpgme_engine_info_t_p(gpgme_engine_info_t value) {
4096 0 : return (gpgme_engine_info_t *)memcpy((gpgme_engine_info_t *)malloc(sizeof(gpgme_engine_info_t)),&value,sizeof(gpgme_engine_info_t));
4097 : }
4098 :
4099 : static void delete_gpgme_engine_info_t_p(gpgme_engine_info_t *obj) {
4100 0 : if (obj) free((char*)obj);
4101 : }
4102 :
4103 : static void gpgme_engine_info_t_p_assign(gpgme_engine_info_t *obj, gpgme_engine_info_t value) {
4104 0 : *obj = value;
4105 : }
4106 :
4107 0 : static gpgme_engine_info_t gpgme_engine_info_t_p_value(gpgme_engine_info_t *obj) {
4108 0 : return *obj;
4109 : }
4110 :
4111 :
4112 : #include <stdio.h>
4113 :
4114 :
4115 : #include "helpers.h"
4116 : #include "private.h"
4117 :
4118 : /* SWIG runtime support for helpers.c */
4119 : PyObject *
4120 40 : _pyme_wrap_gpgme_data_t(gpgme_data_t data)
4121 : {
4122 40 : return SWIG_Python_NewPointerObj(NULL, data, SWIGTYPE_p_gpgme_data, 0);
4123 : }
4124 :
4125 : gpgme_ctx_t
4126 185 : _pyme_unwrap_gpgme_ctx_t(PyObject *wrapped)
4127 : {
4128 : gpgme_ctx_t result;
4129 185 : if (SWIG_ConvertPtr(wrapped,
4130 : (void **) &result,
4131 : SWIGTYPE_p_gpgme_context,
4132 : SWIG_POINTER_EXCEPTION) == -1)
4133 : return NULL;
4134 185 : return result;
4135 : }
4136 :
4137 : #ifdef __cplusplus
4138 : extern "C" {
4139 : #endif
4140 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_name_set(PyObject *self, PyObject *args) {
4141 0 : PyObject *resultobj = 0;
4142 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4143 0 : char *arg2 = (char *) 0 ;
4144 0 : void *argp1 = 0 ;
4145 0 : int res1 = 0 ;
4146 : int res2 ;
4147 0 : char *buf2 = 0 ;
4148 0 : int alloc2 = 0 ;
4149 0 : PyObject * obj1 = 0 ;
4150 :
4151 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_name_set",&obj1)) SWIG_fail;
4152 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4153 0 : if (!SWIG_IsOK(res1)) {
4154 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_name_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4155 : }
4156 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4157 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4158 0 : if (!SWIG_IsOK(res2)) {
4159 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_sig_notation_name_set" "', argument " "2"" of type '" "char *""'");
4160 : }
4161 0 : arg2 = (char *)(buf2);
4162 0 : if (arg1->name) free((char*)arg1->name);
4163 0 : if (arg2) {
4164 0 : size_t size = strlen((const char *)(arg2)) + 1;
4165 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4166 : } else {
4167 0 : arg1->name = 0;
4168 : }
4169 0 : resultobj = SWIG_Py_Void();
4170 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4171 : return resultobj;
4172 : fail:
4173 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4174 : return NULL;
4175 : }
4176 :
4177 :
4178 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_name_get(PyObject *self, PyObject *args) {
4179 15 : PyObject *resultobj = 0;
4180 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4181 15 : void *argp1 = 0 ;
4182 15 : int res1 = 0 ;
4183 15 : char *result = 0 ;
4184 :
4185 15 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
4186 15 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4187 15 : if (!SWIG_IsOK(res1)) {
4188 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_name_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4189 : }
4190 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4191 15 : result = (char *) ((arg1)->name);
4192 15 : resultobj = SWIG_FromCharPtr((const char *)result);
4193 15 : return resultobj;
4194 : fail:
4195 : return NULL;
4196 : }
4197 :
4198 :
4199 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_value_set(PyObject *self, PyObject *args) {
4200 0 : PyObject *resultobj = 0;
4201 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4202 0 : char *arg2 = (char *) 0 ;
4203 0 : void *argp1 = 0 ;
4204 0 : int res1 = 0 ;
4205 : int res2 ;
4206 0 : char *buf2 = 0 ;
4207 0 : int alloc2 = 0 ;
4208 0 : PyObject * obj1 = 0 ;
4209 :
4210 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_value_set",&obj1)) SWIG_fail;
4211 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4212 0 : if (!SWIG_IsOK(res1)) {
4213 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_value_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4214 : }
4215 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4216 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4217 0 : if (!SWIG_IsOK(res2)) {
4218 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_sig_notation_value_set" "', argument " "2"" of type '" "char *""'");
4219 : }
4220 0 : arg2 = (char *)(buf2);
4221 0 : if (arg1->value) free((char*)arg1->value);
4222 0 : if (arg2) {
4223 0 : size_t size = strlen((const char *)(arg2)) + 1;
4224 0 : arg1->value = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4225 : } else {
4226 0 : arg1->value = 0;
4227 : }
4228 0 : resultobj = SWIG_Py_Void();
4229 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4230 : return resultobj;
4231 : fail:
4232 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4233 : return NULL;
4234 : }
4235 :
4236 :
4237 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_value_get(PyObject *self, PyObject *args) {
4238 15 : PyObject *resultobj = 0;
4239 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4240 15 : void *argp1 = 0 ;
4241 15 : int res1 = 0 ;
4242 15 : char *result = 0 ;
4243 :
4244 15 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
4245 15 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4246 15 : if (!SWIG_IsOK(res1)) {
4247 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_value_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4248 : }
4249 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4250 15 : result = (char *) ((arg1)->value);
4251 15 : resultobj = SWIG_FromCharPtr((const char *)result);
4252 15 : return resultobj;
4253 : fail:
4254 : return NULL;
4255 : }
4256 :
4257 :
4258 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_flags_set(PyObject *self, PyObject *args) {
4259 0 : PyObject *resultobj = 0;
4260 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4261 : gpgme_sig_notation_flags_t arg2 ;
4262 0 : void *argp1 = 0 ;
4263 0 : int res1 = 0 ;
4264 : unsigned int val2 ;
4265 0 : int ecode2 = 0 ;
4266 0 : PyObject * obj1 = 0 ;
4267 :
4268 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_flags_set",&obj1)) SWIG_fail;
4269 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4270 0 : if (!SWIG_IsOK(res1)) {
4271 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_flags_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4272 : }
4273 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4274 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4275 0 : if (!SWIG_IsOK(ecode2)) {
4276 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_sig_notation_flags_set" "', argument " "2"" of type '" "gpgme_sig_notation_flags_t""'");
4277 : }
4278 0 : arg2 = (gpgme_sig_notation_flags_t)(val2);
4279 0 : if (arg1) (arg1)->flags = arg2;
4280 0 : resultobj = SWIG_Py_Void();
4281 0 : return resultobj;
4282 : fail:
4283 : return NULL;
4284 : }
4285 :
4286 :
4287 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_flags_get(PyObject *self, PyObject *args) {
4288 15 : PyObject *resultobj = 0;
4289 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4290 15 : void *argp1 = 0 ;
4291 15 : int res1 = 0 ;
4292 : gpgme_sig_notation_flags_t result;
4293 :
4294 15 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
4295 15 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4296 15 : if (!SWIG_IsOK(res1)) {
4297 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_flags_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4298 : }
4299 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4300 15 : result = (gpgme_sig_notation_flags_t) ((arg1)->flags);
4301 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4302 15 : return resultobj;
4303 : fail:
4304 : return NULL;
4305 : }
4306 :
4307 :
4308 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_human_readable_set(PyObject *self, PyObject *args) {
4309 0 : PyObject *resultobj = 0;
4310 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4311 : unsigned int arg2 ;
4312 0 : void *argp1 = 0 ;
4313 0 : int res1 = 0 ;
4314 : unsigned int val2 ;
4315 0 : int ecode2 = 0 ;
4316 0 : PyObject * obj1 = 0 ;
4317 :
4318 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_human_readable_set",&obj1)) SWIG_fail;
4319 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4320 0 : if (!SWIG_IsOK(res1)) {
4321 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_human_readable_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4322 : }
4323 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4324 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4325 0 : if (!SWIG_IsOK(ecode2)) {
4326 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_sig_notation_human_readable_set" "', argument " "2"" of type '" "unsigned int""'");
4327 : }
4328 0 : arg2 = (unsigned int)(val2);
4329 0 : if (arg1) (arg1)->human_readable = arg2;
4330 0 : resultobj = SWIG_Py_Void();
4331 0 : return resultobj;
4332 : fail:
4333 : return NULL;
4334 : }
4335 :
4336 :
4337 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_human_readable_get(PyObject *self, PyObject *args) {
4338 15 : PyObject *resultobj = 0;
4339 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4340 15 : void *argp1 = 0 ;
4341 15 : int res1 = 0 ;
4342 : unsigned int result;
4343 :
4344 15 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
4345 15 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4346 15 : if (!SWIG_IsOK(res1)) {
4347 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_human_readable_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4348 : }
4349 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4350 15 : result = (unsigned int) ((arg1)->human_readable);
4351 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4352 15 : return resultobj;
4353 : fail:
4354 : return NULL;
4355 : }
4356 :
4357 :
4358 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_critical_set(PyObject *self, PyObject *args) {
4359 0 : PyObject *resultobj = 0;
4360 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4361 : unsigned int arg2 ;
4362 0 : void *argp1 = 0 ;
4363 0 : int res1 = 0 ;
4364 : unsigned int val2 ;
4365 0 : int ecode2 = 0 ;
4366 0 : PyObject * obj1 = 0 ;
4367 :
4368 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_critical_set",&obj1)) SWIG_fail;
4369 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4370 0 : if (!SWIG_IsOK(res1)) {
4371 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_critical_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4372 : }
4373 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4374 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4375 0 : if (!SWIG_IsOK(ecode2)) {
4376 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_sig_notation_critical_set" "', argument " "2"" of type '" "unsigned int""'");
4377 : }
4378 0 : arg2 = (unsigned int)(val2);
4379 0 : if (arg1) (arg1)->critical = arg2;
4380 0 : resultobj = SWIG_Py_Void();
4381 0 : return resultobj;
4382 : fail:
4383 : return NULL;
4384 : }
4385 :
4386 :
4387 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_critical_get(PyObject *self, PyObject *args) {
4388 15 : PyObject *resultobj = 0;
4389 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4390 15 : void *argp1 = 0 ;
4391 15 : int res1 = 0 ;
4392 : unsigned int result;
4393 :
4394 15 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
4395 15 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4396 15 : if (!SWIG_IsOK(res1)) {
4397 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_critical_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4398 : }
4399 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4400 15 : result = (unsigned int) ((arg1)->critical);
4401 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4402 15 : return resultobj;
4403 : fail:
4404 : return NULL;
4405 : }
4406 :
4407 :
4408 0 : SWIGINTERN int _wrap_new__gpgme_sig_notation(PyObject *self, PyObject *args) {
4409 0 : PyObject *resultobj = 0;
4410 0 : struct _gpgme_sig_notation *result = 0 ;
4411 :
4412 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
4413 0 : result = (struct _gpgme_sig_notation *)calloc(1, sizeof(struct _gpgme_sig_notation));
4414 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_sig_notation, SWIG_BUILTIN_INIT | 0 );
4415 0 : return resultobj == Py_None ? -1 : 0;
4416 : fail:
4417 : return -1;
4418 : }
4419 :
4420 :
4421 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_sig_notation(PyObject *self, PyObject *args) {
4422 0 : PyObject *resultobj = 0;
4423 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4424 0 : void *argp1 = 0 ;
4425 0 : int res1 = 0 ;
4426 :
4427 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
4428 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
4429 0 : if (!SWIG_IsOK(res1)) {
4430 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_sig_notation" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4431 : }
4432 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4433 0 : free((char *) arg1);
4434 0 : resultobj = SWIG_Py_Void();
4435 0 : return resultobj;
4436 : fail:
4437 : return NULL;
4438 : }
4439 :
4440 :
4441 0 : SWIGINTERN PyObject *_wrap_gpgme_err_make(PyObject *self, PyObject *args) {
4442 0 : PyObject *resultobj = 0;
4443 : gpgme_err_source_t arg1 ;
4444 : gpgme_err_code_t arg2 ;
4445 0 : PyObject * obj0 = 0 ;
4446 0 : PyObject * obj1 = 0 ;
4447 : gpgme_error_t result;
4448 :
4449 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_err_make",&obj0,&obj1)) SWIG_fail;
4450 : {
4451 0 : arg1 = PyLong_AsLong(obj0);
4452 : }
4453 : {
4454 0 : arg2 = PyLong_AsLong(obj1);
4455 : }
4456 0 : result = gpgme_err_make(arg1,arg2);
4457 : {
4458 0 : resultobj = PyLong_FromLong(result);
4459 : }
4460 0 : return resultobj;
4461 : fail:
4462 : return NULL;
4463 : }
4464 :
4465 :
4466 0 : SWIGINTERN PyObject *_wrap_gpgme_error(PyObject *self, PyObject *args) {
4467 0 : PyObject *resultobj = 0;
4468 : gpgme_err_code_t arg1 ;
4469 0 : PyObject * obj0 = 0 ;
4470 : gpgme_error_t result;
4471 :
4472 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_error",&obj0)) SWIG_fail;
4473 : {
4474 0 : arg1 = PyLong_AsLong(obj0);
4475 : }
4476 0 : result = gpgme_error(arg1);
4477 : {
4478 0 : resultobj = PyLong_FromLong(result);
4479 : }
4480 0 : return resultobj;
4481 : fail:
4482 : return NULL;
4483 : }
4484 :
4485 :
4486 28 : SWIGINTERN PyObject *_wrap_gpgme_err_code(PyObject *self, PyObject *args) {
4487 28 : PyObject *resultobj = 0;
4488 : gpgme_error_t arg1 ;
4489 28 : PyObject * obj0 = 0 ;
4490 : gpgme_err_code_t result;
4491 :
4492 28 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_code",&obj0)) SWIG_fail;
4493 : {
4494 28 : arg1 = PyLong_AsLong(obj0);
4495 : }
4496 28 : result = gpgme_err_code(arg1);
4497 : {
4498 28 : resultobj = PyLong_FromLong(result);
4499 : }
4500 28 : return resultobj;
4501 : fail:
4502 : return NULL;
4503 : }
4504 :
4505 :
4506 1 : SWIGINTERN PyObject *_wrap_gpgme_err_source(PyObject *self, PyObject *args) {
4507 1 : PyObject *resultobj = 0;
4508 : gpgme_error_t arg1 ;
4509 1 : PyObject * obj0 = 0 ;
4510 : gpgme_err_source_t result;
4511 :
4512 1 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_source",&obj0)) SWIG_fail;
4513 : {
4514 1 : arg1 = PyLong_AsLong(obj0);
4515 : }
4516 1 : result = gpgme_err_source(arg1);
4517 : {
4518 1 : resultobj = PyLong_FromLong(result);
4519 : }
4520 1 : return resultobj;
4521 : fail:
4522 : return NULL;
4523 : }
4524 :
4525 :
4526 0 : SWIGINTERN PyObject *_wrap_gpgme_strerror(PyObject *self, PyObject *args) {
4527 0 : PyObject *resultobj = 0;
4528 : gpgme_error_t arg1 ;
4529 0 : PyObject * obj0 = 0 ;
4530 0 : char *result = 0 ;
4531 :
4532 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_strerror",&obj0)) SWIG_fail;
4533 : {
4534 0 : arg1 = PyLong_AsLong(obj0);
4535 : }
4536 0 : result = (char *)gpgme_strerror(arg1);
4537 0 : resultobj = SWIG_FromCharPtr((const char *)result);
4538 0 : return resultobj;
4539 : fail:
4540 : return NULL;
4541 : }
4542 :
4543 :
4544 0 : SWIGINTERN PyObject *_wrap_gpgme_strerror_r(PyObject *self, PyObject *args) {
4545 0 : PyObject *resultobj = 0;
4546 : gpg_error_t arg1 ;
4547 0 : char *arg2 = (char *) 0 ;
4548 : size_t arg3 ;
4549 0 : PyObject * obj0 = 0 ;
4550 0 : PyObject * obj1 = 0 ;
4551 : int result;
4552 :
4553 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_strerror_r",&obj0,&obj1)) SWIG_fail;
4554 : {
4555 0 : arg1 = PyLong_AsLong(obj0);
4556 : }
4557 : {
4558 0 : arg3 = PyLong_AsLong(obj1);
4559 : if (arg3 < 0) {
4560 : PyErr_SetString(PyExc_ValueError, "Positive integer expected");
4561 : return NULL;
4562 : }
4563 0 : arg2 = (char *) malloc(arg3+1);
4564 : }
4565 0 : result = (int)gpgme_strerror_r(arg1,arg2,arg3);
4566 0 : resultobj = SWIG_From_int((int)(result));
4567 : {
4568 0 : Py_XDECREF(resultobj); /* Blow away any previous result */
4569 0 : if (result < 0) {
4570 : /* Check for I/O error */
4571 0 : free(arg2);
4572 0 : return PyErr_SetFromErrno(PyExc_RuntimeError);
4573 : }
4574 0 : resultobj = PyBytes_FromStringAndSize(arg2,result);
4575 0 : free(arg2);
4576 : }
4577 0 : return resultobj;
4578 : fail:
4579 : return NULL;
4580 : }
4581 :
4582 :
4583 0 : SWIGINTERN PyObject *_wrap_gpgme_strsource(PyObject *self, PyObject *args) {
4584 0 : PyObject *resultobj = 0;
4585 : gpgme_error_t arg1 ;
4586 0 : PyObject * obj0 = 0 ;
4587 0 : char *result = 0 ;
4588 :
4589 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_strsource",&obj0)) SWIG_fail;
4590 : {
4591 0 : arg1 = PyLong_AsLong(obj0);
4592 : }
4593 0 : result = (char *)gpgme_strsource(arg1);
4594 0 : resultobj = SWIG_FromCharPtr((const char *)result);
4595 0 : return resultobj;
4596 : fail:
4597 : return NULL;
4598 : }
4599 :
4600 :
4601 0 : SWIGINTERN PyObject *_wrap_gpgme_err_code_from_errno(PyObject *self, PyObject *args) {
4602 0 : PyObject *resultobj = 0;
4603 : int arg1 ;
4604 : int val1 ;
4605 0 : int ecode1 = 0 ;
4606 0 : PyObject * obj0 = 0 ;
4607 : gpgme_err_code_t result;
4608 :
4609 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_code_from_errno",&obj0)) SWIG_fail;
4610 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
4611 0 : if (!SWIG_IsOK(ecode1)) {
4612 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_err_code_from_errno" "', argument " "1"" of type '" "int""'");
4613 : }
4614 0 : arg1 = (int)(val1);
4615 0 : result = gpgme_err_code_from_errno(arg1);
4616 : {
4617 0 : resultobj = PyLong_FromLong(result);
4618 : }
4619 0 : return resultobj;
4620 : fail:
4621 : return NULL;
4622 : }
4623 :
4624 :
4625 0 : SWIGINTERN PyObject *_wrap_gpgme_err_code_to_errno(PyObject *self, PyObject *args) {
4626 0 : PyObject *resultobj = 0;
4627 : gpgme_err_code_t arg1 ;
4628 0 : PyObject * obj0 = 0 ;
4629 : int result;
4630 :
4631 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_code_to_errno",&obj0)) SWIG_fail;
4632 : {
4633 0 : arg1 = PyLong_AsLong(obj0);
4634 : }
4635 0 : result = (int)gpgme_err_code_to_errno(arg1);
4636 0 : resultobj = SWIG_From_int((int)(result));
4637 0 : return resultobj;
4638 : fail:
4639 : return NULL;
4640 : }
4641 :
4642 :
4643 0 : SWIGINTERN PyObject *_wrap_gpgme_err_code_from_syserror(PyObject *self, PyObject *args) {
4644 0 : PyObject *resultobj = 0;
4645 : gpgme_err_code_t result;
4646 :
4647 0 : if (!PyArg_ParseTuple(args,(char *)":gpgme_err_code_from_syserror")) SWIG_fail;
4648 0 : result = gpgme_err_code_from_syserror();
4649 : {
4650 0 : resultobj = PyLong_FromLong(result);
4651 : }
4652 0 : return resultobj;
4653 : fail:
4654 : return NULL;
4655 : }
4656 :
4657 :
4658 0 : SWIGINTERN PyObject *_wrap_gpgme_err_set_errno(PyObject *self, PyObject *args) {
4659 0 : PyObject *resultobj = 0;
4660 : int arg1 ;
4661 : int val1 ;
4662 0 : int ecode1 = 0 ;
4663 0 : PyObject * obj0 = 0 ;
4664 :
4665 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_set_errno",&obj0)) SWIG_fail;
4666 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
4667 0 : if (!SWIG_IsOK(ecode1)) {
4668 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_err_set_errno" "', argument " "1"" of type '" "int""'");
4669 : }
4670 0 : arg1 = (int)(val1);
4671 0 : gpgme_err_set_errno(arg1);
4672 0 : resultobj = SWIG_Py_Void();
4673 0 : return resultobj;
4674 : fail:
4675 : return NULL;
4676 : }
4677 :
4678 :
4679 0 : SWIGINTERN PyObject *_wrap_gpgme_err_make_from_errno(PyObject *self, PyObject *args) {
4680 0 : PyObject *resultobj = 0;
4681 : gpgme_err_source_t arg1 ;
4682 : int arg2 ;
4683 : int val2 ;
4684 0 : int ecode2 = 0 ;
4685 0 : PyObject * obj0 = 0 ;
4686 0 : PyObject * obj1 = 0 ;
4687 : gpgme_error_t result;
4688 :
4689 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_err_make_from_errno",&obj0,&obj1)) SWIG_fail;
4690 : {
4691 0 : arg1 = PyLong_AsLong(obj0);
4692 : }
4693 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
4694 0 : if (!SWIG_IsOK(ecode2)) {
4695 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_err_make_from_errno" "', argument " "2"" of type '" "int""'");
4696 : }
4697 0 : arg2 = (int)(val2);
4698 0 : result = gpgme_err_make_from_errno(arg1,arg2);
4699 : {
4700 0 : resultobj = PyLong_FromLong(result);
4701 : }
4702 0 : return resultobj;
4703 : fail:
4704 : return NULL;
4705 : }
4706 :
4707 :
4708 0 : SWIGINTERN PyObject *_wrap_gpgme_error_from_errno(PyObject *self, PyObject *args) {
4709 0 : PyObject *resultobj = 0;
4710 : int arg1 ;
4711 : int val1 ;
4712 0 : int ecode1 = 0 ;
4713 0 : PyObject * obj0 = 0 ;
4714 : gpgme_error_t result;
4715 :
4716 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_error_from_errno",&obj0)) SWIG_fail;
4717 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
4718 0 : if (!SWIG_IsOK(ecode1)) {
4719 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_error_from_errno" "', argument " "1"" of type '" "int""'");
4720 : }
4721 0 : arg1 = (int)(val1);
4722 0 : result = gpgme_error_from_errno(arg1);
4723 : {
4724 0 : resultobj = PyLong_FromLong(result);
4725 : }
4726 0 : return resultobj;
4727 : fail:
4728 : return NULL;
4729 : }
4730 :
4731 :
4732 0 : SWIGINTERN PyObject *_wrap_gpgme_error_from_syserror(PyObject *self, PyObject *args) {
4733 0 : PyObject *resultobj = 0;
4734 : gpgme_error_t result;
4735 :
4736 0 : if (!PyArg_ParseTuple(args,(char *)":gpgme_error_from_syserror")) SWIG_fail;
4737 0 : result = gpgme_error_from_syserror();
4738 : {
4739 0 : resultobj = PyLong_FromLong(result);
4740 : }
4741 0 : return resultobj;
4742 : fail:
4743 : return NULL;
4744 : }
4745 :
4746 :
4747 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_protocol_set(PyObject *self, PyObject *args) {
4748 0 : PyObject *resultobj = 0;
4749 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4750 : gpgme_protocol_t arg2 ;
4751 0 : void *argp1 = 0 ;
4752 0 : int res1 = 0 ;
4753 : int val2 ;
4754 0 : int ecode2 = 0 ;
4755 0 : PyObject * obj1 = 0 ;
4756 :
4757 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_protocol_set",&obj1)) SWIG_fail;
4758 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4759 0 : if (!SWIG_IsOK(res1)) {
4760 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_protocol_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4761 : }
4762 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4763 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
4764 0 : if (!SWIG_IsOK(ecode2)) {
4765 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_engine_info_protocol_set" "', argument " "2"" of type '" "gpgme_protocol_t""'");
4766 : }
4767 0 : arg2 = (gpgme_protocol_t)(val2);
4768 0 : if (arg1) (arg1)->protocol = arg2;
4769 0 : resultobj = SWIG_Py_Void();
4770 0 : return resultobj;
4771 : fail:
4772 : return NULL;
4773 : }
4774 :
4775 :
4776 6 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_protocol_get(PyObject *self, PyObject *args) {
4777 6 : PyObject *resultobj = 0;
4778 6 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4779 6 : void *argp1 = 0 ;
4780 6 : int res1 = 0 ;
4781 : gpgme_protocol_t result;
4782 :
4783 6 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
4784 6 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4785 6 : if (!SWIG_IsOK(res1)) {
4786 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_protocol_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4787 : }
4788 6 : arg1 = (struct _gpgme_engine_info *)(argp1);
4789 6 : result = (gpgme_protocol_t) ((arg1)->protocol);
4790 12 : resultobj = SWIG_From_int((int)(result));
4791 6 : return resultobj;
4792 : fail:
4793 : return NULL;
4794 : }
4795 :
4796 :
4797 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_file_name_set(PyObject *self, PyObject *args) {
4798 0 : PyObject *resultobj = 0;
4799 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4800 0 : char *arg2 = (char *) 0 ;
4801 0 : void *argp1 = 0 ;
4802 0 : int res1 = 0 ;
4803 : int res2 ;
4804 0 : char *buf2 = 0 ;
4805 0 : int alloc2 = 0 ;
4806 0 : PyObject * obj1 = 0 ;
4807 :
4808 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_file_name_set",&obj1)) SWIG_fail;
4809 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4810 0 : if (!SWIG_IsOK(res1)) {
4811 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_file_name_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4812 : }
4813 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4814 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4815 0 : if (!SWIG_IsOK(res2)) {
4816 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_engine_info_file_name_set" "', argument " "2"" of type '" "char *""'");
4817 : }
4818 0 : arg2 = (char *)(buf2);
4819 0 : if (arg1->file_name) free((char*)arg1->file_name);
4820 0 : if (arg2) {
4821 0 : size_t size = strlen((const char *)(arg2)) + 1;
4822 0 : arg1->file_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4823 : } else {
4824 0 : arg1->file_name = 0;
4825 : }
4826 0 : resultobj = SWIG_Py_Void();
4827 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4828 : return resultobj;
4829 : fail:
4830 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4831 : return NULL;
4832 : }
4833 :
4834 :
4835 6 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_file_name_get(PyObject *self, PyObject *args) {
4836 6 : PyObject *resultobj = 0;
4837 6 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4838 6 : void *argp1 = 0 ;
4839 6 : int res1 = 0 ;
4840 6 : char *result = 0 ;
4841 :
4842 6 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
4843 6 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4844 6 : if (!SWIG_IsOK(res1)) {
4845 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_file_name_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4846 : }
4847 6 : arg1 = (struct _gpgme_engine_info *)(argp1);
4848 6 : result = (char *) ((arg1)->file_name);
4849 6 : resultobj = SWIG_FromCharPtr((const char *)result);
4850 6 : return resultobj;
4851 : fail:
4852 : return NULL;
4853 : }
4854 :
4855 :
4856 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_version_set(PyObject *self, PyObject *args) {
4857 0 : PyObject *resultobj = 0;
4858 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4859 0 : char *arg2 = (char *) 0 ;
4860 0 : void *argp1 = 0 ;
4861 0 : int res1 = 0 ;
4862 : int res2 ;
4863 0 : char *buf2 = 0 ;
4864 0 : int alloc2 = 0 ;
4865 0 : PyObject * obj1 = 0 ;
4866 :
4867 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_version_set",&obj1)) SWIG_fail;
4868 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4869 0 : if (!SWIG_IsOK(res1)) {
4870 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_version_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4871 : }
4872 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4873 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4874 0 : if (!SWIG_IsOK(res2)) {
4875 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_engine_info_version_set" "', argument " "2"" of type '" "char *""'");
4876 : }
4877 0 : arg2 = (char *)(buf2);
4878 0 : if (arg1->version) free((char*)arg1->version);
4879 0 : if (arg2) {
4880 0 : size_t size = strlen((const char *)(arg2)) + 1;
4881 0 : arg1->version = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4882 : } else {
4883 0 : arg1->version = 0;
4884 : }
4885 0 : resultobj = SWIG_Py_Void();
4886 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4887 : return resultobj;
4888 : fail:
4889 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4890 : return NULL;
4891 : }
4892 :
4893 :
4894 6 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_version_get(PyObject *self, PyObject *args) {
4895 6 : PyObject *resultobj = 0;
4896 6 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4897 6 : void *argp1 = 0 ;
4898 6 : int res1 = 0 ;
4899 6 : char *result = 0 ;
4900 :
4901 6 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
4902 6 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4903 6 : if (!SWIG_IsOK(res1)) {
4904 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_version_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4905 : }
4906 6 : arg1 = (struct _gpgme_engine_info *)(argp1);
4907 6 : result = (char *) ((arg1)->version);
4908 6 : resultobj = SWIG_FromCharPtr((const char *)result);
4909 6 : return resultobj;
4910 : fail:
4911 : return NULL;
4912 : }
4913 :
4914 :
4915 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_req_version_set(PyObject *self, PyObject *args) {
4916 0 : PyObject *resultobj = 0;
4917 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4918 0 : char *arg2 = (char *) 0 ;
4919 0 : void *argp1 = 0 ;
4920 0 : int res1 = 0 ;
4921 0 : PyObject * obj1 = 0 ;
4922 :
4923 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_req_version_set",&obj1)) SWIG_fail;
4924 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4925 0 : if (!SWIG_IsOK(res1)) {
4926 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_req_version_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4927 : }
4928 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4929 : {
4930 0 : if (obj1 == Py_None)
4931 : arg2 = NULL;
4932 0 : else if (PyUnicode_Check(obj1))
4933 0 : arg2 = PyUnicode_AsUTF8(obj1);
4934 0 : else if (PyBytes_Check(obj1))
4935 0 : arg2 = PyBytes_AsString(obj1);
4936 : else {
4937 0 : PyErr_Format(PyExc_TypeError,
4938 : "arg %d: expected str, bytes, or None, got %s",
4939 : 2, obj1->ob_type->tp_name);
4940 0 : return NULL;
4941 : }
4942 : }
4943 0 : if (arg2) {
4944 0 : size_t size = strlen((const char *)((const char *)(arg2))) + 1;
4945 0 : arg1->req_version = (char const *)(char *)memcpy((char *)malloc((size)*sizeof(char)), arg2, sizeof(char)*(size));
4946 : } else {
4947 0 : arg1->req_version = 0;
4948 : }
4949 0 : resultobj = SWIG_Py_Void();
4950 0 : return resultobj;
4951 : fail:
4952 : return NULL;
4953 : }
4954 :
4955 :
4956 6 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_req_version_get(PyObject *self, PyObject *args) {
4957 6 : PyObject *resultobj = 0;
4958 6 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4959 6 : void *argp1 = 0 ;
4960 6 : int res1 = 0 ;
4961 6 : char *result = 0 ;
4962 :
4963 6 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
4964 6 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4965 6 : if (!SWIG_IsOK(res1)) {
4966 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_req_version_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4967 : }
4968 6 : arg1 = (struct _gpgme_engine_info *)(argp1);
4969 6 : result = (char *) ((arg1)->req_version);
4970 6 : resultobj = SWIG_FromCharPtr((const char *)result);
4971 6 : return resultobj;
4972 : fail:
4973 : return NULL;
4974 : }
4975 :
4976 :
4977 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_home_dir_set(PyObject *self, PyObject *args) {
4978 0 : PyObject *resultobj = 0;
4979 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4980 0 : char *arg2 = (char *) 0 ;
4981 0 : void *argp1 = 0 ;
4982 0 : int res1 = 0 ;
4983 : int res2 ;
4984 0 : char *buf2 = 0 ;
4985 0 : int alloc2 = 0 ;
4986 0 : PyObject * obj1 = 0 ;
4987 :
4988 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_home_dir_set",&obj1)) SWIG_fail;
4989 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4990 0 : if (!SWIG_IsOK(res1)) {
4991 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_home_dir_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4992 : }
4993 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4994 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4995 0 : if (!SWIG_IsOK(res2)) {
4996 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_engine_info_home_dir_set" "', argument " "2"" of type '" "char *""'");
4997 : }
4998 0 : arg2 = (char *)(buf2);
4999 0 : if (arg1->home_dir) free((char*)arg1->home_dir);
5000 0 : if (arg2) {
5001 0 : size_t size = strlen((const char *)(arg2)) + 1;
5002 0 : arg1->home_dir = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5003 : } else {
5004 0 : arg1->home_dir = 0;
5005 : }
5006 0 : resultobj = SWIG_Py_Void();
5007 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5008 : return resultobj;
5009 : fail:
5010 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5011 : return NULL;
5012 : }
5013 :
5014 :
5015 6 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_home_dir_get(PyObject *self, PyObject *args) {
5016 6 : PyObject *resultobj = 0;
5017 6 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
5018 6 : void *argp1 = 0 ;
5019 6 : int res1 = 0 ;
5020 6 : char *result = 0 ;
5021 :
5022 6 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5023 6 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
5024 6 : if (!SWIG_IsOK(res1)) {
5025 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_home_dir_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
5026 : }
5027 6 : arg1 = (struct _gpgme_engine_info *)(argp1);
5028 6 : result = (char *) ((arg1)->home_dir);
5029 6 : resultobj = SWIG_FromCharPtr((const char *)result);
5030 6 : return resultobj;
5031 : fail:
5032 : return NULL;
5033 : }
5034 :
5035 :
5036 0 : SWIGINTERN int _wrap_new__gpgme_engine_info(PyObject *self, PyObject *args) {
5037 0 : PyObject *resultobj = 0;
5038 0 : struct _gpgme_engine_info *result = 0 ;
5039 :
5040 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5041 0 : result = (struct _gpgme_engine_info *)calloc(1, sizeof(struct _gpgme_engine_info));
5042 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_engine_info, SWIG_BUILTIN_INIT | 0 );
5043 0 : return resultobj == Py_None ? -1 : 0;
5044 : fail:
5045 : return -1;
5046 : }
5047 :
5048 :
5049 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_engine_info(PyObject *self, PyObject *args) {
5050 0 : PyObject *resultobj = 0;
5051 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
5052 0 : void *argp1 = 0 ;
5053 0 : int res1 = 0 ;
5054 :
5055 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5056 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_engine_info, SWIG_POINTER_DISOWN | 0 );
5057 0 : if (!SWIG_IsOK(res1)) {
5058 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_engine_info" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
5059 : }
5060 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
5061 0 : free((char *) arg1);
5062 0 : resultobj = SWIG_Py_Void();
5063 0 : return resultobj;
5064 : fail:
5065 : return NULL;
5066 : }
5067 :
5068 :
5069 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_validity_set(PyObject *self, PyObject *args) {
5070 0 : PyObject *resultobj = 0;
5071 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5072 : unsigned int arg2 ;
5073 0 : void *argp1 = 0 ;
5074 0 : int res1 = 0 ;
5075 : unsigned int val2 ;
5076 0 : int ecode2 = 0 ;
5077 0 : PyObject * obj1 = 0 ;
5078 :
5079 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_validity_set",&obj1)) SWIG_fail;
5080 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5081 0 : if (!SWIG_IsOK(res1)) {
5082 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_validity_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5083 : }
5084 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5085 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5086 0 : if (!SWIG_IsOK(ecode2)) {
5087 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_validity_set" "', argument " "2"" of type '" "unsigned int""'");
5088 : }
5089 0 : arg2 = (unsigned int)(val2);
5090 0 : if (arg1) (arg1)->validity = arg2;
5091 0 : resultobj = SWIG_Py_Void();
5092 0 : return resultobj;
5093 : fail:
5094 : return NULL;
5095 : }
5096 :
5097 :
5098 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_validity_get(PyObject *self, PyObject *args) {
5099 0 : PyObject *resultobj = 0;
5100 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5101 0 : void *argp1 = 0 ;
5102 0 : int res1 = 0 ;
5103 : unsigned int result;
5104 :
5105 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5106 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5107 0 : if (!SWIG_IsOK(res1)) {
5108 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_validity_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5109 : }
5110 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5111 0 : result = (unsigned int) ((arg1)->validity);
5112 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5113 0 : return resultobj;
5114 : fail:
5115 : return NULL;
5116 : }
5117 :
5118 :
5119 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_policy_set(PyObject *self, PyObject *args) {
5120 0 : PyObject *resultobj = 0;
5121 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5122 : unsigned int arg2 ;
5123 0 : void *argp1 = 0 ;
5124 0 : int res1 = 0 ;
5125 : unsigned int val2 ;
5126 0 : int ecode2 = 0 ;
5127 0 : PyObject * obj1 = 0 ;
5128 :
5129 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_policy_set",&obj1)) SWIG_fail;
5130 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5131 0 : if (!SWIG_IsOK(res1)) {
5132 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_policy_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5133 : }
5134 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5135 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5136 0 : if (!SWIG_IsOK(ecode2)) {
5137 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_policy_set" "', argument " "2"" of type '" "unsigned int""'");
5138 : }
5139 0 : arg2 = (unsigned int)(val2);
5140 0 : if (arg1) (arg1)->policy = arg2;
5141 0 : resultobj = SWIG_Py_Void();
5142 0 : return resultobj;
5143 : fail:
5144 : return NULL;
5145 : }
5146 :
5147 :
5148 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_policy_get(PyObject *self, PyObject *args) {
5149 0 : PyObject *resultobj = 0;
5150 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5151 0 : void *argp1 = 0 ;
5152 0 : int res1 = 0 ;
5153 : unsigned int result;
5154 :
5155 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5156 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5157 0 : if (!SWIG_IsOK(res1)) {
5158 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_policy_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5159 : }
5160 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5161 0 : result = (unsigned int) ((arg1)->policy);
5162 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5163 0 : return resultobj;
5164 : fail:
5165 : return NULL;
5166 : }
5167 :
5168 :
5169 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info__rfu_set(PyObject *self, PyObject *args) {
5170 0 : PyObject *resultobj = 0;
5171 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5172 : unsigned int arg2 ;
5173 0 : void *argp1 = 0 ;
5174 0 : int res1 = 0 ;
5175 : unsigned int val2 ;
5176 0 : int ecode2 = 0 ;
5177 0 : PyObject * obj1 = 0 ;
5178 :
5179 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info__rfu_set",&obj1)) SWIG_fail;
5180 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5181 0 : if (!SWIG_IsOK(res1)) {
5182 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info__rfu_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5183 : }
5184 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5185 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5186 0 : if (!SWIG_IsOK(ecode2)) {
5187 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info__rfu_set" "', argument " "2"" of type '" "unsigned int""'");
5188 : }
5189 0 : arg2 = (unsigned int)(val2);
5190 0 : if (arg1) (arg1)->_rfu = arg2;
5191 0 : resultobj = SWIG_Py_Void();
5192 0 : return resultobj;
5193 : fail:
5194 : return NULL;
5195 : }
5196 :
5197 :
5198 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info__rfu_get(PyObject *self, PyObject *args) {
5199 0 : PyObject *resultobj = 0;
5200 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5201 0 : void *argp1 = 0 ;
5202 0 : int res1 = 0 ;
5203 : unsigned int result;
5204 :
5205 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5206 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5207 0 : if (!SWIG_IsOK(res1)) {
5208 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info__rfu_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5209 : }
5210 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5211 0 : result = (unsigned int) ((arg1)->_rfu);
5212 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5213 0 : return resultobj;
5214 : fail:
5215 : return NULL;
5216 : }
5217 :
5218 :
5219 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signcount_set(PyObject *self, PyObject *args) {
5220 0 : PyObject *resultobj = 0;
5221 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5222 : unsigned short arg2 ;
5223 0 : void *argp1 = 0 ;
5224 0 : int res1 = 0 ;
5225 : unsigned short val2 ;
5226 0 : int ecode2 = 0 ;
5227 0 : PyObject * obj1 = 0 ;
5228 :
5229 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_signcount_set",&obj1)) SWIG_fail;
5230 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5231 0 : if (!SWIG_IsOK(res1)) {
5232 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signcount_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5233 : }
5234 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5235 0 : ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
5236 0 : if (!SWIG_IsOK(ecode2)) {
5237 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_signcount_set" "', argument " "2"" of type '" "unsigned short""'");
5238 : }
5239 0 : arg2 = (unsigned short)(val2);
5240 0 : if (arg1) (arg1)->signcount = arg2;
5241 0 : resultobj = SWIG_Py_Void();
5242 0 : return resultobj;
5243 : fail:
5244 : return NULL;
5245 : }
5246 :
5247 :
5248 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signcount_get(PyObject *self, PyObject *args) {
5249 0 : PyObject *resultobj = 0;
5250 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5251 0 : void *argp1 = 0 ;
5252 0 : int res1 = 0 ;
5253 : unsigned short result;
5254 :
5255 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5256 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5257 0 : if (!SWIG_IsOK(res1)) {
5258 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signcount_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5259 : }
5260 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5261 0 : result = (unsigned short) ((arg1)->signcount);
5262 0 : resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
5263 0 : return resultobj;
5264 : fail:
5265 : return NULL;
5266 : }
5267 :
5268 :
5269 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrcount_set(PyObject *self, PyObject *args) {
5270 0 : PyObject *resultobj = 0;
5271 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5272 : unsigned short arg2 ;
5273 0 : void *argp1 = 0 ;
5274 0 : int res1 = 0 ;
5275 : unsigned short val2 ;
5276 0 : int ecode2 = 0 ;
5277 0 : PyObject * obj1 = 0 ;
5278 :
5279 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_encrcount_set",&obj1)) SWIG_fail;
5280 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5281 0 : if (!SWIG_IsOK(res1)) {
5282 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrcount_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5283 : }
5284 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5285 0 : ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
5286 0 : if (!SWIG_IsOK(ecode2)) {
5287 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_encrcount_set" "', argument " "2"" of type '" "unsigned short""'");
5288 : }
5289 0 : arg2 = (unsigned short)(val2);
5290 0 : if (arg1) (arg1)->encrcount = arg2;
5291 0 : resultobj = SWIG_Py_Void();
5292 0 : return resultobj;
5293 : fail:
5294 : return NULL;
5295 : }
5296 :
5297 :
5298 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrcount_get(PyObject *self, PyObject *args) {
5299 0 : PyObject *resultobj = 0;
5300 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5301 0 : void *argp1 = 0 ;
5302 0 : int res1 = 0 ;
5303 : unsigned short result;
5304 :
5305 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5306 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5307 0 : if (!SWIG_IsOK(res1)) {
5308 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrcount_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5309 : }
5310 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5311 0 : result = (unsigned short) ((arg1)->encrcount);
5312 0 : resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
5313 0 : return resultobj;
5314 : fail:
5315 : return NULL;
5316 : }
5317 :
5318 :
5319 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signfirst_set(PyObject *self, PyObject *args) {
5320 0 : PyObject *resultobj = 0;
5321 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5322 : unsigned long arg2 ;
5323 0 : void *argp1 = 0 ;
5324 0 : int res1 = 0 ;
5325 : unsigned long val2 ;
5326 0 : int ecode2 = 0 ;
5327 0 : PyObject * obj1 = 0 ;
5328 :
5329 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_signfirst_set",&obj1)) SWIG_fail;
5330 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5331 0 : if (!SWIG_IsOK(res1)) {
5332 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signfirst_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5333 : }
5334 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5335 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5336 0 : if (!SWIG_IsOK(ecode2)) {
5337 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_signfirst_set" "', argument " "2"" of type '" "unsigned long""'");
5338 : }
5339 0 : arg2 = (unsigned long)(val2);
5340 0 : if (arg1) (arg1)->signfirst = arg2;
5341 0 : resultobj = SWIG_Py_Void();
5342 0 : return resultobj;
5343 : fail:
5344 : return NULL;
5345 : }
5346 :
5347 :
5348 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signfirst_get(PyObject *self, PyObject *args) {
5349 0 : PyObject *resultobj = 0;
5350 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5351 0 : void *argp1 = 0 ;
5352 0 : int res1 = 0 ;
5353 : unsigned long result;
5354 :
5355 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5356 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5357 0 : if (!SWIG_IsOK(res1)) {
5358 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signfirst_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5359 : }
5360 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5361 0 : result = (unsigned long) ((arg1)->signfirst);
5362 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5363 0 : return resultobj;
5364 : fail:
5365 : return NULL;
5366 : }
5367 :
5368 :
5369 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signlast_set(PyObject *self, PyObject *args) {
5370 0 : PyObject *resultobj = 0;
5371 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5372 : unsigned long arg2 ;
5373 0 : void *argp1 = 0 ;
5374 0 : int res1 = 0 ;
5375 : unsigned long val2 ;
5376 0 : int ecode2 = 0 ;
5377 0 : PyObject * obj1 = 0 ;
5378 :
5379 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_signlast_set",&obj1)) SWIG_fail;
5380 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5381 0 : if (!SWIG_IsOK(res1)) {
5382 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signlast_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5383 : }
5384 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5385 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5386 0 : if (!SWIG_IsOK(ecode2)) {
5387 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_signlast_set" "', argument " "2"" of type '" "unsigned long""'");
5388 : }
5389 0 : arg2 = (unsigned long)(val2);
5390 0 : if (arg1) (arg1)->signlast = arg2;
5391 0 : resultobj = SWIG_Py_Void();
5392 0 : return resultobj;
5393 : fail:
5394 : return NULL;
5395 : }
5396 :
5397 :
5398 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signlast_get(PyObject *self, PyObject *args) {
5399 0 : PyObject *resultobj = 0;
5400 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5401 0 : void *argp1 = 0 ;
5402 0 : int res1 = 0 ;
5403 : unsigned long result;
5404 :
5405 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5406 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5407 0 : if (!SWIG_IsOK(res1)) {
5408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signlast_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5409 : }
5410 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5411 0 : result = (unsigned long) ((arg1)->signlast);
5412 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5413 0 : return resultobj;
5414 : fail:
5415 : return NULL;
5416 : }
5417 :
5418 :
5419 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrfirst_set(PyObject *self, PyObject *args) {
5420 0 : PyObject *resultobj = 0;
5421 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5422 : unsigned long arg2 ;
5423 0 : void *argp1 = 0 ;
5424 0 : int res1 = 0 ;
5425 : unsigned long val2 ;
5426 0 : int ecode2 = 0 ;
5427 0 : PyObject * obj1 = 0 ;
5428 :
5429 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_encrfirst_set",&obj1)) SWIG_fail;
5430 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5431 0 : if (!SWIG_IsOK(res1)) {
5432 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrfirst_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5433 : }
5434 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5435 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5436 0 : if (!SWIG_IsOK(ecode2)) {
5437 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_encrfirst_set" "', argument " "2"" of type '" "unsigned long""'");
5438 : }
5439 0 : arg2 = (unsigned long)(val2);
5440 0 : if (arg1) (arg1)->encrfirst = arg2;
5441 0 : resultobj = SWIG_Py_Void();
5442 0 : return resultobj;
5443 : fail:
5444 : return NULL;
5445 : }
5446 :
5447 :
5448 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrfirst_get(PyObject *self, PyObject *args) {
5449 0 : PyObject *resultobj = 0;
5450 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5451 0 : void *argp1 = 0 ;
5452 0 : int res1 = 0 ;
5453 : unsigned long result;
5454 :
5455 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5456 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5457 0 : if (!SWIG_IsOK(res1)) {
5458 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrfirst_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5459 : }
5460 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5461 0 : result = (unsigned long) ((arg1)->encrfirst);
5462 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5463 0 : return resultobj;
5464 : fail:
5465 : return NULL;
5466 : }
5467 :
5468 :
5469 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrlast_set(PyObject *self, PyObject *args) {
5470 0 : PyObject *resultobj = 0;
5471 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5472 : unsigned long arg2 ;
5473 0 : void *argp1 = 0 ;
5474 0 : int res1 = 0 ;
5475 : unsigned long val2 ;
5476 0 : int ecode2 = 0 ;
5477 0 : PyObject * obj1 = 0 ;
5478 :
5479 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_encrlast_set",&obj1)) SWIG_fail;
5480 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5481 0 : if (!SWIG_IsOK(res1)) {
5482 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrlast_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5483 : }
5484 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5485 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5486 0 : if (!SWIG_IsOK(ecode2)) {
5487 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_encrlast_set" "', argument " "2"" of type '" "unsigned long""'");
5488 : }
5489 0 : arg2 = (unsigned long)(val2);
5490 0 : if (arg1) (arg1)->encrlast = arg2;
5491 0 : resultobj = SWIG_Py_Void();
5492 0 : return resultobj;
5493 : fail:
5494 : return NULL;
5495 : }
5496 :
5497 :
5498 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrlast_get(PyObject *self, PyObject *args) {
5499 0 : PyObject *resultobj = 0;
5500 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5501 0 : void *argp1 = 0 ;
5502 0 : int res1 = 0 ;
5503 : unsigned long result;
5504 :
5505 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5506 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5507 0 : if (!SWIG_IsOK(res1)) {
5508 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrlast_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5509 : }
5510 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5511 0 : result = (unsigned long) ((arg1)->encrlast);
5512 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5513 0 : return resultobj;
5514 : fail:
5515 : return NULL;
5516 : }
5517 :
5518 :
5519 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_description_set(PyObject *self, PyObject *args) {
5520 0 : PyObject *resultobj = 0;
5521 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5522 0 : char *arg2 = (char *) 0 ;
5523 0 : void *argp1 = 0 ;
5524 0 : int res1 = 0 ;
5525 : int res2 ;
5526 0 : char *buf2 = 0 ;
5527 0 : int alloc2 = 0 ;
5528 0 : PyObject * obj1 = 0 ;
5529 :
5530 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_description_set",&obj1)) SWIG_fail;
5531 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5532 0 : if (!SWIG_IsOK(res1)) {
5533 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_description_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5534 : }
5535 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5536 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5537 0 : if (!SWIG_IsOK(res2)) {
5538 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_tofu_info_description_set" "', argument " "2"" of type '" "char *""'");
5539 : }
5540 0 : arg2 = (char *)(buf2);
5541 0 : if (arg1->description) free((char*)arg1->description);
5542 0 : if (arg2) {
5543 0 : size_t size = strlen((const char *)(arg2)) + 1;
5544 0 : arg1->description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5545 : } else {
5546 0 : arg1->description = 0;
5547 : }
5548 0 : resultobj = SWIG_Py_Void();
5549 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5550 : return resultobj;
5551 : fail:
5552 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5553 : return NULL;
5554 : }
5555 :
5556 :
5557 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_description_get(PyObject *self, PyObject *args) {
5558 0 : PyObject *resultobj = 0;
5559 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5560 0 : void *argp1 = 0 ;
5561 0 : int res1 = 0 ;
5562 0 : char *result = 0 ;
5563 :
5564 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5565 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5566 0 : if (!SWIG_IsOK(res1)) {
5567 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_description_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5568 : }
5569 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5570 0 : result = (char *) ((arg1)->description);
5571 0 : resultobj = SWIG_FromCharPtr((const char *)result);
5572 0 : return resultobj;
5573 : fail:
5574 : return NULL;
5575 : }
5576 :
5577 :
5578 0 : SWIGINTERN int _wrap_new__gpgme_tofu_info(PyObject *self, PyObject *args) {
5579 0 : PyObject *resultobj = 0;
5580 0 : struct _gpgme_tofu_info *result = 0 ;
5581 :
5582 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5583 0 : result = (struct _gpgme_tofu_info *)calloc(1, sizeof(struct _gpgme_tofu_info));
5584 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_tofu_info, SWIG_BUILTIN_INIT | 0 );
5585 0 : return resultobj == Py_None ? -1 : 0;
5586 : fail:
5587 : return -1;
5588 : }
5589 :
5590 :
5591 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_tofu_info(PyObject *self, PyObject *args) {
5592 0 : PyObject *resultobj = 0;
5593 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5594 0 : void *argp1 = 0 ;
5595 0 : int res1 = 0 ;
5596 :
5597 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5598 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_tofu_info, SWIG_POINTER_DISOWN | 0 );
5599 0 : if (!SWIG_IsOK(res1)) {
5600 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_tofu_info" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5601 : }
5602 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5603 0 : free((char *) arg1);
5604 0 : resultobj = SWIG_Py_Void();
5605 0 : return resultobj;
5606 : fail:
5607 : return NULL;
5608 : }
5609 :
5610 :
5611 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_revoked_set(PyObject *self, PyObject *args) {
5612 0 : PyObject *resultobj = 0;
5613 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5614 : unsigned int arg2 ;
5615 0 : void *argp1 = 0 ;
5616 0 : int res1 = 0 ;
5617 : unsigned int val2 ;
5618 0 : int ecode2 = 0 ;
5619 0 : PyObject * obj1 = 0 ;
5620 :
5621 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_revoked_set",&obj1)) SWIG_fail;
5622 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5623 0 : if (!SWIG_IsOK(res1)) {
5624 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_revoked_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5625 : }
5626 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5627 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5628 0 : if (!SWIG_IsOK(ecode2)) {
5629 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
5630 : }
5631 0 : arg2 = (unsigned int)(val2);
5632 0 : if (arg1) (arg1)->revoked = arg2;
5633 0 : resultobj = SWIG_Py_Void();
5634 0 : return resultobj;
5635 : fail:
5636 : return NULL;
5637 : }
5638 :
5639 :
5640 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_revoked_get(PyObject *self, PyObject *args) {
5641 104 : PyObject *resultobj = 0;
5642 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5643 104 : void *argp1 = 0 ;
5644 104 : int res1 = 0 ;
5645 : unsigned int result;
5646 :
5647 104 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5648 104 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5649 104 : if (!SWIG_IsOK(res1)) {
5650 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_revoked_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5651 : }
5652 104 : arg1 = (struct _gpgme_subkey *)(argp1);
5653 104 : result = (unsigned int) ((arg1)->revoked);
5654 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5655 104 : return resultobj;
5656 : fail:
5657 : return NULL;
5658 : }
5659 :
5660 :
5661 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expired_set(PyObject *self, PyObject *args) {
5662 0 : PyObject *resultobj = 0;
5663 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5664 : unsigned int arg2 ;
5665 0 : void *argp1 = 0 ;
5666 0 : int res1 = 0 ;
5667 : unsigned int val2 ;
5668 0 : int ecode2 = 0 ;
5669 0 : PyObject * obj1 = 0 ;
5670 :
5671 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_expired_set",&obj1)) SWIG_fail;
5672 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5673 0 : if (!SWIG_IsOK(res1)) {
5674 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expired_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5675 : }
5676 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5677 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5678 0 : if (!SWIG_IsOK(ecode2)) {
5679 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_expired_set" "', argument " "2"" of type '" "unsigned int""'");
5680 : }
5681 0 : arg2 = (unsigned int)(val2);
5682 0 : if (arg1) (arg1)->expired = arg2;
5683 0 : resultobj = SWIG_Py_Void();
5684 0 : return resultobj;
5685 : fail:
5686 : return NULL;
5687 : }
5688 :
5689 :
5690 108 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expired_get(PyObject *self, PyObject *args) {
5691 108 : PyObject *resultobj = 0;
5692 108 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5693 108 : void *argp1 = 0 ;
5694 108 : int res1 = 0 ;
5695 : unsigned int result;
5696 :
5697 108 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5698 108 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5699 108 : if (!SWIG_IsOK(res1)) {
5700 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expired_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5701 : }
5702 108 : arg1 = (struct _gpgme_subkey *)(argp1);
5703 108 : result = (unsigned int) ((arg1)->expired);
5704 108 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5705 108 : return resultobj;
5706 : fail:
5707 : return NULL;
5708 : }
5709 :
5710 :
5711 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_disabled_set(PyObject *self, PyObject *args) {
5712 0 : PyObject *resultobj = 0;
5713 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5714 : unsigned int arg2 ;
5715 0 : void *argp1 = 0 ;
5716 0 : int res1 = 0 ;
5717 : unsigned int val2 ;
5718 0 : int ecode2 = 0 ;
5719 0 : PyObject * obj1 = 0 ;
5720 :
5721 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_disabled_set",&obj1)) SWIG_fail;
5722 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5723 0 : if (!SWIG_IsOK(res1)) {
5724 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_disabled_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5725 : }
5726 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5727 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5728 0 : if (!SWIG_IsOK(ecode2)) {
5729 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_disabled_set" "', argument " "2"" of type '" "unsigned int""'");
5730 : }
5731 0 : arg2 = (unsigned int)(val2);
5732 0 : if (arg1) (arg1)->disabled = arg2;
5733 0 : resultobj = SWIG_Py_Void();
5734 0 : return resultobj;
5735 : fail:
5736 : return NULL;
5737 : }
5738 :
5739 :
5740 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_disabled_get(PyObject *self, PyObject *args) {
5741 104 : PyObject *resultobj = 0;
5742 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5743 104 : void *argp1 = 0 ;
5744 104 : int res1 = 0 ;
5745 : unsigned int result;
5746 :
5747 104 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5748 104 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5749 104 : if (!SWIG_IsOK(res1)) {
5750 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_disabled_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5751 : }
5752 104 : arg1 = (struct _gpgme_subkey *)(argp1);
5753 104 : result = (unsigned int) ((arg1)->disabled);
5754 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5755 104 : return resultobj;
5756 : fail:
5757 : return NULL;
5758 : }
5759 :
5760 :
5761 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_invalid_set(PyObject *self, PyObject *args) {
5762 0 : PyObject *resultobj = 0;
5763 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5764 : unsigned int arg2 ;
5765 0 : void *argp1 = 0 ;
5766 0 : int res1 = 0 ;
5767 : unsigned int val2 ;
5768 0 : int ecode2 = 0 ;
5769 0 : PyObject * obj1 = 0 ;
5770 :
5771 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_invalid_set",&obj1)) SWIG_fail;
5772 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5773 0 : if (!SWIG_IsOK(res1)) {
5774 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_invalid_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5775 : }
5776 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5777 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5778 0 : if (!SWIG_IsOK(ecode2)) {
5779 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
5780 : }
5781 0 : arg2 = (unsigned int)(val2);
5782 0 : if (arg1) (arg1)->invalid = arg2;
5783 0 : resultobj = SWIG_Py_Void();
5784 0 : return resultobj;
5785 : fail:
5786 : return NULL;
5787 : }
5788 :
5789 :
5790 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_invalid_get(PyObject *self, PyObject *args) {
5791 104 : PyObject *resultobj = 0;
5792 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5793 104 : void *argp1 = 0 ;
5794 104 : int res1 = 0 ;
5795 : unsigned int result;
5796 :
5797 104 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5798 104 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5799 104 : if (!SWIG_IsOK(res1)) {
5800 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_invalid_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5801 : }
5802 104 : arg1 = (struct _gpgme_subkey *)(argp1);
5803 104 : result = (unsigned int) ((arg1)->invalid);
5804 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5805 104 : return resultobj;
5806 : fail:
5807 : return NULL;
5808 : }
5809 :
5810 :
5811 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_encrypt_set(PyObject *self, PyObject *args) {
5812 0 : PyObject *resultobj = 0;
5813 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5814 : unsigned int arg2 ;
5815 0 : void *argp1 = 0 ;
5816 0 : int res1 = 0 ;
5817 : unsigned int val2 ;
5818 0 : int ecode2 = 0 ;
5819 0 : PyObject * obj1 = 0 ;
5820 :
5821 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_encrypt_set",&obj1)) SWIG_fail;
5822 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5823 0 : if (!SWIG_IsOK(res1)) {
5824 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_encrypt_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5825 : }
5826 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5827 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5828 0 : if (!SWIG_IsOK(ecode2)) {
5829 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_encrypt_set" "', argument " "2"" of type '" "unsigned int""'");
5830 : }
5831 0 : arg2 = (unsigned int)(val2);
5832 0 : if (arg1) (arg1)->can_encrypt = arg2;
5833 0 : resultobj = SWIG_Py_Void();
5834 0 : return resultobj;
5835 : fail:
5836 : return NULL;
5837 : }
5838 :
5839 :
5840 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_encrypt_get(PyObject *self, PyObject *args) {
5841 104 : PyObject *resultobj = 0;
5842 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5843 104 : void *argp1 = 0 ;
5844 104 : int res1 = 0 ;
5845 : unsigned int result;
5846 :
5847 104 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5848 104 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5849 104 : if (!SWIG_IsOK(res1)) {
5850 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_encrypt_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5851 : }
5852 104 : arg1 = (struct _gpgme_subkey *)(argp1);
5853 104 : result = (unsigned int) ((arg1)->can_encrypt);
5854 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5855 104 : return resultobj;
5856 : fail:
5857 : return NULL;
5858 : }
5859 :
5860 :
5861 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_sign_set(PyObject *self, PyObject *args) {
5862 0 : PyObject *resultobj = 0;
5863 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5864 : unsigned int arg2 ;
5865 0 : void *argp1 = 0 ;
5866 0 : int res1 = 0 ;
5867 : unsigned int val2 ;
5868 0 : int ecode2 = 0 ;
5869 0 : PyObject * obj1 = 0 ;
5870 :
5871 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_sign_set",&obj1)) SWIG_fail;
5872 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5873 0 : if (!SWIG_IsOK(res1)) {
5874 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_sign_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5875 : }
5876 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5877 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5878 0 : if (!SWIG_IsOK(ecode2)) {
5879 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_sign_set" "', argument " "2"" of type '" "unsigned int""'");
5880 : }
5881 0 : arg2 = (unsigned int)(val2);
5882 0 : if (arg1) (arg1)->can_sign = arg2;
5883 0 : resultobj = SWIG_Py_Void();
5884 0 : return resultobj;
5885 : fail:
5886 : return NULL;
5887 : }
5888 :
5889 :
5890 112 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_sign_get(PyObject *self, PyObject *args) {
5891 112 : PyObject *resultobj = 0;
5892 112 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5893 112 : void *argp1 = 0 ;
5894 112 : int res1 = 0 ;
5895 : unsigned int result;
5896 :
5897 112 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5898 112 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5899 112 : if (!SWIG_IsOK(res1)) {
5900 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_sign_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5901 : }
5902 112 : arg1 = (struct _gpgme_subkey *)(argp1);
5903 112 : result = (unsigned int) ((arg1)->can_sign);
5904 112 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5905 112 : return resultobj;
5906 : fail:
5907 : return NULL;
5908 : }
5909 :
5910 :
5911 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_certify_set(PyObject *self, PyObject *args) {
5912 0 : PyObject *resultobj = 0;
5913 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5914 : unsigned int arg2 ;
5915 0 : void *argp1 = 0 ;
5916 0 : int res1 = 0 ;
5917 : unsigned int val2 ;
5918 0 : int ecode2 = 0 ;
5919 0 : PyObject * obj1 = 0 ;
5920 :
5921 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_certify_set",&obj1)) SWIG_fail;
5922 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5923 0 : if (!SWIG_IsOK(res1)) {
5924 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_certify_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5925 : }
5926 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5927 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5928 0 : if (!SWIG_IsOK(ecode2)) {
5929 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_certify_set" "', argument " "2"" of type '" "unsigned int""'");
5930 : }
5931 0 : arg2 = (unsigned int)(val2);
5932 0 : if (arg1) (arg1)->can_certify = arg2;
5933 0 : resultobj = SWIG_Py_Void();
5934 0 : return resultobj;
5935 : fail:
5936 : return NULL;
5937 : }
5938 :
5939 :
5940 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_certify_get(PyObject *self, PyObject *args) {
5941 104 : PyObject *resultobj = 0;
5942 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5943 104 : void *argp1 = 0 ;
5944 104 : int res1 = 0 ;
5945 : unsigned int result;
5946 :
5947 104 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5948 104 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5949 104 : if (!SWIG_IsOK(res1)) {
5950 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_certify_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5951 : }
5952 104 : arg1 = (struct _gpgme_subkey *)(argp1);
5953 104 : result = (unsigned int) ((arg1)->can_certify);
5954 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5955 104 : return resultobj;
5956 : fail:
5957 : return NULL;
5958 : }
5959 :
5960 :
5961 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_secret_set(PyObject *self, PyObject *args) {
5962 0 : PyObject *resultobj = 0;
5963 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5964 : unsigned int arg2 ;
5965 0 : void *argp1 = 0 ;
5966 0 : int res1 = 0 ;
5967 : unsigned int val2 ;
5968 0 : int ecode2 = 0 ;
5969 0 : PyObject * obj1 = 0 ;
5970 :
5971 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_secret_set",&obj1)) SWIG_fail;
5972 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5973 0 : if (!SWIG_IsOK(res1)) {
5974 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_secret_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5975 : }
5976 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5977 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5978 0 : if (!SWIG_IsOK(ecode2)) {
5979 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_secret_set" "', argument " "2"" of type '" "unsigned int""'");
5980 : }
5981 0 : arg2 = (unsigned int)(val2);
5982 0 : if (arg1) (arg1)->secret = arg2;
5983 0 : resultobj = SWIG_Py_Void();
5984 0 : return resultobj;
5985 : fail:
5986 : return NULL;
5987 : }
5988 :
5989 :
5990 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_secret_get(PyObject *self, PyObject *args) {
5991 104 : PyObject *resultobj = 0;
5992 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5993 104 : void *argp1 = 0 ;
5994 104 : int res1 = 0 ;
5995 : unsigned int result;
5996 :
5997 104 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
5998 104 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5999 104 : if (!SWIG_IsOK(res1)) {
6000 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_secret_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6001 : }
6002 104 : arg1 = (struct _gpgme_subkey *)(argp1);
6003 104 : result = (unsigned int) ((arg1)->secret);
6004 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6005 104 : return resultobj;
6006 : fail:
6007 : return NULL;
6008 : }
6009 :
6010 :
6011 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_authenticate_set(PyObject *self, PyObject *args) {
6012 0 : PyObject *resultobj = 0;
6013 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6014 : unsigned int arg2 ;
6015 0 : void *argp1 = 0 ;
6016 0 : int res1 = 0 ;
6017 : unsigned int val2 ;
6018 0 : int ecode2 = 0 ;
6019 0 : PyObject * obj1 = 0 ;
6020 :
6021 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_authenticate_set",&obj1)) SWIG_fail;
6022 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6023 0 : if (!SWIG_IsOK(res1)) {
6024 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_authenticate_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6025 : }
6026 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6027 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6028 0 : if (!SWIG_IsOK(ecode2)) {
6029 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_authenticate_set" "', argument " "2"" of type '" "unsigned int""'");
6030 : }
6031 0 : arg2 = (unsigned int)(val2);
6032 0 : if (arg1) (arg1)->can_authenticate = arg2;
6033 0 : resultobj = SWIG_Py_Void();
6034 0 : return resultobj;
6035 : fail:
6036 : return NULL;
6037 : }
6038 :
6039 :
6040 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_authenticate_get(PyObject *self, PyObject *args) {
6041 0 : PyObject *resultobj = 0;
6042 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6043 0 : void *argp1 = 0 ;
6044 0 : int res1 = 0 ;
6045 : unsigned int result;
6046 :
6047 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6048 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6049 0 : if (!SWIG_IsOK(res1)) {
6050 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_authenticate_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6051 : }
6052 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6053 0 : result = (unsigned int) ((arg1)->can_authenticate);
6054 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6055 0 : return resultobj;
6056 : fail:
6057 : return NULL;
6058 : }
6059 :
6060 :
6061 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_qualified_set(PyObject *self, PyObject *args) {
6062 0 : PyObject *resultobj = 0;
6063 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6064 : unsigned int arg2 ;
6065 0 : void *argp1 = 0 ;
6066 0 : int res1 = 0 ;
6067 : unsigned int val2 ;
6068 0 : int ecode2 = 0 ;
6069 0 : PyObject * obj1 = 0 ;
6070 :
6071 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_is_qualified_set",&obj1)) SWIG_fail;
6072 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6073 0 : if (!SWIG_IsOK(res1)) {
6074 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_qualified_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6075 : }
6076 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6077 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6078 0 : if (!SWIG_IsOK(ecode2)) {
6079 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_is_qualified_set" "', argument " "2"" of type '" "unsigned int""'");
6080 : }
6081 0 : arg2 = (unsigned int)(val2);
6082 0 : if (arg1) (arg1)->is_qualified = arg2;
6083 0 : resultobj = SWIG_Py_Void();
6084 0 : return resultobj;
6085 : fail:
6086 : return NULL;
6087 : }
6088 :
6089 :
6090 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_qualified_get(PyObject *self, PyObject *args) {
6091 0 : PyObject *resultobj = 0;
6092 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6093 0 : void *argp1 = 0 ;
6094 0 : int res1 = 0 ;
6095 : unsigned int result;
6096 :
6097 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6098 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6099 0 : if (!SWIG_IsOK(res1)) {
6100 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_qualified_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6101 : }
6102 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6103 0 : result = (unsigned int) ((arg1)->is_qualified);
6104 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6105 0 : return resultobj;
6106 : fail:
6107 : return NULL;
6108 : }
6109 :
6110 :
6111 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_cardkey_set(PyObject *self, PyObject *args) {
6112 0 : PyObject *resultobj = 0;
6113 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6114 : unsigned int arg2 ;
6115 0 : void *argp1 = 0 ;
6116 0 : int res1 = 0 ;
6117 : unsigned int val2 ;
6118 0 : int ecode2 = 0 ;
6119 0 : PyObject * obj1 = 0 ;
6120 :
6121 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_is_cardkey_set",&obj1)) SWIG_fail;
6122 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6123 0 : if (!SWIG_IsOK(res1)) {
6124 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_cardkey_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6125 : }
6126 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6127 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6128 0 : if (!SWIG_IsOK(ecode2)) {
6129 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_is_cardkey_set" "', argument " "2"" of type '" "unsigned int""'");
6130 : }
6131 0 : arg2 = (unsigned int)(val2);
6132 0 : if (arg1) (arg1)->is_cardkey = arg2;
6133 0 : resultobj = SWIG_Py_Void();
6134 0 : return resultobj;
6135 : fail:
6136 : return NULL;
6137 : }
6138 :
6139 :
6140 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_cardkey_get(PyObject *self, PyObject *args) {
6141 104 : PyObject *resultobj = 0;
6142 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6143 104 : void *argp1 = 0 ;
6144 104 : int res1 = 0 ;
6145 : unsigned int result;
6146 :
6147 104 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6148 104 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6149 104 : if (!SWIG_IsOK(res1)) {
6150 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_cardkey_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6151 : }
6152 104 : arg1 = (struct _gpgme_subkey *)(argp1);
6153 104 : result = (unsigned int) ((arg1)->is_cardkey);
6154 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6155 104 : return resultobj;
6156 : fail:
6157 : return NULL;
6158 : }
6159 :
6160 :
6161 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__unused_set(PyObject *self, PyObject *args) {
6162 0 : PyObject *resultobj = 0;
6163 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6164 : unsigned int arg2 ;
6165 0 : void *argp1 = 0 ;
6166 0 : int res1 = 0 ;
6167 : unsigned int val2 ;
6168 0 : int ecode2 = 0 ;
6169 0 : PyObject * obj1 = 0 ;
6170 :
6171 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey__unused_set",&obj1)) SWIG_fail;
6172 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6173 0 : if (!SWIG_IsOK(res1)) {
6174 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__unused_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6175 : }
6176 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6177 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6178 0 : if (!SWIG_IsOK(ecode2)) {
6179 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey__unused_set" "', argument " "2"" of type '" "unsigned int""'");
6180 : }
6181 0 : arg2 = (unsigned int)(val2);
6182 0 : if (arg1) (arg1)->_unused = arg2;
6183 0 : resultobj = SWIG_Py_Void();
6184 0 : return resultobj;
6185 : fail:
6186 : return NULL;
6187 : }
6188 :
6189 :
6190 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__unused_get(PyObject *self, PyObject *args) {
6191 0 : PyObject *resultobj = 0;
6192 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6193 0 : void *argp1 = 0 ;
6194 0 : int res1 = 0 ;
6195 : unsigned int result;
6196 :
6197 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6198 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6199 0 : if (!SWIG_IsOK(res1)) {
6200 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__unused_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6201 : }
6202 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6203 0 : result = (unsigned int) ((arg1)->_unused);
6204 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6205 0 : return resultobj;
6206 : fail:
6207 : return NULL;
6208 : }
6209 :
6210 :
6211 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_pubkey_algo_set(PyObject *self, PyObject *args) {
6212 0 : PyObject *resultobj = 0;
6213 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6214 : gpgme_pubkey_algo_t arg2 ;
6215 0 : void *argp1 = 0 ;
6216 0 : int res1 = 0 ;
6217 : int val2 ;
6218 0 : int ecode2 = 0 ;
6219 0 : PyObject * obj1 = 0 ;
6220 :
6221 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_pubkey_algo_set",&obj1)) SWIG_fail;
6222 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6223 0 : if (!SWIG_IsOK(res1)) {
6224 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6225 : }
6226 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6227 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
6228 0 : if (!SWIG_IsOK(ecode2)) {
6229 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
6230 : }
6231 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
6232 0 : if (arg1) (arg1)->pubkey_algo = arg2;
6233 0 : resultobj = SWIG_Py_Void();
6234 0 : return resultobj;
6235 : fail:
6236 : return NULL;
6237 : }
6238 :
6239 :
6240 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_pubkey_algo_get(PyObject *self, PyObject *args) {
6241 104 : PyObject *resultobj = 0;
6242 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6243 104 : void *argp1 = 0 ;
6244 104 : int res1 = 0 ;
6245 : gpgme_pubkey_algo_t result;
6246 :
6247 104 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6248 104 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6249 104 : if (!SWIG_IsOK(res1)) {
6250 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6251 : }
6252 104 : arg1 = (struct _gpgme_subkey *)(argp1);
6253 104 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
6254 208 : resultobj = SWIG_From_int((int)(result));
6255 104 : return resultobj;
6256 : fail:
6257 : return NULL;
6258 : }
6259 :
6260 :
6261 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_length_set(PyObject *self, PyObject *args) {
6262 0 : PyObject *resultobj = 0;
6263 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6264 : unsigned int arg2 ;
6265 0 : void *argp1 = 0 ;
6266 0 : int res1 = 0 ;
6267 : unsigned int val2 ;
6268 0 : int ecode2 = 0 ;
6269 0 : PyObject * obj1 = 0 ;
6270 :
6271 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_length_set",&obj1)) SWIG_fail;
6272 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6273 0 : if (!SWIG_IsOK(res1)) {
6274 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_length_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6275 : }
6276 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6277 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6278 0 : if (!SWIG_IsOK(ecode2)) {
6279 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_length_set" "', argument " "2"" of type '" "unsigned int""'");
6280 : }
6281 0 : arg2 = (unsigned int)(val2);
6282 0 : if (arg1) (arg1)->length = arg2;
6283 0 : resultobj = SWIG_Py_Void();
6284 0 : return resultobj;
6285 : fail:
6286 : return NULL;
6287 : }
6288 :
6289 :
6290 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_length_get(PyObject *self, PyObject *args) {
6291 104 : PyObject *resultobj = 0;
6292 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6293 104 : void *argp1 = 0 ;
6294 104 : int res1 = 0 ;
6295 : unsigned int result;
6296 :
6297 104 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6298 104 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6299 104 : if (!SWIG_IsOK(res1)) {
6300 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_length_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6301 : }
6302 104 : arg1 = (struct _gpgme_subkey *)(argp1);
6303 104 : result = (unsigned int) ((arg1)->length);
6304 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6305 104 : return resultobj;
6306 : fail:
6307 : return NULL;
6308 : }
6309 :
6310 :
6311 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keyid_set(PyObject *self, PyObject *args) {
6312 0 : PyObject *resultobj = 0;
6313 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6314 0 : char *arg2 = (char *) 0 ;
6315 0 : void *argp1 = 0 ;
6316 0 : int res1 = 0 ;
6317 : int res2 ;
6318 0 : char *buf2 = 0 ;
6319 0 : int alloc2 = 0 ;
6320 0 : PyObject * obj1 = 0 ;
6321 :
6322 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_keyid_set",&obj1)) SWIG_fail;
6323 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6324 0 : if (!SWIG_IsOK(res1)) {
6325 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keyid_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6326 : }
6327 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6328 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6329 0 : if (!SWIG_IsOK(res2)) {
6330 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_keyid_set" "', argument " "2"" of type '" "char *""'");
6331 : }
6332 0 : arg2 = (char *)(buf2);
6333 0 : if (arg1->keyid) free((char*)arg1->keyid);
6334 0 : if (arg2) {
6335 0 : size_t size = strlen((const char *)(arg2)) + 1;
6336 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
6337 : } else {
6338 0 : arg1->keyid = 0;
6339 : }
6340 0 : resultobj = SWIG_Py_Void();
6341 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6342 : return resultobj;
6343 : fail:
6344 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6345 : return NULL;
6346 : }
6347 :
6348 :
6349 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keyid_get(PyObject *self, PyObject *args) {
6350 104 : PyObject *resultobj = 0;
6351 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6352 104 : void *argp1 = 0 ;
6353 104 : int res1 = 0 ;
6354 104 : char *result = 0 ;
6355 :
6356 104 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6357 104 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6358 104 : if (!SWIG_IsOK(res1)) {
6359 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keyid_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6360 : }
6361 104 : arg1 = (struct _gpgme_subkey *)(argp1);
6362 104 : result = (char *) ((arg1)->keyid);
6363 104 : resultobj = SWIG_FromCharPtr((const char *)result);
6364 104 : return resultobj;
6365 : fail:
6366 : return NULL;
6367 : }
6368 :
6369 :
6370 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__keyid_set(PyObject *self, PyObject *args) {
6371 0 : PyObject *resultobj = 0;
6372 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6373 : char *arg2 ;
6374 0 : void *argp1 = 0 ;
6375 0 : int res1 = 0 ;
6376 : char temp2[16+1] ;
6377 : int res2 ;
6378 0 : PyObject * obj1 = 0 ;
6379 :
6380 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey__keyid_set",&obj1)) SWIG_fail;
6381 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6382 0 : if (!SWIG_IsOK(res1)) {
6383 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__keyid_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6384 : }
6385 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6386 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
6387 0 : if (!SWIG_IsOK(res2)) {
6388 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
6389 : }
6390 0 : arg2 = (char *)(temp2);
6391 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
6392 : else memset(arg1->_keyid,0,16+1*sizeof(char));
6393 0 : resultobj = SWIG_Py_Void();
6394 0 : return resultobj;
6395 : fail:
6396 : return NULL;
6397 : }
6398 :
6399 :
6400 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__keyid_get(PyObject *self, PyObject *args) {
6401 0 : PyObject *resultobj = 0;
6402 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6403 0 : void *argp1 = 0 ;
6404 0 : int res1 = 0 ;
6405 0 : char *result = 0 ;
6406 :
6407 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6408 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6409 0 : if (!SWIG_IsOK(res1)) {
6410 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__keyid_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6411 : }
6412 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6413 0 : result = (char *)(char *) ((arg1)->_keyid);
6414 : {
6415 0 : size_t size = 16+1;
6416 :
6417 0 : while (size && (result[size - 1] == '\0')) --size;
6418 :
6419 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
6420 : }
6421 0 : return resultobj;
6422 : fail:
6423 : return NULL;
6424 : }
6425 :
6426 :
6427 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_fpr_set(PyObject *self, PyObject *args) {
6428 0 : PyObject *resultobj = 0;
6429 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6430 0 : char *arg2 = (char *) 0 ;
6431 0 : void *argp1 = 0 ;
6432 0 : int res1 = 0 ;
6433 : int res2 ;
6434 0 : char *buf2 = 0 ;
6435 0 : int alloc2 = 0 ;
6436 0 : PyObject * obj1 = 0 ;
6437 :
6438 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_fpr_set",&obj1)) SWIG_fail;
6439 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6440 0 : if (!SWIG_IsOK(res1)) {
6441 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_fpr_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6442 : }
6443 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6444 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6445 0 : if (!SWIG_IsOK(res2)) {
6446 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_fpr_set" "', argument " "2"" of type '" "char *""'");
6447 : }
6448 0 : arg2 = (char *)(buf2);
6449 0 : if (arg1->fpr) free((char*)arg1->fpr);
6450 0 : if (arg2) {
6451 0 : size_t size = strlen((const char *)(arg2)) + 1;
6452 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
6453 : } else {
6454 0 : arg1->fpr = 0;
6455 : }
6456 0 : resultobj = SWIG_Py_Void();
6457 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6458 : return resultobj;
6459 : fail:
6460 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6461 : return NULL;
6462 : }
6463 :
6464 :
6465 58 : SWIGINTERN PyObject *_wrap__gpgme_subkey_fpr_get(PyObject *self, PyObject *args) {
6466 58 : PyObject *resultobj = 0;
6467 58 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6468 58 : void *argp1 = 0 ;
6469 58 : int res1 = 0 ;
6470 58 : char *result = 0 ;
6471 :
6472 58 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6473 58 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6474 58 : if (!SWIG_IsOK(res1)) {
6475 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_fpr_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6476 : }
6477 58 : arg1 = (struct _gpgme_subkey *)(argp1);
6478 58 : result = (char *) ((arg1)->fpr);
6479 58 : resultobj = SWIG_FromCharPtr((const char *)result);
6480 58 : return resultobj;
6481 : fail:
6482 : return NULL;
6483 : }
6484 :
6485 :
6486 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_timestamp_set(PyObject *self, PyObject *args) {
6487 0 : PyObject *resultobj = 0;
6488 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6489 : long arg2 ;
6490 0 : void *argp1 = 0 ;
6491 0 : int res1 = 0 ;
6492 : long val2 ;
6493 0 : int ecode2 = 0 ;
6494 0 : PyObject * obj1 = 0 ;
6495 :
6496 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_timestamp_set",&obj1)) SWIG_fail;
6497 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6498 0 : if (!SWIG_IsOK(res1)) {
6499 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6500 : }
6501 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6502 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
6503 0 : if (!SWIG_IsOK(ecode2)) {
6504 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_timestamp_set" "', argument " "2"" of type '" "long""'");
6505 : }
6506 0 : arg2 = (long)(val2);
6507 0 : if (arg1) (arg1)->timestamp = arg2;
6508 0 : resultobj = SWIG_Py_Void();
6509 0 : return resultobj;
6510 : fail:
6511 : return NULL;
6512 : }
6513 :
6514 :
6515 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_timestamp_get(PyObject *self, PyObject *args) {
6516 0 : PyObject *resultobj = 0;
6517 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6518 0 : void *argp1 = 0 ;
6519 0 : int res1 = 0 ;
6520 : long result;
6521 :
6522 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6523 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6524 0 : if (!SWIG_IsOK(res1)) {
6525 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6526 : }
6527 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6528 0 : result = (long) ((arg1)->timestamp);
6529 0 : resultobj = SWIG_From_long((long)(result));
6530 0 : return resultobj;
6531 : fail:
6532 : return NULL;
6533 : }
6534 :
6535 :
6536 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expires_set(PyObject *self, PyObject *args) {
6537 0 : PyObject *resultobj = 0;
6538 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6539 : long arg2 ;
6540 0 : void *argp1 = 0 ;
6541 0 : int res1 = 0 ;
6542 : long val2 ;
6543 0 : int ecode2 = 0 ;
6544 0 : PyObject * obj1 = 0 ;
6545 :
6546 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_expires_set",&obj1)) SWIG_fail;
6547 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6548 0 : if (!SWIG_IsOK(res1)) {
6549 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expires_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6550 : }
6551 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6552 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
6553 0 : if (!SWIG_IsOK(ecode2)) {
6554 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_expires_set" "', argument " "2"" of type '" "long""'");
6555 : }
6556 0 : arg2 = (long)(val2);
6557 0 : if (arg1) (arg1)->expires = arg2;
6558 0 : resultobj = SWIG_Py_Void();
6559 0 : return resultobj;
6560 : fail:
6561 : return NULL;
6562 : }
6563 :
6564 :
6565 108 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expires_get(PyObject *self, PyObject *args) {
6566 108 : PyObject *resultobj = 0;
6567 108 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6568 108 : void *argp1 = 0 ;
6569 108 : int res1 = 0 ;
6570 : long result;
6571 :
6572 108 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6573 108 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6574 108 : if (!SWIG_IsOK(res1)) {
6575 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expires_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6576 : }
6577 108 : arg1 = (struct _gpgme_subkey *)(argp1);
6578 108 : result = (long) ((arg1)->expires);
6579 108 : resultobj = SWIG_From_long((long)(result));
6580 108 : return resultobj;
6581 : fail:
6582 : return NULL;
6583 : }
6584 :
6585 :
6586 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_card_number_set(PyObject *self, PyObject *args) {
6587 0 : PyObject *resultobj = 0;
6588 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6589 0 : char *arg2 = (char *) 0 ;
6590 0 : void *argp1 = 0 ;
6591 0 : int res1 = 0 ;
6592 : int res2 ;
6593 0 : char *buf2 = 0 ;
6594 0 : int alloc2 = 0 ;
6595 0 : PyObject * obj1 = 0 ;
6596 :
6597 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_card_number_set",&obj1)) SWIG_fail;
6598 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6599 0 : if (!SWIG_IsOK(res1)) {
6600 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_card_number_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6601 : }
6602 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6603 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6604 0 : if (!SWIG_IsOK(res2)) {
6605 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_card_number_set" "', argument " "2"" of type '" "char *""'");
6606 : }
6607 0 : arg2 = (char *)(buf2);
6608 0 : if (arg1->card_number) free((char*)arg1->card_number);
6609 0 : if (arg2) {
6610 0 : size_t size = strlen((const char *)(arg2)) + 1;
6611 0 : arg1->card_number = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
6612 : } else {
6613 0 : arg1->card_number = 0;
6614 : }
6615 0 : resultobj = SWIG_Py_Void();
6616 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6617 : return resultobj;
6618 : fail:
6619 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6620 : return NULL;
6621 : }
6622 :
6623 :
6624 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_card_number_get(PyObject *self, PyObject *args) {
6625 104 : PyObject *resultobj = 0;
6626 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6627 104 : void *argp1 = 0 ;
6628 104 : int res1 = 0 ;
6629 104 : char *result = 0 ;
6630 :
6631 104 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6632 104 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6633 104 : if (!SWIG_IsOK(res1)) {
6634 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_card_number_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6635 : }
6636 104 : arg1 = (struct _gpgme_subkey *)(argp1);
6637 104 : result = (char *) ((arg1)->card_number);
6638 104 : resultobj = SWIG_FromCharPtr((const char *)result);
6639 104 : return resultobj;
6640 : fail:
6641 : return NULL;
6642 : }
6643 :
6644 :
6645 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_curve_set(PyObject *self, PyObject *args) {
6646 0 : PyObject *resultobj = 0;
6647 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6648 0 : char *arg2 = (char *) 0 ;
6649 0 : void *argp1 = 0 ;
6650 0 : int res1 = 0 ;
6651 : int res2 ;
6652 0 : char *buf2 = 0 ;
6653 0 : int alloc2 = 0 ;
6654 0 : PyObject * obj1 = 0 ;
6655 :
6656 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_curve_set",&obj1)) SWIG_fail;
6657 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6658 0 : if (!SWIG_IsOK(res1)) {
6659 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_curve_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6660 : }
6661 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6662 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6663 0 : if (!SWIG_IsOK(res2)) {
6664 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_curve_set" "', argument " "2"" of type '" "char *""'");
6665 : }
6666 0 : arg2 = (char *)(buf2);
6667 0 : if (arg1->curve) free((char*)arg1->curve);
6668 0 : if (arg2) {
6669 0 : size_t size = strlen((const char *)(arg2)) + 1;
6670 0 : arg1->curve = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
6671 : } else {
6672 0 : arg1->curve = 0;
6673 : }
6674 0 : resultobj = SWIG_Py_Void();
6675 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6676 : return resultobj;
6677 : fail:
6678 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6679 : return NULL;
6680 : }
6681 :
6682 :
6683 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_curve_get(PyObject *self, PyObject *args) {
6684 0 : PyObject *resultobj = 0;
6685 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6686 0 : void *argp1 = 0 ;
6687 0 : int res1 = 0 ;
6688 0 : char *result = 0 ;
6689 :
6690 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6691 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6692 0 : if (!SWIG_IsOK(res1)) {
6693 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_curve_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6694 : }
6695 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6696 0 : result = (char *) ((arg1)->curve);
6697 0 : resultobj = SWIG_FromCharPtr((const char *)result);
6698 0 : return resultobj;
6699 : fail:
6700 : return NULL;
6701 : }
6702 :
6703 :
6704 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keygrip_set(PyObject *self, PyObject *args) {
6705 0 : PyObject *resultobj = 0;
6706 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6707 0 : char *arg2 = (char *) 0 ;
6708 0 : void *argp1 = 0 ;
6709 0 : int res1 = 0 ;
6710 : int res2 ;
6711 0 : char *buf2 = 0 ;
6712 0 : int alloc2 = 0 ;
6713 0 : PyObject * obj1 = 0 ;
6714 :
6715 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_keygrip_set",&obj1)) SWIG_fail;
6716 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6717 0 : if (!SWIG_IsOK(res1)) {
6718 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keygrip_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6719 : }
6720 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6721 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6722 0 : if (!SWIG_IsOK(res2)) {
6723 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_keygrip_set" "', argument " "2"" of type '" "char *""'");
6724 : }
6725 0 : arg2 = (char *)(buf2);
6726 0 : if (arg1->keygrip) free((char*)arg1->keygrip);
6727 0 : if (arg2) {
6728 0 : size_t size = strlen((const char *)(arg2)) + 1;
6729 0 : arg1->keygrip = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
6730 : } else {
6731 0 : arg1->keygrip = 0;
6732 : }
6733 0 : resultobj = SWIG_Py_Void();
6734 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6735 : return resultobj;
6736 : fail:
6737 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6738 : return NULL;
6739 : }
6740 :
6741 :
6742 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keygrip_get(PyObject *self, PyObject *args) {
6743 0 : PyObject *resultobj = 0;
6744 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6745 0 : void *argp1 = 0 ;
6746 0 : int res1 = 0 ;
6747 0 : char *result = 0 ;
6748 :
6749 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6750 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6751 0 : if (!SWIG_IsOK(res1)) {
6752 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keygrip_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6753 : }
6754 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6755 0 : result = (char *) ((arg1)->keygrip);
6756 0 : resultobj = SWIG_FromCharPtr((const char *)result);
6757 0 : return resultobj;
6758 : fail:
6759 : return NULL;
6760 : }
6761 :
6762 :
6763 0 : SWIGINTERN int _wrap_new__gpgme_subkey(PyObject *self, PyObject *args) {
6764 0 : PyObject *resultobj = 0;
6765 0 : struct _gpgme_subkey *result = 0 ;
6766 :
6767 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6768 0 : result = (struct _gpgme_subkey *)calloc(1, sizeof(struct _gpgme_subkey));
6769 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_subkey, SWIG_BUILTIN_INIT | 0 );
6770 0 : return resultobj == Py_None ? -1 : 0;
6771 : fail:
6772 : return -1;
6773 : }
6774 :
6775 :
6776 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_subkey(PyObject *self, PyObject *args) {
6777 0 : PyObject *resultobj = 0;
6778 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6779 0 : void *argp1 = 0 ;
6780 0 : int res1 = 0 ;
6781 :
6782 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6783 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_subkey, SWIG_POINTER_DISOWN | 0 );
6784 0 : if (!SWIG_IsOK(res1)) {
6785 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_subkey" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6786 : }
6787 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6788 0 : free((char *) arg1);
6789 0 : resultobj = SWIG_Py_Void();
6790 0 : return resultobj;
6791 : fail:
6792 : return NULL;
6793 : }
6794 :
6795 :
6796 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_revoked_set(PyObject *self, PyObject *args) {
6797 0 : PyObject *resultobj = 0;
6798 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
6799 : unsigned int arg2 ;
6800 0 : void *argp1 = 0 ;
6801 0 : int res1 = 0 ;
6802 : unsigned int val2 ;
6803 0 : int ecode2 = 0 ;
6804 0 : PyObject * obj1 = 0 ;
6805 :
6806 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_revoked_set",&obj1)) SWIG_fail;
6807 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
6808 0 : if (!SWIG_IsOK(res1)) {
6809 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_revoked_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
6810 : }
6811 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
6812 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6813 0 : if (!SWIG_IsOK(ecode2)) {
6814 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
6815 : }
6816 0 : arg2 = (unsigned int)(val2);
6817 0 : if (arg1) (arg1)->revoked = arg2;
6818 0 : resultobj = SWIG_Py_Void();
6819 0 : return resultobj;
6820 : fail:
6821 : return NULL;
6822 : }
6823 :
6824 :
6825 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_revoked_get(PyObject *self, PyObject *args) {
6826 0 : PyObject *resultobj = 0;
6827 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
6828 0 : void *argp1 = 0 ;
6829 0 : int res1 = 0 ;
6830 : unsigned int result;
6831 :
6832 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6833 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
6834 0 : if (!SWIG_IsOK(res1)) {
6835 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_revoked_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
6836 : }
6837 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
6838 0 : result = (unsigned int) ((arg1)->revoked);
6839 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6840 0 : return resultobj;
6841 : fail:
6842 : return NULL;
6843 : }
6844 :
6845 :
6846 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expired_set(PyObject *self, PyObject *args) {
6847 0 : PyObject *resultobj = 0;
6848 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
6849 : unsigned int arg2 ;
6850 0 : void *argp1 = 0 ;
6851 0 : int res1 = 0 ;
6852 : unsigned int val2 ;
6853 0 : int ecode2 = 0 ;
6854 0 : PyObject * obj1 = 0 ;
6855 :
6856 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_expired_set",&obj1)) SWIG_fail;
6857 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
6858 0 : if (!SWIG_IsOK(res1)) {
6859 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expired_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
6860 : }
6861 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
6862 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6863 0 : if (!SWIG_IsOK(ecode2)) {
6864 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_expired_set" "', argument " "2"" of type '" "unsigned int""'");
6865 : }
6866 0 : arg2 = (unsigned int)(val2);
6867 0 : if (arg1) (arg1)->expired = arg2;
6868 0 : resultobj = SWIG_Py_Void();
6869 0 : return resultobj;
6870 : fail:
6871 : return NULL;
6872 : }
6873 :
6874 :
6875 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expired_get(PyObject *self, PyObject *args) {
6876 0 : PyObject *resultobj = 0;
6877 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
6878 0 : void *argp1 = 0 ;
6879 0 : int res1 = 0 ;
6880 : unsigned int result;
6881 :
6882 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6883 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
6884 0 : if (!SWIG_IsOK(res1)) {
6885 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expired_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
6886 : }
6887 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
6888 0 : result = (unsigned int) ((arg1)->expired);
6889 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6890 0 : return resultobj;
6891 : fail:
6892 : return NULL;
6893 : }
6894 :
6895 :
6896 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_invalid_set(PyObject *self, PyObject *args) {
6897 0 : PyObject *resultobj = 0;
6898 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
6899 : unsigned int arg2 ;
6900 0 : void *argp1 = 0 ;
6901 0 : int res1 = 0 ;
6902 : unsigned int val2 ;
6903 0 : int ecode2 = 0 ;
6904 0 : PyObject * obj1 = 0 ;
6905 :
6906 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_invalid_set",&obj1)) SWIG_fail;
6907 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
6908 0 : if (!SWIG_IsOK(res1)) {
6909 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_invalid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
6910 : }
6911 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
6912 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6913 0 : if (!SWIG_IsOK(ecode2)) {
6914 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
6915 : }
6916 0 : arg2 = (unsigned int)(val2);
6917 0 : if (arg1) (arg1)->invalid = arg2;
6918 0 : resultobj = SWIG_Py_Void();
6919 0 : return resultobj;
6920 : fail:
6921 : return NULL;
6922 : }
6923 :
6924 :
6925 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_invalid_get(PyObject *self, PyObject *args) {
6926 0 : PyObject *resultobj = 0;
6927 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
6928 0 : void *argp1 = 0 ;
6929 0 : int res1 = 0 ;
6930 : unsigned int result;
6931 :
6932 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6933 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
6934 0 : if (!SWIG_IsOK(res1)) {
6935 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_invalid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
6936 : }
6937 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
6938 0 : result = (unsigned int) ((arg1)->invalid);
6939 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6940 0 : return resultobj;
6941 : fail:
6942 : return NULL;
6943 : }
6944 :
6945 :
6946 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_exportable_set(PyObject *self, PyObject *args) {
6947 0 : PyObject *resultobj = 0;
6948 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
6949 : unsigned int arg2 ;
6950 0 : void *argp1 = 0 ;
6951 0 : int res1 = 0 ;
6952 : unsigned int val2 ;
6953 0 : int ecode2 = 0 ;
6954 0 : PyObject * obj1 = 0 ;
6955 :
6956 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_exportable_set",&obj1)) SWIG_fail;
6957 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
6958 0 : if (!SWIG_IsOK(res1)) {
6959 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_exportable_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
6960 : }
6961 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
6962 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6963 0 : if (!SWIG_IsOK(ecode2)) {
6964 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_exportable_set" "', argument " "2"" of type '" "unsigned int""'");
6965 : }
6966 0 : arg2 = (unsigned int)(val2);
6967 0 : if (arg1) (arg1)->exportable = arg2;
6968 0 : resultobj = SWIG_Py_Void();
6969 0 : return resultobj;
6970 : fail:
6971 : return NULL;
6972 : }
6973 :
6974 :
6975 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_exportable_get(PyObject *self, PyObject *args) {
6976 0 : PyObject *resultobj = 0;
6977 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
6978 0 : void *argp1 = 0 ;
6979 0 : int res1 = 0 ;
6980 : unsigned int result;
6981 :
6982 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
6983 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
6984 0 : if (!SWIG_IsOK(res1)) {
6985 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_exportable_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
6986 : }
6987 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
6988 0 : result = (unsigned int) ((arg1)->exportable);
6989 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6990 0 : return resultobj;
6991 : fail:
6992 : return NULL;
6993 : }
6994 :
6995 :
6996 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__unused_set(PyObject *self, PyObject *args) {
6997 0 : PyObject *resultobj = 0;
6998 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
6999 : unsigned int arg2 ;
7000 0 : void *argp1 = 0 ;
7001 0 : int res1 = 0 ;
7002 : unsigned int val2 ;
7003 0 : int ecode2 = 0 ;
7004 0 : PyObject * obj1 = 0 ;
7005 :
7006 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig__unused_set",&obj1)) SWIG_fail;
7007 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7008 0 : if (!SWIG_IsOK(res1)) {
7009 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__unused_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7010 : }
7011 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7012 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7013 0 : if (!SWIG_IsOK(ecode2)) {
7014 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig__unused_set" "', argument " "2"" of type '" "unsigned int""'");
7015 : }
7016 0 : arg2 = (unsigned int)(val2);
7017 0 : if (arg1) (arg1)->_unused = arg2;
7018 0 : resultobj = SWIG_Py_Void();
7019 0 : return resultobj;
7020 : fail:
7021 : return NULL;
7022 : }
7023 :
7024 :
7025 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__unused_get(PyObject *self, PyObject *args) {
7026 0 : PyObject *resultobj = 0;
7027 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7028 0 : void *argp1 = 0 ;
7029 0 : int res1 = 0 ;
7030 : unsigned int result;
7031 :
7032 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7033 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7034 0 : if (!SWIG_IsOK(res1)) {
7035 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__unused_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7036 : }
7037 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7038 0 : result = (unsigned int) ((arg1)->_unused);
7039 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7040 0 : return resultobj;
7041 : fail:
7042 : return NULL;
7043 : }
7044 :
7045 :
7046 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_pubkey_algo_set(PyObject *self, PyObject *args) {
7047 0 : PyObject *resultobj = 0;
7048 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7049 : gpgme_pubkey_algo_t arg2 ;
7050 0 : void *argp1 = 0 ;
7051 0 : int res1 = 0 ;
7052 : int val2 ;
7053 0 : int ecode2 = 0 ;
7054 0 : PyObject * obj1 = 0 ;
7055 :
7056 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_pubkey_algo_set",&obj1)) SWIG_fail;
7057 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7058 0 : if (!SWIG_IsOK(res1)) {
7059 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7060 : }
7061 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7062 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
7063 0 : if (!SWIG_IsOK(ecode2)) {
7064 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
7065 : }
7066 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
7067 0 : if (arg1) (arg1)->pubkey_algo = arg2;
7068 0 : resultobj = SWIG_Py_Void();
7069 0 : return resultobj;
7070 : fail:
7071 : return NULL;
7072 : }
7073 :
7074 :
7075 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_pubkey_algo_get(PyObject *self, PyObject *args) {
7076 0 : PyObject *resultobj = 0;
7077 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7078 0 : void *argp1 = 0 ;
7079 0 : int res1 = 0 ;
7080 : gpgme_pubkey_algo_t result;
7081 :
7082 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7083 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7084 0 : if (!SWIG_IsOK(res1)) {
7085 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7086 : }
7087 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7088 0 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
7089 0 : resultobj = SWIG_From_int((int)(result));
7090 0 : return resultobj;
7091 : fail:
7092 : return NULL;
7093 : }
7094 :
7095 :
7096 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_keyid_set(PyObject *self, PyObject *args) {
7097 0 : PyObject *resultobj = 0;
7098 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7099 0 : char *arg2 = (char *) 0 ;
7100 0 : void *argp1 = 0 ;
7101 0 : int res1 = 0 ;
7102 : int res2 ;
7103 0 : char *buf2 = 0 ;
7104 0 : int alloc2 = 0 ;
7105 0 : PyObject * obj1 = 0 ;
7106 :
7107 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_keyid_set",&obj1)) SWIG_fail;
7108 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7109 0 : if (!SWIG_IsOK(res1)) {
7110 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_keyid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7111 : }
7112 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7113 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7114 0 : if (!SWIG_IsOK(res2)) {
7115 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_keyid_set" "', argument " "2"" of type '" "char *""'");
7116 : }
7117 0 : arg2 = (char *)(buf2);
7118 0 : if (arg1->keyid) free((char*)arg1->keyid);
7119 0 : if (arg2) {
7120 0 : size_t size = strlen((const char *)(arg2)) + 1;
7121 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7122 : } else {
7123 0 : arg1->keyid = 0;
7124 : }
7125 0 : resultobj = SWIG_Py_Void();
7126 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7127 : return resultobj;
7128 : fail:
7129 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7130 : return NULL;
7131 : }
7132 :
7133 :
7134 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_keyid_get(PyObject *self, PyObject *args) {
7135 0 : PyObject *resultobj = 0;
7136 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7137 0 : void *argp1 = 0 ;
7138 0 : int res1 = 0 ;
7139 0 : char *result = 0 ;
7140 :
7141 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7142 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7143 0 : if (!SWIG_IsOK(res1)) {
7144 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_keyid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7145 : }
7146 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7147 0 : result = (char *) ((arg1)->keyid);
7148 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7149 0 : return resultobj;
7150 : fail:
7151 : return NULL;
7152 : }
7153 :
7154 :
7155 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__keyid_set(PyObject *self, PyObject *args) {
7156 0 : PyObject *resultobj = 0;
7157 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7158 : char *arg2 ;
7159 0 : void *argp1 = 0 ;
7160 0 : int res1 = 0 ;
7161 : char temp2[16+1] ;
7162 : int res2 ;
7163 0 : PyObject * obj1 = 0 ;
7164 :
7165 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig__keyid_set",&obj1)) SWIG_fail;
7166 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7167 0 : if (!SWIG_IsOK(res1)) {
7168 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__keyid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7169 : }
7170 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7171 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
7172 0 : if (!SWIG_IsOK(res2)) {
7173 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
7174 : }
7175 0 : arg2 = (char *)(temp2);
7176 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
7177 : else memset(arg1->_keyid,0,16+1*sizeof(char));
7178 0 : resultobj = SWIG_Py_Void();
7179 0 : return resultobj;
7180 : fail:
7181 : return NULL;
7182 : }
7183 :
7184 :
7185 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__keyid_get(PyObject *self, PyObject *args) {
7186 0 : PyObject *resultobj = 0;
7187 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7188 0 : void *argp1 = 0 ;
7189 0 : int res1 = 0 ;
7190 0 : char *result = 0 ;
7191 :
7192 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7193 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7194 0 : if (!SWIG_IsOK(res1)) {
7195 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__keyid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7196 : }
7197 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7198 0 : result = (char *)(char *) ((arg1)->_keyid);
7199 : {
7200 0 : size_t size = 16+1;
7201 :
7202 0 : while (size && (result[size - 1] == '\0')) --size;
7203 :
7204 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
7205 : }
7206 0 : return resultobj;
7207 : fail:
7208 : return NULL;
7209 : }
7210 :
7211 :
7212 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_timestamp_set(PyObject *self, PyObject *args) {
7213 0 : PyObject *resultobj = 0;
7214 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7215 : long arg2 ;
7216 0 : void *argp1 = 0 ;
7217 0 : int res1 = 0 ;
7218 : long val2 ;
7219 0 : int ecode2 = 0 ;
7220 0 : PyObject * obj1 = 0 ;
7221 :
7222 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_timestamp_set",&obj1)) SWIG_fail;
7223 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7224 0 : if (!SWIG_IsOK(res1)) {
7225 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7226 : }
7227 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7228 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
7229 0 : if (!SWIG_IsOK(ecode2)) {
7230 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_timestamp_set" "', argument " "2"" of type '" "long""'");
7231 : }
7232 0 : arg2 = (long)(val2);
7233 0 : if (arg1) (arg1)->timestamp = arg2;
7234 0 : resultobj = SWIG_Py_Void();
7235 0 : return resultobj;
7236 : fail:
7237 : return NULL;
7238 : }
7239 :
7240 :
7241 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_timestamp_get(PyObject *self, PyObject *args) {
7242 0 : PyObject *resultobj = 0;
7243 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7244 0 : void *argp1 = 0 ;
7245 0 : int res1 = 0 ;
7246 : long result;
7247 :
7248 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7249 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7250 0 : if (!SWIG_IsOK(res1)) {
7251 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7252 : }
7253 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7254 0 : result = (long) ((arg1)->timestamp);
7255 0 : resultobj = SWIG_From_long((long)(result));
7256 0 : return resultobj;
7257 : fail:
7258 : return NULL;
7259 : }
7260 :
7261 :
7262 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expires_set(PyObject *self, PyObject *args) {
7263 0 : PyObject *resultobj = 0;
7264 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7265 : long arg2 ;
7266 0 : void *argp1 = 0 ;
7267 0 : int res1 = 0 ;
7268 : long val2 ;
7269 0 : int ecode2 = 0 ;
7270 0 : PyObject * obj1 = 0 ;
7271 :
7272 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_expires_set",&obj1)) SWIG_fail;
7273 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7274 0 : if (!SWIG_IsOK(res1)) {
7275 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expires_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7276 : }
7277 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7278 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
7279 0 : if (!SWIG_IsOK(ecode2)) {
7280 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_expires_set" "', argument " "2"" of type '" "long""'");
7281 : }
7282 0 : arg2 = (long)(val2);
7283 0 : if (arg1) (arg1)->expires = arg2;
7284 0 : resultobj = SWIG_Py_Void();
7285 0 : return resultobj;
7286 : fail:
7287 : return NULL;
7288 : }
7289 :
7290 :
7291 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expires_get(PyObject *self, PyObject *args) {
7292 0 : PyObject *resultobj = 0;
7293 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7294 0 : void *argp1 = 0 ;
7295 0 : int res1 = 0 ;
7296 : long result;
7297 :
7298 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7299 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7300 0 : if (!SWIG_IsOK(res1)) {
7301 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expires_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7302 : }
7303 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7304 0 : result = (long) ((arg1)->expires);
7305 0 : resultobj = SWIG_From_long((long)(result));
7306 0 : return resultobj;
7307 : fail:
7308 : return NULL;
7309 : }
7310 :
7311 :
7312 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_status_set(PyObject *self, PyObject *args) {
7313 0 : PyObject *resultobj = 0;
7314 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7315 : gpgme_error_t arg2 ;
7316 0 : void *argp1 = 0 ;
7317 0 : int res1 = 0 ;
7318 0 : PyObject * obj1 = 0 ;
7319 :
7320 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_status_set",&obj1)) SWIG_fail;
7321 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7322 0 : if (!SWIG_IsOK(res1)) {
7323 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_status_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7324 : }
7325 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7326 : {
7327 0 : arg2 = PyLong_AsLong(obj1);
7328 : }
7329 0 : if (arg1) (arg1)->status = arg2;
7330 0 : resultobj = SWIG_Py_Void();
7331 0 : return resultobj;
7332 : fail:
7333 : return NULL;
7334 : }
7335 :
7336 :
7337 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_status_get(PyObject *self, PyObject *args) {
7338 0 : PyObject *resultobj = 0;
7339 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7340 0 : void *argp1 = 0 ;
7341 0 : int res1 = 0 ;
7342 : gpgme_error_t result;
7343 :
7344 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7345 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7346 0 : if (!SWIG_IsOK(res1)) {
7347 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_status_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7348 : }
7349 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7350 0 : result = ((arg1)->status);
7351 : {
7352 0 : resultobj = PyLong_FromLong(result);
7353 : }
7354 0 : return resultobj;
7355 : fail:
7356 : return NULL;
7357 : }
7358 :
7359 :
7360 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_uid_set(PyObject *self, PyObject *args) {
7361 0 : PyObject *resultobj = 0;
7362 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7363 0 : char *arg2 = (char *) 0 ;
7364 0 : void *argp1 = 0 ;
7365 0 : int res1 = 0 ;
7366 : int res2 ;
7367 0 : char *buf2 = 0 ;
7368 0 : int alloc2 = 0 ;
7369 0 : PyObject * obj1 = 0 ;
7370 :
7371 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_uid_set",&obj1)) SWIG_fail;
7372 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7373 0 : if (!SWIG_IsOK(res1)) {
7374 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_uid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7375 : }
7376 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7377 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7378 0 : if (!SWIG_IsOK(res2)) {
7379 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_uid_set" "', argument " "2"" of type '" "char *""'");
7380 : }
7381 0 : arg2 = (char *)(buf2);
7382 0 : if (arg1->uid) free((char*)arg1->uid);
7383 0 : if (arg2) {
7384 0 : size_t size = strlen((const char *)(arg2)) + 1;
7385 0 : arg1->uid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7386 : } else {
7387 0 : arg1->uid = 0;
7388 : }
7389 0 : resultobj = SWIG_Py_Void();
7390 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7391 : return resultobj;
7392 : fail:
7393 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7394 : return NULL;
7395 : }
7396 :
7397 :
7398 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_uid_get(PyObject *self, PyObject *args) {
7399 0 : PyObject *resultobj = 0;
7400 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7401 0 : void *argp1 = 0 ;
7402 0 : int res1 = 0 ;
7403 0 : char *result = 0 ;
7404 :
7405 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7406 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7407 0 : if (!SWIG_IsOK(res1)) {
7408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_uid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7409 : }
7410 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7411 0 : result = (char *) ((arg1)->uid);
7412 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7413 0 : return resultobj;
7414 : fail:
7415 : return NULL;
7416 : }
7417 :
7418 :
7419 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_name_set(PyObject *self, PyObject *args) {
7420 0 : PyObject *resultobj = 0;
7421 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7422 0 : char *arg2 = (char *) 0 ;
7423 0 : void *argp1 = 0 ;
7424 0 : int res1 = 0 ;
7425 : int res2 ;
7426 0 : char *buf2 = 0 ;
7427 0 : int alloc2 = 0 ;
7428 0 : PyObject * obj1 = 0 ;
7429 :
7430 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_name_set",&obj1)) SWIG_fail;
7431 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7432 0 : if (!SWIG_IsOK(res1)) {
7433 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_name_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7434 : }
7435 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7436 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7437 0 : if (!SWIG_IsOK(res2)) {
7438 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_name_set" "', argument " "2"" of type '" "char *""'");
7439 : }
7440 0 : arg2 = (char *)(buf2);
7441 0 : if (arg1->name) free((char*)arg1->name);
7442 0 : if (arg2) {
7443 0 : size_t size = strlen((const char *)(arg2)) + 1;
7444 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7445 : } else {
7446 0 : arg1->name = 0;
7447 : }
7448 0 : resultobj = SWIG_Py_Void();
7449 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7450 : return resultobj;
7451 : fail:
7452 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7453 : return NULL;
7454 : }
7455 :
7456 :
7457 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_name_get(PyObject *self, PyObject *args) {
7458 0 : PyObject *resultobj = 0;
7459 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7460 0 : void *argp1 = 0 ;
7461 0 : int res1 = 0 ;
7462 0 : char *result = 0 ;
7463 :
7464 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7465 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7466 0 : if (!SWIG_IsOK(res1)) {
7467 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_name_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7468 : }
7469 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7470 0 : result = (char *) ((arg1)->name);
7471 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7472 0 : return resultobj;
7473 : fail:
7474 : return NULL;
7475 : }
7476 :
7477 :
7478 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_email_set(PyObject *self, PyObject *args) {
7479 0 : PyObject *resultobj = 0;
7480 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7481 0 : char *arg2 = (char *) 0 ;
7482 0 : void *argp1 = 0 ;
7483 0 : int res1 = 0 ;
7484 : int res2 ;
7485 0 : char *buf2 = 0 ;
7486 0 : int alloc2 = 0 ;
7487 0 : PyObject * obj1 = 0 ;
7488 :
7489 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_email_set",&obj1)) SWIG_fail;
7490 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7491 0 : if (!SWIG_IsOK(res1)) {
7492 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_email_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7493 : }
7494 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7495 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7496 0 : if (!SWIG_IsOK(res2)) {
7497 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_email_set" "', argument " "2"" of type '" "char *""'");
7498 : }
7499 0 : arg2 = (char *)(buf2);
7500 0 : if (arg1->email) free((char*)arg1->email);
7501 0 : if (arg2) {
7502 0 : size_t size = strlen((const char *)(arg2)) + 1;
7503 0 : arg1->email = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7504 : } else {
7505 0 : arg1->email = 0;
7506 : }
7507 0 : resultobj = SWIG_Py_Void();
7508 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7509 : return resultobj;
7510 : fail:
7511 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7512 : return NULL;
7513 : }
7514 :
7515 :
7516 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_email_get(PyObject *self, PyObject *args) {
7517 0 : PyObject *resultobj = 0;
7518 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7519 0 : void *argp1 = 0 ;
7520 0 : int res1 = 0 ;
7521 0 : char *result = 0 ;
7522 :
7523 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7524 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7525 0 : if (!SWIG_IsOK(res1)) {
7526 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_email_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7527 : }
7528 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7529 0 : result = (char *) ((arg1)->email);
7530 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7531 0 : return resultobj;
7532 : fail:
7533 : return NULL;
7534 : }
7535 :
7536 :
7537 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_comment_set(PyObject *self, PyObject *args) {
7538 0 : PyObject *resultobj = 0;
7539 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7540 0 : char *arg2 = (char *) 0 ;
7541 0 : void *argp1 = 0 ;
7542 0 : int res1 = 0 ;
7543 : int res2 ;
7544 0 : char *buf2 = 0 ;
7545 0 : int alloc2 = 0 ;
7546 0 : PyObject * obj1 = 0 ;
7547 :
7548 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_comment_set",&obj1)) SWIG_fail;
7549 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7550 0 : if (!SWIG_IsOK(res1)) {
7551 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_comment_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7552 : }
7553 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7554 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7555 0 : if (!SWIG_IsOK(res2)) {
7556 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_comment_set" "', argument " "2"" of type '" "char *""'");
7557 : }
7558 0 : arg2 = (char *)(buf2);
7559 0 : if (arg1->comment) free((char*)arg1->comment);
7560 0 : if (arg2) {
7561 0 : size_t size = strlen((const char *)(arg2)) + 1;
7562 0 : arg1->comment = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7563 : } else {
7564 0 : arg1->comment = 0;
7565 : }
7566 0 : resultobj = SWIG_Py_Void();
7567 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7568 : return resultobj;
7569 : fail:
7570 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7571 : return NULL;
7572 : }
7573 :
7574 :
7575 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_comment_get(PyObject *self, PyObject *args) {
7576 0 : PyObject *resultobj = 0;
7577 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7578 0 : void *argp1 = 0 ;
7579 0 : int res1 = 0 ;
7580 0 : char *result = 0 ;
7581 :
7582 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7583 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7584 0 : if (!SWIG_IsOK(res1)) {
7585 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_comment_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7586 : }
7587 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7588 0 : result = (char *) ((arg1)->comment);
7589 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7590 0 : return resultobj;
7591 : fail:
7592 : return NULL;
7593 : }
7594 :
7595 :
7596 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_sig_class_set(PyObject *self, PyObject *args) {
7597 0 : PyObject *resultobj = 0;
7598 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7599 : unsigned int arg2 ;
7600 0 : void *argp1 = 0 ;
7601 0 : int res1 = 0 ;
7602 : unsigned int val2 ;
7603 0 : int ecode2 = 0 ;
7604 0 : PyObject * obj1 = 0 ;
7605 :
7606 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_sig_class_set",&obj1)) SWIG_fail;
7607 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7608 0 : if (!SWIG_IsOK(res1)) {
7609 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_sig_class_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7610 : }
7611 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7612 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7613 0 : if (!SWIG_IsOK(ecode2)) {
7614 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_sig_class_set" "', argument " "2"" of type '" "unsigned int""'");
7615 : }
7616 0 : arg2 = (unsigned int)(val2);
7617 0 : if (arg1) (arg1)->sig_class = arg2;
7618 0 : resultobj = SWIG_Py_Void();
7619 0 : return resultobj;
7620 : fail:
7621 : return NULL;
7622 : }
7623 :
7624 :
7625 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_sig_class_get(PyObject *self, PyObject *args) {
7626 0 : PyObject *resultobj = 0;
7627 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7628 0 : void *argp1 = 0 ;
7629 0 : int res1 = 0 ;
7630 : unsigned int result;
7631 :
7632 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7633 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7634 0 : if (!SWIG_IsOK(res1)) {
7635 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_sig_class_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7636 : }
7637 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7638 0 : result = (unsigned int) ((arg1)->sig_class);
7639 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7640 0 : return resultobj;
7641 : fail:
7642 : return NULL;
7643 : }
7644 :
7645 :
7646 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_notations_set(PyObject *self, PyObject *args) {
7647 0 : PyObject *resultobj = 0;
7648 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7649 0 : gpgme_sig_notation_t arg2 = (gpgme_sig_notation_t) 0 ;
7650 0 : void *argp1 = 0 ;
7651 0 : int res1 = 0 ;
7652 0 : void *argp2 = 0 ;
7653 0 : int res2 = 0 ;
7654 0 : PyObject * obj1 = 0 ;
7655 :
7656 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_notations_set",&obj1)) SWIG_fail;
7657 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7658 0 : if (!SWIG_IsOK(res1)) {
7659 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_notations_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7660 : }
7661 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7662 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
7663 0 : if (!SWIG_IsOK(res2)) {
7664 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_notations_set" "', argument " "2"" of type '" "gpgme_sig_notation_t""'");
7665 : }
7666 0 : arg2 = (gpgme_sig_notation_t)(argp2);
7667 0 : if (arg1) (arg1)->notations = arg2;
7668 0 : resultobj = SWIG_Py_Void();
7669 0 : return resultobj;
7670 : fail:
7671 : return NULL;
7672 : }
7673 :
7674 :
7675 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_notations_get(PyObject *self, PyObject *args) {
7676 0 : PyObject *resultobj = 0;
7677 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7678 0 : void *argp1 = 0 ;
7679 0 : int res1 = 0 ;
7680 : gpgme_sig_notation_t result;
7681 :
7682 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7683 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7684 0 : if (!SWIG_IsOK(res1)) {
7685 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_notations_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7686 : }
7687 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7688 0 : result = (gpgme_sig_notation_t) ((arg1)->notations);
7689 : {
7690 : int i;
7691 0 : int size = 0;
7692 : gpgme_sig_notation_t curr;
7693 0 : for (curr = result; curr != NULL; curr = curr->next) {
7694 0 : size++;
7695 : }
7696 0 : resultobj = PyList_New(size);
7697 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
7698 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
7699 0 : PyList_SetItem(resultobj, i, o);
7700 : }
7701 : }
7702 : return resultobj;
7703 : fail:
7704 : return NULL;
7705 : }
7706 :
7707 :
7708 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__last_notation_set(PyObject *self, PyObject *args) {
7709 0 : PyObject *resultobj = 0;
7710 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7711 0 : gpgme_sig_notation_t arg2 = (gpgme_sig_notation_t) 0 ;
7712 0 : void *argp1 = 0 ;
7713 0 : int res1 = 0 ;
7714 0 : void *argp2 = 0 ;
7715 0 : int res2 = 0 ;
7716 0 : PyObject * obj1 = 0 ;
7717 :
7718 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig__last_notation_set",&obj1)) SWIG_fail;
7719 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7720 0 : if (!SWIG_IsOK(res1)) {
7721 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__last_notation_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7722 : }
7723 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7724 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
7725 0 : if (!SWIG_IsOK(res2)) {
7726 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig__last_notation_set" "', argument " "2"" of type '" "gpgme_sig_notation_t""'");
7727 : }
7728 0 : arg2 = (gpgme_sig_notation_t)(argp2);
7729 0 : if (arg1) (arg1)->_last_notation = arg2;
7730 0 : resultobj = SWIG_Py_Void();
7731 0 : return resultobj;
7732 : fail:
7733 : return NULL;
7734 : }
7735 :
7736 :
7737 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__last_notation_get(PyObject *self, PyObject *args) {
7738 0 : PyObject *resultobj = 0;
7739 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7740 0 : void *argp1 = 0 ;
7741 0 : int res1 = 0 ;
7742 : gpgme_sig_notation_t result;
7743 :
7744 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7745 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7746 0 : if (!SWIG_IsOK(res1)) {
7747 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__last_notation_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7748 : }
7749 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7750 0 : result = (gpgme_sig_notation_t) ((arg1)->_last_notation);
7751 : {
7752 : int i;
7753 0 : int size = 0;
7754 : gpgme_sig_notation_t curr;
7755 0 : for (curr = result; curr != NULL; curr = curr->next) {
7756 0 : size++;
7757 : }
7758 0 : resultobj = PyList_New(size);
7759 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
7760 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
7761 0 : PyList_SetItem(resultobj, i, o);
7762 : }
7763 : }
7764 : return resultobj;
7765 : fail:
7766 : return NULL;
7767 : }
7768 :
7769 :
7770 0 : SWIGINTERN int _wrap_new__gpgme_key_sig(PyObject *self, PyObject *args) {
7771 0 : PyObject *resultobj = 0;
7772 0 : struct _gpgme_key_sig *result = 0 ;
7773 :
7774 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7775 0 : result = (struct _gpgme_key_sig *)calloc(1, sizeof(struct _gpgme_key_sig));
7776 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key_sig, SWIG_BUILTIN_INIT | 0 );
7777 0 : return resultobj == Py_None ? -1 : 0;
7778 : fail:
7779 : return -1;
7780 : }
7781 :
7782 :
7783 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_key_sig(PyObject *self, PyObject *args) {
7784 0 : PyObject *resultobj = 0;
7785 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7786 0 : void *argp1 = 0 ;
7787 0 : int res1 = 0 ;
7788 :
7789 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7790 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key_sig, SWIG_POINTER_DISOWN | 0 );
7791 0 : if (!SWIG_IsOK(res1)) {
7792 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_key_sig" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7793 : }
7794 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7795 0 : free((char *) arg1);
7796 0 : resultobj = SWIG_Py_Void();
7797 0 : return resultobj;
7798 : fail:
7799 : return NULL;
7800 : }
7801 :
7802 :
7803 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_revoked_set(PyObject *self, PyObject *args) {
7804 0 : PyObject *resultobj = 0;
7805 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
7806 : unsigned int arg2 ;
7807 0 : void *argp1 = 0 ;
7808 0 : int res1 = 0 ;
7809 : unsigned int val2 ;
7810 0 : int ecode2 = 0 ;
7811 0 : PyObject * obj1 = 0 ;
7812 :
7813 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_revoked_set",&obj1)) SWIG_fail;
7814 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
7815 0 : if (!SWIG_IsOK(res1)) {
7816 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_revoked_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
7817 : }
7818 0 : arg1 = (struct _gpgme_user_id *)(argp1);
7819 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7820 0 : if (!SWIG_IsOK(ecode2)) {
7821 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
7822 : }
7823 0 : arg2 = (unsigned int)(val2);
7824 0 : if (arg1) (arg1)->revoked = arg2;
7825 0 : resultobj = SWIG_Py_Void();
7826 0 : return resultobj;
7827 : fail:
7828 : return NULL;
7829 : }
7830 :
7831 :
7832 64 : SWIGINTERN PyObject *_wrap__gpgme_user_id_revoked_get(PyObject *self, PyObject *args) {
7833 64 : PyObject *resultobj = 0;
7834 64 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
7835 64 : void *argp1 = 0 ;
7836 64 : int res1 = 0 ;
7837 : unsigned int result;
7838 :
7839 64 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7840 64 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
7841 64 : if (!SWIG_IsOK(res1)) {
7842 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_revoked_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
7843 : }
7844 64 : arg1 = (struct _gpgme_user_id *)(argp1);
7845 64 : result = (unsigned int) ((arg1)->revoked);
7846 64 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7847 64 : return resultobj;
7848 : fail:
7849 : return NULL;
7850 : }
7851 :
7852 :
7853 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_invalid_set(PyObject *self, PyObject *args) {
7854 0 : PyObject *resultobj = 0;
7855 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
7856 : unsigned int arg2 ;
7857 0 : void *argp1 = 0 ;
7858 0 : int res1 = 0 ;
7859 : unsigned int val2 ;
7860 0 : int ecode2 = 0 ;
7861 0 : PyObject * obj1 = 0 ;
7862 :
7863 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_invalid_set",&obj1)) SWIG_fail;
7864 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
7865 0 : if (!SWIG_IsOK(res1)) {
7866 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_invalid_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
7867 : }
7868 0 : arg1 = (struct _gpgme_user_id *)(argp1);
7869 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7870 0 : if (!SWIG_IsOK(ecode2)) {
7871 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
7872 : }
7873 0 : arg2 = (unsigned int)(val2);
7874 0 : if (arg1) (arg1)->invalid = arg2;
7875 0 : resultobj = SWIG_Py_Void();
7876 0 : return resultobj;
7877 : fail:
7878 : return NULL;
7879 : }
7880 :
7881 :
7882 64 : SWIGINTERN PyObject *_wrap__gpgme_user_id_invalid_get(PyObject *self, PyObject *args) {
7883 64 : PyObject *resultobj = 0;
7884 64 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
7885 64 : void *argp1 = 0 ;
7886 64 : int res1 = 0 ;
7887 : unsigned int result;
7888 :
7889 64 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7890 64 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
7891 64 : if (!SWIG_IsOK(res1)) {
7892 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_invalid_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
7893 : }
7894 64 : arg1 = (struct _gpgme_user_id *)(argp1);
7895 64 : result = (unsigned int) ((arg1)->invalid);
7896 64 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7897 64 : return resultobj;
7898 : fail:
7899 : return NULL;
7900 : }
7901 :
7902 :
7903 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__unused_set(PyObject *self, PyObject *args) {
7904 0 : PyObject *resultobj = 0;
7905 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
7906 : unsigned int arg2 ;
7907 0 : void *argp1 = 0 ;
7908 0 : int res1 = 0 ;
7909 : unsigned int val2 ;
7910 0 : int ecode2 = 0 ;
7911 0 : PyObject * obj1 = 0 ;
7912 :
7913 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id__unused_set",&obj1)) SWIG_fail;
7914 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
7915 0 : if (!SWIG_IsOK(res1)) {
7916 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__unused_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
7917 : }
7918 0 : arg1 = (struct _gpgme_user_id *)(argp1);
7919 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7920 0 : if (!SWIG_IsOK(ecode2)) {
7921 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id__unused_set" "', argument " "2"" of type '" "unsigned int""'");
7922 : }
7923 0 : arg2 = (unsigned int)(val2);
7924 0 : if (arg1) (arg1)->_unused = arg2;
7925 0 : resultobj = SWIG_Py_Void();
7926 0 : return resultobj;
7927 : fail:
7928 : return NULL;
7929 : }
7930 :
7931 :
7932 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__unused_get(PyObject *self, PyObject *args) {
7933 0 : PyObject *resultobj = 0;
7934 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
7935 0 : void *argp1 = 0 ;
7936 0 : int res1 = 0 ;
7937 : unsigned int result;
7938 :
7939 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7940 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
7941 0 : if (!SWIG_IsOK(res1)) {
7942 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__unused_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
7943 : }
7944 0 : arg1 = (struct _gpgme_user_id *)(argp1);
7945 0 : result = (unsigned int) ((arg1)->_unused);
7946 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7947 0 : return resultobj;
7948 : fail:
7949 : return NULL;
7950 : }
7951 :
7952 :
7953 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_validity_set(PyObject *self, PyObject *args) {
7954 0 : PyObject *resultobj = 0;
7955 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
7956 : gpgme_validity_t arg2 ;
7957 0 : void *argp1 = 0 ;
7958 0 : int res1 = 0 ;
7959 : int val2 ;
7960 0 : int ecode2 = 0 ;
7961 0 : PyObject * obj1 = 0 ;
7962 :
7963 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_validity_set",&obj1)) SWIG_fail;
7964 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
7965 0 : if (!SWIG_IsOK(res1)) {
7966 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_validity_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
7967 : }
7968 0 : arg1 = (struct _gpgme_user_id *)(argp1);
7969 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
7970 0 : if (!SWIG_IsOK(ecode2)) {
7971 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id_validity_set" "', argument " "2"" of type '" "gpgme_validity_t""'");
7972 : }
7973 0 : arg2 = (gpgme_validity_t)(val2);
7974 0 : if (arg1) (arg1)->validity = arg2;
7975 0 : resultobj = SWIG_Py_Void();
7976 0 : return resultobj;
7977 : fail:
7978 : return NULL;
7979 : }
7980 :
7981 :
7982 64 : SWIGINTERN PyObject *_wrap__gpgme_user_id_validity_get(PyObject *self, PyObject *args) {
7983 64 : PyObject *resultobj = 0;
7984 64 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
7985 64 : void *argp1 = 0 ;
7986 64 : int res1 = 0 ;
7987 : gpgme_validity_t result;
7988 :
7989 64 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
7990 64 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
7991 64 : if (!SWIG_IsOK(res1)) {
7992 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_validity_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
7993 : }
7994 64 : arg1 = (struct _gpgme_user_id *)(argp1);
7995 64 : result = (gpgme_validity_t) ((arg1)->validity);
7996 128 : resultobj = SWIG_From_int((int)(result));
7997 64 : return resultobj;
7998 : fail:
7999 : return NULL;
8000 : }
8001 :
8002 :
8003 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_uid_set(PyObject *self, PyObject *args) {
8004 0 : PyObject *resultobj = 0;
8005 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8006 0 : char *arg2 = (char *) 0 ;
8007 0 : void *argp1 = 0 ;
8008 0 : int res1 = 0 ;
8009 : int res2 ;
8010 0 : char *buf2 = 0 ;
8011 0 : int alloc2 = 0 ;
8012 0 : PyObject * obj1 = 0 ;
8013 :
8014 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_uid_set",&obj1)) SWIG_fail;
8015 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8016 0 : if (!SWIG_IsOK(res1)) {
8017 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_uid_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8018 : }
8019 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8020 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8021 0 : if (!SWIG_IsOK(res2)) {
8022 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_uid_set" "', argument " "2"" of type '" "char *""'");
8023 : }
8024 0 : arg2 = (char *)(buf2);
8025 0 : if (arg1->uid) free((char*)arg1->uid);
8026 0 : if (arg2) {
8027 0 : size_t size = strlen((const char *)(arg2)) + 1;
8028 0 : arg1->uid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8029 : } else {
8030 0 : arg1->uid = 0;
8031 : }
8032 0 : resultobj = SWIG_Py_Void();
8033 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8034 : return resultobj;
8035 : fail:
8036 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8037 : return NULL;
8038 : }
8039 :
8040 :
8041 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_uid_get(PyObject *self, PyObject *args) {
8042 0 : PyObject *resultobj = 0;
8043 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8044 0 : void *argp1 = 0 ;
8045 0 : int res1 = 0 ;
8046 0 : char *result = 0 ;
8047 :
8048 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8049 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8050 0 : if (!SWIG_IsOK(res1)) {
8051 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_uid_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8052 : }
8053 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8054 0 : result = (char *) ((arg1)->uid);
8055 0 : resultobj = SWIG_FromCharPtr((const char *)result);
8056 0 : return resultobj;
8057 : fail:
8058 : return NULL;
8059 : }
8060 :
8061 :
8062 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_name_set(PyObject *self, PyObject *args) {
8063 0 : PyObject *resultobj = 0;
8064 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8065 0 : char *arg2 = (char *) 0 ;
8066 0 : void *argp1 = 0 ;
8067 0 : int res1 = 0 ;
8068 : int res2 ;
8069 0 : char *buf2 = 0 ;
8070 0 : int alloc2 = 0 ;
8071 0 : PyObject * obj1 = 0 ;
8072 :
8073 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_name_set",&obj1)) SWIG_fail;
8074 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8075 0 : if (!SWIG_IsOK(res1)) {
8076 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_name_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8077 : }
8078 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8079 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8080 0 : if (!SWIG_IsOK(res2)) {
8081 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_name_set" "', argument " "2"" of type '" "char *""'");
8082 : }
8083 0 : arg2 = (char *)(buf2);
8084 0 : if (arg1->name) free((char*)arg1->name);
8085 0 : if (arg2) {
8086 0 : size_t size = strlen((const char *)(arg2)) + 1;
8087 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8088 : } else {
8089 0 : arg1->name = 0;
8090 : }
8091 0 : resultobj = SWIG_Py_Void();
8092 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8093 : return resultobj;
8094 : fail:
8095 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8096 : return NULL;
8097 : }
8098 :
8099 :
8100 232 : SWIGINTERN PyObject *_wrap__gpgme_user_id_name_get(PyObject *self, PyObject *args) {
8101 232 : PyObject *resultobj = 0;
8102 232 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8103 232 : void *argp1 = 0 ;
8104 232 : int res1 = 0 ;
8105 232 : char *result = 0 ;
8106 :
8107 232 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8108 232 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8109 232 : if (!SWIG_IsOK(res1)) {
8110 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_name_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8111 : }
8112 232 : arg1 = (struct _gpgme_user_id *)(argp1);
8113 232 : result = (char *) ((arg1)->name);
8114 232 : resultobj = SWIG_FromCharPtr((const char *)result);
8115 232 : return resultobj;
8116 : fail:
8117 : return NULL;
8118 : }
8119 :
8120 :
8121 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_email_set(PyObject *self, PyObject *args) {
8122 0 : PyObject *resultobj = 0;
8123 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8124 0 : char *arg2 = (char *) 0 ;
8125 0 : void *argp1 = 0 ;
8126 0 : int res1 = 0 ;
8127 : int res2 ;
8128 0 : char *buf2 = 0 ;
8129 0 : int alloc2 = 0 ;
8130 0 : PyObject * obj1 = 0 ;
8131 :
8132 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_email_set",&obj1)) SWIG_fail;
8133 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8134 0 : if (!SWIG_IsOK(res1)) {
8135 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_email_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8136 : }
8137 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8138 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8139 0 : if (!SWIG_IsOK(res2)) {
8140 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_email_set" "', argument " "2"" of type '" "char *""'");
8141 : }
8142 0 : arg2 = (char *)(buf2);
8143 0 : if (arg1->email) free((char*)arg1->email);
8144 0 : if (arg2) {
8145 0 : size_t size = strlen((const char *)(arg2)) + 1;
8146 0 : arg1->email = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8147 : } else {
8148 0 : arg1->email = 0;
8149 : }
8150 0 : resultobj = SWIG_Py_Void();
8151 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8152 : return resultobj;
8153 : fail:
8154 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8155 : return NULL;
8156 : }
8157 :
8158 :
8159 64 : SWIGINTERN PyObject *_wrap__gpgme_user_id_email_get(PyObject *self, PyObject *args) {
8160 64 : PyObject *resultobj = 0;
8161 64 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8162 64 : void *argp1 = 0 ;
8163 64 : int res1 = 0 ;
8164 64 : char *result = 0 ;
8165 :
8166 64 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8167 64 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8168 64 : if (!SWIG_IsOK(res1)) {
8169 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_email_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8170 : }
8171 64 : arg1 = (struct _gpgme_user_id *)(argp1);
8172 64 : result = (char *) ((arg1)->email);
8173 64 : resultobj = SWIG_FromCharPtr((const char *)result);
8174 64 : return resultobj;
8175 : fail:
8176 : return NULL;
8177 : }
8178 :
8179 :
8180 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_comment_set(PyObject *self, PyObject *args) {
8181 0 : PyObject *resultobj = 0;
8182 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8183 0 : char *arg2 = (char *) 0 ;
8184 0 : void *argp1 = 0 ;
8185 0 : int res1 = 0 ;
8186 : int res2 ;
8187 0 : char *buf2 = 0 ;
8188 0 : int alloc2 = 0 ;
8189 0 : PyObject * obj1 = 0 ;
8190 :
8191 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_comment_set",&obj1)) SWIG_fail;
8192 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8193 0 : if (!SWIG_IsOK(res1)) {
8194 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_comment_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8195 : }
8196 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8197 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8198 0 : if (!SWIG_IsOK(res2)) {
8199 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_comment_set" "', argument " "2"" of type '" "char *""'");
8200 : }
8201 0 : arg2 = (char *)(buf2);
8202 0 : if (arg1->comment) free((char*)arg1->comment);
8203 0 : if (arg2) {
8204 0 : size_t size = strlen((const char *)(arg2)) + 1;
8205 0 : arg1->comment = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8206 : } else {
8207 0 : arg1->comment = 0;
8208 : }
8209 0 : resultobj = SWIG_Py_Void();
8210 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8211 : return resultobj;
8212 : fail:
8213 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8214 : return NULL;
8215 : }
8216 :
8217 :
8218 64 : SWIGINTERN PyObject *_wrap__gpgme_user_id_comment_get(PyObject *self, PyObject *args) {
8219 64 : PyObject *resultobj = 0;
8220 64 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8221 64 : void *argp1 = 0 ;
8222 64 : int res1 = 0 ;
8223 64 : char *result = 0 ;
8224 :
8225 64 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8226 64 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8227 64 : if (!SWIG_IsOK(res1)) {
8228 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_comment_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8229 : }
8230 64 : arg1 = (struct _gpgme_user_id *)(argp1);
8231 64 : result = (char *) ((arg1)->comment);
8232 64 : resultobj = SWIG_FromCharPtr((const char *)result);
8233 64 : return resultobj;
8234 : fail:
8235 : return NULL;
8236 : }
8237 :
8238 :
8239 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_signatures_set(PyObject *self, PyObject *args) {
8240 0 : PyObject *resultobj = 0;
8241 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8242 0 : gpgme_key_sig_t arg2 = (gpgme_key_sig_t) 0 ;
8243 0 : void *argp1 = 0 ;
8244 0 : int res1 = 0 ;
8245 0 : void *argp2 = 0 ;
8246 0 : int res2 = 0 ;
8247 0 : PyObject * obj1 = 0 ;
8248 :
8249 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_signatures_set",&obj1)) SWIG_fail;
8250 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8251 0 : if (!SWIG_IsOK(res1)) {
8252 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_signatures_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8253 : }
8254 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8255 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key_sig, SWIG_POINTER_DISOWN | 0 );
8256 0 : if (!SWIG_IsOK(res2)) {
8257 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_signatures_set" "', argument " "2"" of type '" "gpgme_key_sig_t""'");
8258 : }
8259 0 : arg2 = (gpgme_key_sig_t)(argp2);
8260 0 : if (arg1) (arg1)->signatures = arg2;
8261 0 : resultobj = SWIG_Py_Void();
8262 0 : return resultobj;
8263 : fail:
8264 : return NULL;
8265 : }
8266 :
8267 :
8268 64 : SWIGINTERN PyObject *_wrap__gpgme_user_id_signatures_get(PyObject *self, PyObject *args) {
8269 64 : PyObject *resultobj = 0;
8270 64 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8271 64 : void *argp1 = 0 ;
8272 64 : int res1 = 0 ;
8273 : gpgme_key_sig_t result;
8274 :
8275 64 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8276 64 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8277 64 : if (!SWIG_IsOK(res1)) {
8278 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_signatures_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8279 : }
8280 64 : arg1 = (struct _gpgme_user_id *)(argp1);
8281 64 : result = (gpgme_key_sig_t) ((arg1)->signatures);
8282 : {
8283 : int i;
8284 64 : int size = 0;
8285 : gpgme_key_sig_t curr;
8286 64 : for (curr = result; curr != NULL; curr = curr->next) {
8287 0 : size++;
8288 : }
8289 64 : resultobj = PyList_New(size);
8290 64 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
8291 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_key_sig, 0 );
8292 0 : PyList_SetItem(resultobj, i, o);
8293 : }
8294 : }
8295 : return resultobj;
8296 : fail:
8297 : return NULL;
8298 : }
8299 :
8300 :
8301 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__last_keysig_set(PyObject *self, PyObject *args) {
8302 0 : PyObject *resultobj = 0;
8303 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8304 0 : gpgme_key_sig_t arg2 = (gpgme_key_sig_t) 0 ;
8305 0 : void *argp1 = 0 ;
8306 0 : int res1 = 0 ;
8307 0 : void *argp2 = 0 ;
8308 0 : int res2 = 0 ;
8309 0 : PyObject * obj1 = 0 ;
8310 :
8311 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id__last_keysig_set",&obj1)) SWIG_fail;
8312 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8313 0 : if (!SWIG_IsOK(res1)) {
8314 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__last_keysig_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8315 : }
8316 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8317 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key_sig, SWIG_POINTER_DISOWN | 0 );
8318 0 : if (!SWIG_IsOK(res2)) {
8319 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id__last_keysig_set" "', argument " "2"" of type '" "gpgme_key_sig_t""'");
8320 : }
8321 0 : arg2 = (gpgme_key_sig_t)(argp2);
8322 0 : if (arg1) (arg1)->_last_keysig = arg2;
8323 0 : resultobj = SWIG_Py_Void();
8324 0 : return resultobj;
8325 : fail:
8326 : return NULL;
8327 : }
8328 :
8329 :
8330 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__last_keysig_get(PyObject *self, PyObject *args) {
8331 0 : PyObject *resultobj = 0;
8332 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8333 0 : void *argp1 = 0 ;
8334 0 : int res1 = 0 ;
8335 : gpgme_key_sig_t result;
8336 :
8337 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8338 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8339 0 : if (!SWIG_IsOK(res1)) {
8340 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__last_keysig_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8341 : }
8342 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8343 0 : result = (gpgme_key_sig_t) ((arg1)->_last_keysig);
8344 : {
8345 : int i;
8346 0 : int size = 0;
8347 : gpgme_key_sig_t curr;
8348 0 : for (curr = result; curr != NULL; curr = curr->next) {
8349 0 : size++;
8350 : }
8351 0 : resultobj = PyList_New(size);
8352 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
8353 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_key_sig, 0 );
8354 0 : PyList_SetItem(resultobj, i, o);
8355 : }
8356 : }
8357 : return resultobj;
8358 : fail:
8359 : return NULL;
8360 : }
8361 :
8362 :
8363 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_address_set(PyObject *self, PyObject *args) {
8364 0 : PyObject *resultobj = 0;
8365 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8366 0 : char *arg2 = (char *) 0 ;
8367 0 : void *argp1 = 0 ;
8368 0 : int res1 = 0 ;
8369 : int res2 ;
8370 0 : char *buf2 = 0 ;
8371 0 : int alloc2 = 0 ;
8372 0 : PyObject * obj1 = 0 ;
8373 :
8374 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_address_set",&obj1)) SWIG_fail;
8375 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8376 0 : if (!SWIG_IsOK(res1)) {
8377 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_address_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8378 : }
8379 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8380 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8381 0 : if (!SWIG_IsOK(res2)) {
8382 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_address_set" "', argument " "2"" of type '" "char *""'");
8383 : }
8384 0 : arg2 = (char *)(buf2);
8385 0 : if (arg1->address) free((char*)arg1->address);
8386 0 : if (arg2) {
8387 0 : size_t size = strlen((const char *)(arg2)) + 1;
8388 0 : arg1->address = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8389 : } else {
8390 0 : arg1->address = 0;
8391 : }
8392 0 : resultobj = SWIG_Py_Void();
8393 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8394 : return resultobj;
8395 : fail:
8396 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8397 : return NULL;
8398 : }
8399 :
8400 :
8401 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_address_get(PyObject *self, PyObject *args) {
8402 0 : PyObject *resultobj = 0;
8403 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8404 0 : void *argp1 = 0 ;
8405 0 : int res1 = 0 ;
8406 0 : char *result = 0 ;
8407 :
8408 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8409 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8410 0 : if (!SWIG_IsOK(res1)) {
8411 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_address_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8412 : }
8413 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8414 0 : result = (char *) ((arg1)->address);
8415 0 : resultobj = SWIG_FromCharPtr((const char *)result);
8416 0 : return resultobj;
8417 : fail:
8418 : return NULL;
8419 : }
8420 :
8421 :
8422 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_tofu_set(PyObject *self, PyObject *args) {
8423 0 : PyObject *resultobj = 0;
8424 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8425 0 : gpgme_tofu_info_t arg2 = (gpgme_tofu_info_t) 0 ;
8426 0 : void *argp1 = 0 ;
8427 0 : int res1 = 0 ;
8428 0 : void *argp2 = 0 ;
8429 0 : int res2 = 0 ;
8430 0 : PyObject * obj1 = 0 ;
8431 :
8432 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_tofu_set",&obj1)) SWIG_fail;
8433 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8434 0 : if (!SWIG_IsOK(res1)) {
8435 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_tofu_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8436 : }
8437 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8438 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_tofu_info, SWIG_POINTER_DISOWN | 0 );
8439 0 : if (!SWIG_IsOK(res2)) {
8440 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_tofu_set" "', argument " "2"" of type '" "gpgme_tofu_info_t""'");
8441 : }
8442 0 : arg2 = (gpgme_tofu_info_t)(argp2);
8443 0 : if (arg1) (arg1)->tofu = arg2;
8444 0 : resultobj = SWIG_Py_Void();
8445 0 : return resultobj;
8446 : fail:
8447 : return NULL;
8448 : }
8449 :
8450 :
8451 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_tofu_get(PyObject *self, PyObject *args) {
8452 0 : PyObject *resultobj = 0;
8453 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8454 0 : void *argp1 = 0 ;
8455 0 : int res1 = 0 ;
8456 : gpgme_tofu_info_t result;
8457 :
8458 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8459 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8460 0 : if (!SWIG_IsOK(res1)) {
8461 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_tofu_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8462 : }
8463 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8464 0 : result = (gpgme_tofu_info_t) ((arg1)->tofu);
8465 : {
8466 : int i;
8467 0 : int size = 0;
8468 : gpgme_tofu_info_t curr;
8469 0 : for (curr = result; curr != NULL; curr = curr->next) {
8470 0 : size++;
8471 : }
8472 0 : resultobj = PyList_New(size);
8473 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
8474 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_tofu_info, 0 );
8475 0 : PyList_SetItem(resultobj, i, o);
8476 : }
8477 : }
8478 : return resultobj;
8479 : fail:
8480 : return NULL;
8481 : }
8482 :
8483 :
8484 0 : SWIGINTERN int _wrap_new__gpgme_user_id(PyObject *self, PyObject *args) {
8485 0 : PyObject *resultobj = 0;
8486 0 : struct _gpgme_user_id *result = 0 ;
8487 :
8488 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8489 0 : result = (struct _gpgme_user_id *)calloc(1, sizeof(struct _gpgme_user_id));
8490 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_user_id, SWIG_BUILTIN_INIT | 0 );
8491 0 : return resultobj == Py_None ? -1 : 0;
8492 : fail:
8493 : return -1;
8494 : }
8495 :
8496 :
8497 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_user_id(PyObject *self, PyObject *args) {
8498 0 : PyObject *resultobj = 0;
8499 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8500 0 : void *argp1 = 0 ;
8501 0 : int res1 = 0 ;
8502 :
8503 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8504 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_user_id, SWIG_POINTER_DISOWN | 0 );
8505 0 : if (!SWIG_IsOK(res1)) {
8506 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_user_id" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8507 : }
8508 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8509 0 : free((char *) arg1);
8510 0 : resultobj = SWIG_Py_Void();
8511 0 : return resultobj;
8512 : fail:
8513 : return NULL;
8514 : }
8515 :
8516 :
8517 0 : SWIGINTERN PyObject *_wrap__gpgme_key__refs_set(PyObject *self, PyObject *args) {
8518 0 : PyObject *resultobj = 0;
8519 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8520 : unsigned int arg2 ;
8521 0 : void *argp1 = 0 ;
8522 0 : int res1 = 0 ;
8523 : unsigned int val2 ;
8524 0 : int ecode2 = 0 ;
8525 0 : PyObject * obj1 = 0 ;
8526 :
8527 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__refs_set",&obj1)) SWIG_fail;
8528 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8529 0 : if (!SWIG_IsOK(res1)) {
8530 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__refs_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8531 : }
8532 0 : arg1 = (struct _gpgme_key *)(argp1);
8533 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8534 0 : if (!SWIG_IsOK(ecode2)) {
8535 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key__refs_set" "', argument " "2"" of type '" "unsigned int""'");
8536 : }
8537 0 : arg2 = (unsigned int)(val2);
8538 0 : if (arg1) (arg1)->_refs = arg2;
8539 0 : resultobj = SWIG_Py_Void();
8540 0 : return resultobj;
8541 : fail:
8542 : return NULL;
8543 : }
8544 :
8545 :
8546 0 : SWIGINTERN PyObject *_wrap__gpgme_key__refs_get(PyObject *self, PyObject *args) {
8547 0 : PyObject *resultobj = 0;
8548 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8549 0 : void *argp1 = 0 ;
8550 0 : int res1 = 0 ;
8551 : unsigned int result;
8552 :
8553 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8554 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8555 0 : if (!SWIG_IsOK(res1)) {
8556 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__refs_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8557 : }
8558 0 : arg1 = (struct _gpgme_key *)(argp1);
8559 0 : result = (unsigned int) ((arg1)->_refs);
8560 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8561 0 : return resultobj;
8562 : fail:
8563 : return NULL;
8564 : }
8565 :
8566 :
8567 0 : SWIGINTERN PyObject *_wrap__gpgme_key_revoked_set(PyObject *self, PyObject *args) {
8568 0 : PyObject *resultobj = 0;
8569 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8570 : unsigned int arg2 ;
8571 0 : void *argp1 = 0 ;
8572 0 : int res1 = 0 ;
8573 : unsigned int val2 ;
8574 0 : int ecode2 = 0 ;
8575 0 : PyObject * obj1 = 0 ;
8576 :
8577 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_revoked_set",&obj1)) SWIG_fail;
8578 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8579 0 : if (!SWIG_IsOK(res1)) {
8580 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_revoked_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8581 : }
8582 0 : arg1 = (struct _gpgme_key *)(argp1);
8583 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8584 0 : if (!SWIG_IsOK(ecode2)) {
8585 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
8586 : }
8587 0 : arg2 = (unsigned int)(val2);
8588 0 : if (arg1) (arg1)->revoked = arg2;
8589 0 : resultobj = SWIG_Py_Void();
8590 0 : return resultobj;
8591 : fail:
8592 : return NULL;
8593 : }
8594 :
8595 :
8596 52 : SWIGINTERN PyObject *_wrap__gpgme_key_revoked_get(PyObject *self, PyObject *args) {
8597 52 : PyObject *resultobj = 0;
8598 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8599 52 : void *argp1 = 0 ;
8600 52 : int res1 = 0 ;
8601 : unsigned int result;
8602 :
8603 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8604 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8605 52 : if (!SWIG_IsOK(res1)) {
8606 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_revoked_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8607 : }
8608 52 : arg1 = (struct _gpgme_key *)(argp1);
8609 52 : result = (unsigned int) ((arg1)->revoked);
8610 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8611 52 : return resultobj;
8612 : fail:
8613 : return NULL;
8614 : }
8615 :
8616 :
8617 0 : SWIGINTERN PyObject *_wrap__gpgme_key_expired_set(PyObject *self, PyObject *args) {
8618 0 : PyObject *resultobj = 0;
8619 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8620 : unsigned int arg2 ;
8621 0 : void *argp1 = 0 ;
8622 0 : int res1 = 0 ;
8623 : unsigned int val2 ;
8624 0 : int ecode2 = 0 ;
8625 0 : PyObject * obj1 = 0 ;
8626 :
8627 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_expired_set",&obj1)) SWIG_fail;
8628 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8629 0 : if (!SWIG_IsOK(res1)) {
8630 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_expired_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8631 : }
8632 0 : arg1 = (struct _gpgme_key *)(argp1);
8633 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8634 0 : if (!SWIG_IsOK(ecode2)) {
8635 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_expired_set" "', argument " "2"" of type '" "unsigned int""'");
8636 : }
8637 0 : arg2 = (unsigned int)(val2);
8638 0 : if (arg1) (arg1)->expired = arg2;
8639 0 : resultobj = SWIG_Py_Void();
8640 0 : return resultobj;
8641 : fail:
8642 : return NULL;
8643 : }
8644 :
8645 :
8646 52 : SWIGINTERN PyObject *_wrap__gpgme_key_expired_get(PyObject *self, PyObject *args) {
8647 52 : PyObject *resultobj = 0;
8648 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8649 52 : void *argp1 = 0 ;
8650 52 : int res1 = 0 ;
8651 : unsigned int result;
8652 :
8653 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8654 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8655 52 : if (!SWIG_IsOK(res1)) {
8656 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_expired_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8657 : }
8658 52 : arg1 = (struct _gpgme_key *)(argp1);
8659 52 : result = (unsigned int) ((arg1)->expired);
8660 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8661 52 : return resultobj;
8662 : fail:
8663 : return NULL;
8664 : }
8665 :
8666 :
8667 0 : SWIGINTERN PyObject *_wrap__gpgme_key_disabled_set(PyObject *self, PyObject *args) {
8668 0 : PyObject *resultobj = 0;
8669 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8670 : unsigned int arg2 ;
8671 0 : void *argp1 = 0 ;
8672 0 : int res1 = 0 ;
8673 : unsigned int val2 ;
8674 0 : int ecode2 = 0 ;
8675 0 : PyObject * obj1 = 0 ;
8676 :
8677 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_disabled_set",&obj1)) SWIG_fail;
8678 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8679 0 : if (!SWIG_IsOK(res1)) {
8680 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_disabled_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8681 : }
8682 0 : arg1 = (struct _gpgme_key *)(argp1);
8683 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8684 0 : if (!SWIG_IsOK(ecode2)) {
8685 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_disabled_set" "', argument " "2"" of type '" "unsigned int""'");
8686 : }
8687 0 : arg2 = (unsigned int)(val2);
8688 0 : if (arg1) (arg1)->disabled = arg2;
8689 0 : resultobj = SWIG_Py_Void();
8690 0 : return resultobj;
8691 : fail:
8692 : return NULL;
8693 : }
8694 :
8695 :
8696 52 : SWIGINTERN PyObject *_wrap__gpgme_key_disabled_get(PyObject *self, PyObject *args) {
8697 52 : PyObject *resultobj = 0;
8698 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8699 52 : void *argp1 = 0 ;
8700 52 : int res1 = 0 ;
8701 : unsigned int result;
8702 :
8703 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8704 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8705 52 : if (!SWIG_IsOK(res1)) {
8706 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_disabled_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8707 : }
8708 52 : arg1 = (struct _gpgme_key *)(argp1);
8709 52 : result = (unsigned int) ((arg1)->disabled);
8710 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8711 52 : return resultobj;
8712 : fail:
8713 : return NULL;
8714 : }
8715 :
8716 :
8717 0 : SWIGINTERN PyObject *_wrap__gpgme_key_invalid_set(PyObject *self, PyObject *args) {
8718 0 : PyObject *resultobj = 0;
8719 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8720 : unsigned int arg2 ;
8721 0 : void *argp1 = 0 ;
8722 0 : int res1 = 0 ;
8723 : unsigned int val2 ;
8724 0 : int ecode2 = 0 ;
8725 0 : PyObject * obj1 = 0 ;
8726 :
8727 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_invalid_set",&obj1)) SWIG_fail;
8728 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8729 0 : if (!SWIG_IsOK(res1)) {
8730 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_invalid_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8731 : }
8732 0 : arg1 = (struct _gpgme_key *)(argp1);
8733 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8734 0 : if (!SWIG_IsOK(ecode2)) {
8735 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
8736 : }
8737 0 : arg2 = (unsigned int)(val2);
8738 0 : if (arg1) (arg1)->invalid = arg2;
8739 0 : resultobj = SWIG_Py_Void();
8740 0 : return resultobj;
8741 : fail:
8742 : return NULL;
8743 : }
8744 :
8745 :
8746 52 : SWIGINTERN PyObject *_wrap__gpgme_key_invalid_get(PyObject *self, PyObject *args) {
8747 52 : PyObject *resultobj = 0;
8748 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8749 52 : void *argp1 = 0 ;
8750 52 : int res1 = 0 ;
8751 : unsigned int result;
8752 :
8753 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8754 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8755 52 : if (!SWIG_IsOK(res1)) {
8756 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_invalid_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8757 : }
8758 52 : arg1 = (struct _gpgme_key *)(argp1);
8759 52 : result = (unsigned int) ((arg1)->invalid);
8760 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8761 52 : return resultobj;
8762 : fail:
8763 : return NULL;
8764 : }
8765 :
8766 :
8767 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_encrypt_set(PyObject *self, PyObject *args) {
8768 0 : PyObject *resultobj = 0;
8769 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8770 : unsigned int arg2 ;
8771 0 : void *argp1 = 0 ;
8772 0 : int res1 = 0 ;
8773 : unsigned int val2 ;
8774 0 : int ecode2 = 0 ;
8775 0 : PyObject * obj1 = 0 ;
8776 :
8777 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_encrypt_set",&obj1)) SWIG_fail;
8778 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8779 0 : if (!SWIG_IsOK(res1)) {
8780 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_encrypt_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8781 : }
8782 0 : arg1 = (struct _gpgme_key *)(argp1);
8783 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8784 0 : if (!SWIG_IsOK(ecode2)) {
8785 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_encrypt_set" "', argument " "2"" of type '" "unsigned int""'");
8786 : }
8787 0 : arg2 = (unsigned int)(val2);
8788 0 : if (arg1) (arg1)->can_encrypt = arg2;
8789 0 : resultobj = SWIG_Py_Void();
8790 0 : return resultobj;
8791 : fail:
8792 : return NULL;
8793 : }
8794 :
8795 :
8796 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_encrypt_get(PyObject *self, PyObject *args) {
8797 0 : PyObject *resultobj = 0;
8798 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8799 0 : void *argp1 = 0 ;
8800 0 : int res1 = 0 ;
8801 : unsigned int result;
8802 :
8803 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8804 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8805 0 : if (!SWIG_IsOK(res1)) {
8806 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_encrypt_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8807 : }
8808 0 : arg1 = (struct _gpgme_key *)(argp1);
8809 0 : result = (unsigned int) ((arg1)->can_encrypt);
8810 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8811 0 : return resultobj;
8812 : fail:
8813 : return NULL;
8814 : }
8815 :
8816 :
8817 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_sign_set(PyObject *self, PyObject *args) {
8818 0 : PyObject *resultobj = 0;
8819 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8820 : unsigned int arg2 ;
8821 0 : void *argp1 = 0 ;
8822 0 : int res1 = 0 ;
8823 : unsigned int val2 ;
8824 0 : int ecode2 = 0 ;
8825 0 : PyObject * obj1 = 0 ;
8826 :
8827 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_sign_set",&obj1)) SWIG_fail;
8828 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8829 0 : if (!SWIG_IsOK(res1)) {
8830 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_sign_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8831 : }
8832 0 : arg1 = (struct _gpgme_key *)(argp1);
8833 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8834 0 : if (!SWIG_IsOK(ecode2)) {
8835 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_sign_set" "', argument " "2"" of type '" "unsigned int""'");
8836 : }
8837 0 : arg2 = (unsigned int)(val2);
8838 0 : if (arg1) (arg1)->can_sign = arg2;
8839 0 : resultobj = SWIG_Py_Void();
8840 0 : return resultobj;
8841 : fail:
8842 : return NULL;
8843 : }
8844 :
8845 :
8846 52 : SWIGINTERN PyObject *_wrap__gpgme_key_can_sign_get(PyObject *self, PyObject *args) {
8847 52 : PyObject *resultobj = 0;
8848 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8849 52 : void *argp1 = 0 ;
8850 52 : int res1 = 0 ;
8851 : unsigned int result;
8852 :
8853 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8854 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8855 52 : if (!SWIG_IsOK(res1)) {
8856 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_sign_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8857 : }
8858 52 : arg1 = (struct _gpgme_key *)(argp1);
8859 52 : result = (unsigned int) ((arg1)->can_sign);
8860 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8861 52 : return resultobj;
8862 : fail:
8863 : return NULL;
8864 : }
8865 :
8866 :
8867 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_certify_set(PyObject *self, PyObject *args) {
8868 0 : PyObject *resultobj = 0;
8869 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8870 : unsigned int arg2 ;
8871 0 : void *argp1 = 0 ;
8872 0 : int res1 = 0 ;
8873 : unsigned int val2 ;
8874 0 : int ecode2 = 0 ;
8875 0 : PyObject * obj1 = 0 ;
8876 :
8877 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_certify_set",&obj1)) SWIG_fail;
8878 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8879 0 : if (!SWIG_IsOK(res1)) {
8880 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_certify_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8881 : }
8882 0 : arg1 = (struct _gpgme_key *)(argp1);
8883 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8884 0 : if (!SWIG_IsOK(ecode2)) {
8885 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_certify_set" "', argument " "2"" of type '" "unsigned int""'");
8886 : }
8887 0 : arg2 = (unsigned int)(val2);
8888 0 : if (arg1) (arg1)->can_certify = arg2;
8889 0 : resultobj = SWIG_Py_Void();
8890 0 : return resultobj;
8891 : fail:
8892 : return NULL;
8893 : }
8894 :
8895 :
8896 52 : SWIGINTERN PyObject *_wrap__gpgme_key_can_certify_get(PyObject *self, PyObject *args) {
8897 52 : PyObject *resultobj = 0;
8898 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8899 52 : void *argp1 = 0 ;
8900 52 : int res1 = 0 ;
8901 : unsigned int result;
8902 :
8903 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8904 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8905 52 : if (!SWIG_IsOK(res1)) {
8906 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_certify_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8907 : }
8908 52 : arg1 = (struct _gpgme_key *)(argp1);
8909 52 : result = (unsigned int) ((arg1)->can_certify);
8910 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8911 52 : return resultobj;
8912 : fail:
8913 : return NULL;
8914 : }
8915 :
8916 :
8917 0 : SWIGINTERN PyObject *_wrap__gpgme_key_secret_set(PyObject *self, PyObject *args) {
8918 0 : PyObject *resultobj = 0;
8919 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8920 : unsigned int arg2 ;
8921 0 : void *argp1 = 0 ;
8922 0 : int res1 = 0 ;
8923 : unsigned int val2 ;
8924 0 : int ecode2 = 0 ;
8925 0 : PyObject * obj1 = 0 ;
8926 :
8927 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_secret_set",&obj1)) SWIG_fail;
8928 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8929 0 : if (!SWIG_IsOK(res1)) {
8930 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_secret_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8931 : }
8932 0 : arg1 = (struct _gpgme_key *)(argp1);
8933 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8934 0 : if (!SWIG_IsOK(ecode2)) {
8935 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_secret_set" "', argument " "2"" of type '" "unsigned int""'");
8936 : }
8937 0 : arg2 = (unsigned int)(val2);
8938 0 : if (arg1) (arg1)->secret = arg2;
8939 0 : resultobj = SWIG_Py_Void();
8940 0 : return resultobj;
8941 : fail:
8942 : return NULL;
8943 : }
8944 :
8945 :
8946 52 : SWIGINTERN PyObject *_wrap__gpgme_key_secret_get(PyObject *self, PyObject *args) {
8947 52 : PyObject *resultobj = 0;
8948 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8949 52 : void *argp1 = 0 ;
8950 52 : int res1 = 0 ;
8951 : unsigned int result;
8952 :
8953 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
8954 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8955 52 : if (!SWIG_IsOK(res1)) {
8956 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_secret_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8957 : }
8958 52 : arg1 = (struct _gpgme_key *)(argp1);
8959 52 : result = (unsigned int) ((arg1)->secret);
8960 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8961 52 : return resultobj;
8962 : fail:
8963 : return NULL;
8964 : }
8965 :
8966 :
8967 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_authenticate_set(PyObject *self, PyObject *args) {
8968 0 : PyObject *resultobj = 0;
8969 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8970 : unsigned int arg2 ;
8971 0 : void *argp1 = 0 ;
8972 0 : int res1 = 0 ;
8973 : unsigned int val2 ;
8974 0 : int ecode2 = 0 ;
8975 0 : PyObject * obj1 = 0 ;
8976 :
8977 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_authenticate_set",&obj1)) SWIG_fail;
8978 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
8979 0 : if (!SWIG_IsOK(res1)) {
8980 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_authenticate_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
8981 : }
8982 0 : arg1 = (struct _gpgme_key *)(argp1);
8983 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8984 0 : if (!SWIG_IsOK(ecode2)) {
8985 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_authenticate_set" "', argument " "2"" of type '" "unsigned int""'");
8986 : }
8987 0 : arg2 = (unsigned int)(val2);
8988 0 : if (arg1) (arg1)->can_authenticate = arg2;
8989 0 : resultobj = SWIG_Py_Void();
8990 0 : return resultobj;
8991 : fail:
8992 : return NULL;
8993 : }
8994 :
8995 :
8996 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_authenticate_get(PyObject *self, PyObject *args) {
8997 0 : PyObject *resultobj = 0;
8998 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
8999 0 : void *argp1 = 0 ;
9000 0 : int res1 = 0 ;
9001 : unsigned int result;
9002 :
9003 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9004 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9005 0 : if (!SWIG_IsOK(res1)) {
9006 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_authenticate_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9007 : }
9008 0 : arg1 = (struct _gpgme_key *)(argp1);
9009 0 : result = (unsigned int) ((arg1)->can_authenticate);
9010 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9011 0 : return resultobj;
9012 : fail:
9013 : return NULL;
9014 : }
9015 :
9016 :
9017 0 : SWIGINTERN PyObject *_wrap__gpgme_key_is_qualified_set(PyObject *self, PyObject *args) {
9018 0 : PyObject *resultobj = 0;
9019 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9020 : unsigned int arg2 ;
9021 0 : void *argp1 = 0 ;
9022 0 : int res1 = 0 ;
9023 : unsigned int val2 ;
9024 0 : int ecode2 = 0 ;
9025 0 : PyObject * obj1 = 0 ;
9026 :
9027 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_is_qualified_set",&obj1)) SWIG_fail;
9028 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9029 0 : if (!SWIG_IsOK(res1)) {
9030 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_is_qualified_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9031 : }
9032 0 : arg1 = (struct _gpgme_key *)(argp1);
9033 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9034 0 : if (!SWIG_IsOK(ecode2)) {
9035 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_is_qualified_set" "', argument " "2"" of type '" "unsigned int""'");
9036 : }
9037 0 : arg2 = (unsigned int)(val2);
9038 0 : if (arg1) (arg1)->is_qualified = arg2;
9039 0 : resultobj = SWIG_Py_Void();
9040 0 : return resultobj;
9041 : fail:
9042 : return NULL;
9043 : }
9044 :
9045 :
9046 0 : SWIGINTERN PyObject *_wrap__gpgme_key_is_qualified_get(PyObject *self, PyObject *args) {
9047 0 : PyObject *resultobj = 0;
9048 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9049 0 : void *argp1 = 0 ;
9050 0 : int res1 = 0 ;
9051 : unsigned int result;
9052 :
9053 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9054 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9055 0 : if (!SWIG_IsOK(res1)) {
9056 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_is_qualified_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9057 : }
9058 0 : arg1 = (struct _gpgme_key *)(argp1);
9059 0 : result = (unsigned int) ((arg1)->is_qualified);
9060 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9061 0 : return resultobj;
9062 : fail:
9063 : return NULL;
9064 : }
9065 :
9066 :
9067 0 : SWIGINTERN PyObject *_wrap__gpgme_key__unused_set(PyObject *self, PyObject *args) {
9068 0 : PyObject *resultobj = 0;
9069 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9070 : unsigned int arg2 ;
9071 0 : void *argp1 = 0 ;
9072 0 : int res1 = 0 ;
9073 : unsigned int val2 ;
9074 0 : int ecode2 = 0 ;
9075 0 : PyObject * obj1 = 0 ;
9076 :
9077 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__unused_set",&obj1)) SWIG_fail;
9078 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9079 0 : if (!SWIG_IsOK(res1)) {
9080 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__unused_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9081 : }
9082 0 : arg1 = (struct _gpgme_key *)(argp1);
9083 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9084 0 : if (!SWIG_IsOK(ecode2)) {
9085 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key__unused_set" "', argument " "2"" of type '" "unsigned int""'");
9086 : }
9087 0 : arg2 = (unsigned int)(val2);
9088 0 : if (arg1) (arg1)->_unused = arg2;
9089 0 : resultobj = SWIG_Py_Void();
9090 0 : return resultobj;
9091 : fail:
9092 : return NULL;
9093 : }
9094 :
9095 :
9096 0 : SWIGINTERN PyObject *_wrap__gpgme_key__unused_get(PyObject *self, PyObject *args) {
9097 0 : PyObject *resultobj = 0;
9098 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9099 0 : void *argp1 = 0 ;
9100 0 : int res1 = 0 ;
9101 : unsigned int result;
9102 :
9103 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9104 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9105 0 : if (!SWIG_IsOK(res1)) {
9106 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__unused_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9107 : }
9108 0 : arg1 = (struct _gpgme_key *)(argp1);
9109 0 : result = (unsigned int) ((arg1)->_unused);
9110 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9111 0 : return resultobj;
9112 : fail:
9113 : return NULL;
9114 : }
9115 :
9116 :
9117 0 : SWIGINTERN PyObject *_wrap__gpgme_key_protocol_set(PyObject *self, PyObject *args) {
9118 0 : PyObject *resultobj = 0;
9119 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9120 : gpgme_protocol_t arg2 ;
9121 0 : void *argp1 = 0 ;
9122 0 : int res1 = 0 ;
9123 : int val2 ;
9124 0 : int ecode2 = 0 ;
9125 0 : PyObject * obj1 = 0 ;
9126 :
9127 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_protocol_set",&obj1)) SWIG_fail;
9128 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9129 0 : if (!SWIG_IsOK(res1)) {
9130 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_protocol_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9131 : }
9132 0 : arg1 = (struct _gpgme_key *)(argp1);
9133 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
9134 0 : if (!SWIG_IsOK(ecode2)) {
9135 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_protocol_set" "', argument " "2"" of type '" "gpgme_protocol_t""'");
9136 : }
9137 0 : arg2 = (gpgme_protocol_t)(val2);
9138 0 : if (arg1) (arg1)->protocol = arg2;
9139 0 : resultobj = SWIG_Py_Void();
9140 0 : return resultobj;
9141 : fail:
9142 : return NULL;
9143 : }
9144 :
9145 :
9146 52 : SWIGINTERN PyObject *_wrap__gpgme_key_protocol_get(PyObject *self, PyObject *args) {
9147 52 : PyObject *resultobj = 0;
9148 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9149 52 : void *argp1 = 0 ;
9150 52 : int res1 = 0 ;
9151 : gpgme_protocol_t result;
9152 :
9153 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9154 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9155 52 : if (!SWIG_IsOK(res1)) {
9156 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_protocol_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9157 : }
9158 52 : arg1 = (struct _gpgme_key *)(argp1);
9159 52 : result = (gpgme_protocol_t) ((arg1)->protocol);
9160 104 : resultobj = SWIG_From_int((int)(result));
9161 52 : return resultobj;
9162 : fail:
9163 : return NULL;
9164 : }
9165 :
9166 :
9167 0 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_serial_set(PyObject *self, PyObject *args) {
9168 0 : PyObject *resultobj = 0;
9169 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9170 0 : char *arg2 = (char *) 0 ;
9171 0 : void *argp1 = 0 ;
9172 0 : int res1 = 0 ;
9173 : int res2 ;
9174 0 : char *buf2 = 0 ;
9175 0 : int alloc2 = 0 ;
9176 0 : PyObject * obj1 = 0 ;
9177 :
9178 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_issuer_serial_set",&obj1)) SWIG_fail;
9179 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9180 0 : if (!SWIG_IsOK(res1)) {
9181 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_serial_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9182 : }
9183 0 : arg1 = (struct _gpgme_key *)(argp1);
9184 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9185 0 : if (!SWIG_IsOK(res2)) {
9186 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_issuer_serial_set" "', argument " "2"" of type '" "char *""'");
9187 : }
9188 0 : arg2 = (char *)(buf2);
9189 0 : if (arg1->issuer_serial) free((char*)arg1->issuer_serial);
9190 0 : if (arg2) {
9191 0 : size_t size = strlen((const char *)(arg2)) + 1;
9192 0 : arg1->issuer_serial = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
9193 : } else {
9194 0 : arg1->issuer_serial = 0;
9195 : }
9196 0 : resultobj = SWIG_Py_Void();
9197 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9198 : return resultobj;
9199 : fail:
9200 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9201 : return NULL;
9202 : }
9203 :
9204 :
9205 52 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_serial_get(PyObject *self, PyObject *args) {
9206 52 : PyObject *resultobj = 0;
9207 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9208 52 : void *argp1 = 0 ;
9209 52 : int res1 = 0 ;
9210 52 : char *result = 0 ;
9211 :
9212 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9213 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9214 52 : if (!SWIG_IsOK(res1)) {
9215 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_serial_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9216 : }
9217 52 : arg1 = (struct _gpgme_key *)(argp1);
9218 52 : result = (char *) ((arg1)->issuer_serial);
9219 52 : resultobj = SWIG_FromCharPtr((const char *)result);
9220 52 : return resultobj;
9221 : fail:
9222 : return NULL;
9223 : }
9224 :
9225 :
9226 0 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_name_set(PyObject *self, PyObject *args) {
9227 0 : PyObject *resultobj = 0;
9228 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9229 0 : char *arg2 = (char *) 0 ;
9230 0 : void *argp1 = 0 ;
9231 0 : int res1 = 0 ;
9232 : int res2 ;
9233 0 : char *buf2 = 0 ;
9234 0 : int alloc2 = 0 ;
9235 0 : PyObject * obj1 = 0 ;
9236 :
9237 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_issuer_name_set",&obj1)) SWIG_fail;
9238 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9239 0 : if (!SWIG_IsOK(res1)) {
9240 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_name_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9241 : }
9242 0 : arg1 = (struct _gpgme_key *)(argp1);
9243 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9244 0 : if (!SWIG_IsOK(res2)) {
9245 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_issuer_name_set" "', argument " "2"" of type '" "char *""'");
9246 : }
9247 0 : arg2 = (char *)(buf2);
9248 0 : if (arg1->issuer_name) free((char*)arg1->issuer_name);
9249 0 : if (arg2) {
9250 0 : size_t size = strlen((const char *)(arg2)) + 1;
9251 0 : arg1->issuer_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
9252 : } else {
9253 0 : arg1->issuer_name = 0;
9254 : }
9255 0 : resultobj = SWIG_Py_Void();
9256 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9257 : return resultobj;
9258 : fail:
9259 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9260 : return NULL;
9261 : }
9262 :
9263 :
9264 52 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_name_get(PyObject *self, PyObject *args) {
9265 52 : PyObject *resultobj = 0;
9266 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9267 52 : void *argp1 = 0 ;
9268 52 : int res1 = 0 ;
9269 52 : char *result = 0 ;
9270 :
9271 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9272 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9273 52 : if (!SWIG_IsOK(res1)) {
9274 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_name_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9275 : }
9276 52 : arg1 = (struct _gpgme_key *)(argp1);
9277 52 : result = (char *) ((arg1)->issuer_name);
9278 52 : resultobj = SWIG_FromCharPtr((const char *)result);
9279 52 : return resultobj;
9280 : fail:
9281 : return NULL;
9282 : }
9283 :
9284 :
9285 0 : SWIGINTERN PyObject *_wrap__gpgme_key_chain_id_set(PyObject *self, PyObject *args) {
9286 0 : PyObject *resultobj = 0;
9287 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9288 0 : char *arg2 = (char *) 0 ;
9289 0 : void *argp1 = 0 ;
9290 0 : int res1 = 0 ;
9291 : int res2 ;
9292 0 : char *buf2 = 0 ;
9293 0 : int alloc2 = 0 ;
9294 0 : PyObject * obj1 = 0 ;
9295 :
9296 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_chain_id_set",&obj1)) SWIG_fail;
9297 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9298 0 : if (!SWIG_IsOK(res1)) {
9299 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_chain_id_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9300 : }
9301 0 : arg1 = (struct _gpgme_key *)(argp1);
9302 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9303 0 : if (!SWIG_IsOK(res2)) {
9304 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_chain_id_set" "', argument " "2"" of type '" "char *""'");
9305 : }
9306 0 : arg2 = (char *)(buf2);
9307 0 : if (arg1->chain_id) free((char*)arg1->chain_id);
9308 0 : if (arg2) {
9309 0 : size_t size = strlen((const char *)(arg2)) + 1;
9310 0 : arg1->chain_id = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
9311 : } else {
9312 0 : arg1->chain_id = 0;
9313 : }
9314 0 : resultobj = SWIG_Py_Void();
9315 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9316 : return resultobj;
9317 : fail:
9318 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9319 : return NULL;
9320 : }
9321 :
9322 :
9323 52 : SWIGINTERN PyObject *_wrap__gpgme_key_chain_id_get(PyObject *self, PyObject *args) {
9324 52 : PyObject *resultobj = 0;
9325 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9326 52 : void *argp1 = 0 ;
9327 52 : int res1 = 0 ;
9328 52 : char *result = 0 ;
9329 :
9330 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9331 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9332 52 : if (!SWIG_IsOK(res1)) {
9333 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_chain_id_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9334 : }
9335 52 : arg1 = (struct _gpgme_key *)(argp1);
9336 52 : result = (char *) ((arg1)->chain_id);
9337 52 : resultobj = SWIG_FromCharPtr((const char *)result);
9338 52 : return resultobj;
9339 : fail:
9340 : return NULL;
9341 : }
9342 :
9343 :
9344 0 : SWIGINTERN PyObject *_wrap__gpgme_key_owner_trust_set(PyObject *self, PyObject *args) {
9345 0 : PyObject *resultobj = 0;
9346 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9347 : gpgme_validity_t arg2 ;
9348 0 : void *argp1 = 0 ;
9349 0 : int res1 = 0 ;
9350 : int val2 ;
9351 0 : int ecode2 = 0 ;
9352 0 : PyObject * obj1 = 0 ;
9353 :
9354 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_owner_trust_set",&obj1)) SWIG_fail;
9355 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9356 0 : if (!SWIG_IsOK(res1)) {
9357 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_owner_trust_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9358 : }
9359 0 : arg1 = (struct _gpgme_key *)(argp1);
9360 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
9361 0 : if (!SWIG_IsOK(ecode2)) {
9362 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_owner_trust_set" "', argument " "2"" of type '" "gpgme_validity_t""'");
9363 : }
9364 0 : arg2 = (gpgme_validity_t)(val2);
9365 0 : if (arg1) (arg1)->owner_trust = arg2;
9366 0 : resultobj = SWIG_Py_Void();
9367 0 : return resultobj;
9368 : fail:
9369 : return NULL;
9370 : }
9371 :
9372 :
9373 52 : SWIGINTERN PyObject *_wrap__gpgme_key_owner_trust_get(PyObject *self, PyObject *args) {
9374 52 : PyObject *resultobj = 0;
9375 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9376 52 : void *argp1 = 0 ;
9377 52 : int res1 = 0 ;
9378 : gpgme_validity_t result;
9379 :
9380 52 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9381 52 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9382 52 : if (!SWIG_IsOK(res1)) {
9383 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_owner_trust_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9384 : }
9385 52 : arg1 = (struct _gpgme_key *)(argp1);
9386 52 : result = (gpgme_validity_t) ((arg1)->owner_trust);
9387 104 : resultobj = SWIG_From_int((int)(result));
9388 52 : return resultobj;
9389 : fail:
9390 : return NULL;
9391 : }
9392 :
9393 :
9394 0 : SWIGINTERN PyObject *_wrap__gpgme_key_subkeys_set(PyObject *self, PyObject *args) {
9395 0 : PyObject *resultobj = 0;
9396 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9397 0 : gpgme_subkey_t arg2 = (gpgme_subkey_t) 0 ;
9398 0 : void *argp1 = 0 ;
9399 0 : int res1 = 0 ;
9400 0 : void *argp2 = 0 ;
9401 0 : int res2 = 0 ;
9402 0 : PyObject * obj1 = 0 ;
9403 :
9404 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_subkeys_set",&obj1)) SWIG_fail;
9405 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9406 0 : if (!SWIG_IsOK(res1)) {
9407 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_subkeys_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9408 : }
9409 0 : arg1 = (struct _gpgme_key *)(argp1);
9410 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_subkey, SWIG_POINTER_DISOWN | 0 );
9411 0 : if (!SWIG_IsOK(res2)) {
9412 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_subkeys_set" "', argument " "2"" of type '" "gpgme_subkey_t""'");
9413 : }
9414 0 : arg2 = (gpgme_subkey_t)(argp2);
9415 0 : if (arg1) (arg1)->subkeys = arg2;
9416 0 : resultobj = SWIG_Py_Void();
9417 0 : return resultobj;
9418 : fail:
9419 : return NULL;
9420 : }
9421 :
9422 :
9423 166 : SWIGINTERN PyObject *_wrap__gpgme_key_subkeys_get(PyObject *self, PyObject *args) {
9424 166 : PyObject *resultobj = 0;
9425 166 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9426 166 : void *argp1 = 0 ;
9427 166 : int res1 = 0 ;
9428 : gpgme_subkey_t result;
9429 :
9430 166 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9431 166 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9432 166 : if (!SWIG_IsOK(res1)) {
9433 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_subkeys_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9434 : }
9435 166 : arg1 = (struct _gpgme_key *)(argp1);
9436 166 : result = (gpgme_subkey_t) ((arg1)->subkeys);
9437 : {
9438 : int i;
9439 166 : int size = 0;
9440 : gpgme_subkey_t curr;
9441 518 : for (curr = result; curr != NULL; curr = curr->next) {
9442 352 : size++;
9443 : }
9444 166 : resultobj = PyList_New(size);
9445 518 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
9446 352 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_subkey, 0 );
9447 352 : PyList_SetItem(resultobj, i, o);
9448 : }
9449 : }
9450 : return resultobj;
9451 : fail:
9452 : return NULL;
9453 : }
9454 :
9455 :
9456 0 : SWIGINTERN PyObject *_wrap__gpgme_key_uids_set(PyObject *self, PyObject *args) {
9457 0 : PyObject *resultobj = 0;
9458 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9459 0 : gpgme_user_id_t arg2 = (gpgme_user_id_t) 0 ;
9460 0 : void *argp1 = 0 ;
9461 0 : int res1 = 0 ;
9462 0 : void *argp2 = 0 ;
9463 0 : int res2 = 0 ;
9464 0 : PyObject * obj1 = 0 ;
9465 :
9466 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_uids_set",&obj1)) SWIG_fail;
9467 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9468 0 : if (!SWIG_IsOK(res1)) {
9469 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_uids_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9470 : }
9471 0 : arg1 = (struct _gpgme_key *)(argp1);
9472 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_user_id, SWIG_POINTER_DISOWN | 0 );
9473 0 : if (!SWIG_IsOK(res2)) {
9474 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_uids_set" "', argument " "2"" of type '" "gpgme_user_id_t""'");
9475 : }
9476 0 : arg2 = (gpgme_user_id_t)(argp2);
9477 0 : if (arg1) (arg1)->uids = arg2;
9478 0 : resultobj = SWIG_Py_Void();
9479 0 : return resultobj;
9480 : fail:
9481 : return NULL;
9482 : }
9483 :
9484 :
9485 324 : SWIGINTERN PyObject *_wrap__gpgme_key_uids_get(PyObject *self, PyObject *args) {
9486 324 : PyObject *resultobj = 0;
9487 324 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9488 324 : void *argp1 = 0 ;
9489 324 : int res1 = 0 ;
9490 : gpgme_user_id_t result;
9491 :
9492 324 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9493 324 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9494 324 : if (!SWIG_IsOK(res1)) {
9495 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_uids_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9496 : }
9497 324 : arg1 = (struct _gpgme_key *)(argp1);
9498 324 : result = (gpgme_user_id_t) ((arg1)->uids);
9499 : {
9500 : int i;
9501 324 : int size = 0;
9502 : gpgme_user_id_t curr;
9503 740 : for (curr = result; curr != NULL; curr = curr->next) {
9504 416 : size++;
9505 : }
9506 324 : resultobj = PyList_New(size);
9507 740 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
9508 416 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_user_id, 0 );
9509 416 : PyList_SetItem(resultobj, i, o);
9510 : }
9511 : }
9512 : return resultobj;
9513 : fail:
9514 : return NULL;
9515 : }
9516 :
9517 :
9518 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_subkey_set(PyObject *self, PyObject *args) {
9519 0 : PyObject *resultobj = 0;
9520 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9521 0 : gpgme_subkey_t arg2 = (gpgme_subkey_t) 0 ;
9522 0 : void *argp1 = 0 ;
9523 0 : int res1 = 0 ;
9524 0 : void *argp2 = 0 ;
9525 0 : int res2 = 0 ;
9526 0 : PyObject * obj1 = 0 ;
9527 :
9528 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__last_subkey_set",&obj1)) SWIG_fail;
9529 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9530 0 : if (!SWIG_IsOK(res1)) {
9531 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_subkey_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9532 : }
9533 0 : arg1 = (struct _gpgme_key *)(argp1);
9534 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_subkey, SWIG_POINTER_DISOWN | 0 );
9535 0 : if (!SWIG_IsOK(res2)) {
9536 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key__last_subkey_set" "', argument " "2"" of type '" "gpgme_subkey_t""'");
9537 : }
9538 0 : arg2 = (gpgme_subkey_t)(argp2);
9539 0 : if (arg1) (arg1)->_last_subkey = arg2;
9540 0 : resultobj = SWIG_Py_Void();
9541 0 : return resultobj;
9542 : fail:
9543 : return NULL;
9544 : }
9545 :
9546 :
9547 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_subkey_get(PyObject *self, PyObject *args) {
9548 0 : PyObject *resultobj = 0;
9549 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9550 0 : void *argp1 = 0 ;
9551 0 : int res1 = 0 ;
9552 : gpgme_subkey_t result;
9553 :
9554 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9555 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9556 0 : if (!SWIG_IsOK(res1)) {
9557 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_subkey_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9558 : }
9559 0 : arg1 = (struct _gpgme_key *)(argp1);
9560 0 : result = (gpgme_subkey_t) ((arg1)->_last_subkey);
9561 : {
9562 : int i;
9563 0 : int size = 0;
9564 : gpgme_subkey_t curr;
9565 0 : for (curr = result; curr != NULL; curr = curr->next) {
9566 0 : size++;
9567 : }
9568 0 : resultobj = PyList_New(size);
9569 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
9570 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_subkey, 0 );
9571 0 : PyList_SetItem(resultobj, i, o);
9572 : }
9573 : }
9574 : return resultobj;
9575 : fail:
9576 : return NULL;
9577 : }
9578 :
9579 :
9580 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_uid_set(PyObject *self, PyObject *args) {
9581 0 : PyObject *resultobj = 0;
9582 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9583 0 : gpgme_user_id_t arg2 = (gpgme_user_id_t) 0 ;
9584 0 : void *argp1 = 0 ;
9585 0 : int res1 = 0 ;
9586 0 : void *argp2 = 0 ;
9587 0 : int res2 = 0 ;
9588 0 : PyObject * obj1 = 0 ;
9589 :
9590 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__last_uid_set",&obj1)) SWIG_fail;
9591 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9592 0 : if (!SWIG_IsOK(res1)) {
9593 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_uid_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9594 : }
9595 0 : arg1 = (struct _gpgme_key *)(argp1);
9596 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_user_id, SWIG_POINTER_DISOWN | 0 );
9597 0 : if (!SWIG_IsOK(res2)) {
9598 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key__last_uid_set" "', argument " "2"" of type '" "gpgme_user_id_t""'");
9599 : }
9600 0 : arg2 = (gpgme_user_id_t)(argp2);
9601 0 : if (arg1) (arg1)->_last_uid = arg2;
9602 0 : resultobj = SWIG_Py_Void();
9603 0 : return resultobj;
9604 : fail:
9605 : return NULL;
9606 : }
9607 :
9608 :
9609 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_uid_get(PyObject *self, PyObject *args) {
9610 0 : PyObject *resultobj = 0;
9611 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9612 0 : void *argp1 = 0 ;
9613 0 : int res1 = 0 ;
9614 : gpgme_user_id_t result;
9615 :
9616 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9617 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9618 0 : if (!SWIG_IsOK(res1)) {
9619 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_uid_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9620 : }
9621 0 : arg1 = (struct _gpgme_key *)(argp1);
9622 0 : result = (gpgme_user_id_t) ((arg1)->_last_uid);
9623 : {
9624 : int i;
9625 0 : int size = 0;
9626 : gpgme_user_id_t curr;
9627 0 : for (curr = result; curr != NULL; curr = curr->next) {
9628 0 : size++;
9629 : }
9630 0 : resultobj = PyList_New(size);
9631 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
9632 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_user_id, 0 );
9633 0 : PyList_SetItem(resultobj, i, o);
9634 : }
9635 : }
9636 : return resultobj;
9637 : fail:
9638 : return NULL;
9639 : }
9640 :
9641 :
9642 0 : SWIGINTERN PyObject *_wrap__gpgme_key_keylist_mode_set(PyObject *self, PyObject *args) {
9643 0 : PyObject *resultobj = 0;
9644 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9645 : gpgme_keylist_mode_t arg2 ;
9646 0 : void *argp1 = 0 ;
9647 0 : int res1 = 0 ;
9648 : unsigned int val2 ;
9649 0 : int ecode2 = 0 ;
9650 0 : PyObject * obj1 = 0 ;
9651 :
9652 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_keylist_mode_set",&obj1)) SWIG_fail;
9653 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9654 0 : if (!SWIG_IsOK(res1)) {
9655 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_keylist_mode_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9656 : }
9657 0 : arg1 = (struct _gpgme_key *)(argp1);
9658 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9659 0 : if (!SWIG_IsOK(ecode2)) {
9660 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_keylist_mode_set" "', argument " "2"" of type '" "gpgme_keylist_mode_t""'");
9661 : }
9662 0 : arg2 = (gpgme_keylist_mode_t)(val2);
9663 0 : if (arg1) (arg1)->keylist_mode = arg2;
9664 0 : resultobj = SWIG_Py_Void();
9665 0 : return resultobj;
9666 : fail:
9667 : return NULL;
9668 : }
9669 :
9670 :
9671 0 : SWIGINTERN PyObject *_wrap__gpgme_key_keylist_mode_get(PyObject *self, PyObject *args) {
9672 0 : PyObject *resultobj = 0;
9673 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9674 0 : void *argp1 = 0 ;
9675 0 : int res1 = 0 ;
9676 : gpgme_keylist_mode_t result;
9677 :
9678 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9679 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9680 0 : if (!SWIG_IsOK(res1)) {
9681 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_keylist_mode_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9682 : }
9683 0 : arg1 = (struct _gpgme_key *)(argp1);
9684 0 : result = (gpgme_keylist_mode_t) ((arg1)->keylist_mode);
9685 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9686 0 : return resultobj;
9687 : fail:
9688 : return NULL;
9689 : }
9690 :
9691 :
9692 0 : SWIGINTERN PyObject *_wrap__gpgme_key_fpr_set(PyObject *self, PyObject *args) {
9693 0 : PyObject *resultobj = 0;
9694 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9695 0 : char *arg2 = (char *) 0 ;
9696 0 : void *argp1 = 0 ;
9697 0 : int res1 = 0 ;
9698 : int res2 ;
9699 0 : char *buf2 = 0 ;
9700 0 : int alloc2 = 0 ;
9701 0 : PyObject * obj1 = 0 ;
9702 :
9703 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_fpr_set",&obj1)) SWIG_fail;
9704 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9705 0 : if (!SWIG_IsOK(res1)) {
9706 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_fpr_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9707 : }
9708 0 : arg1 = (struct _gpgme_key *)(argp1);
9709 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9710 0 : if (!SWIG_IsOK(res2)) {
9711 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_fpr_set" "', argument " "2"" of type '" "char *""'");
9712 : }
9713 0 : arg2 = (char *)(buf2);
9714 0 : if (arg1->fpr) free((char*)arg1->fpr);
9715 0 : if (arg2) {
9716 0 : size_t size = strlen((const char *)(arg2)) + 1;
9717 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
9718 : } else {
9719 0 : arg1->fpr = 0;
9720 : }
9721 0 : resultobj = SWIG_Py_Void();
9722 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9723 : return resultobj;
9724 : fail:
9725 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9726 : return NULL;
9727 : }
9728 :
9729 :
9730 0 : SWIGINTERN PyObject *_wrap__gpgme_key_fpr_get(PyObject *self, PyObject *args) {
9731 0 : PyObject *resultobj = 0;
9732 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9733 0 : void *argp1 = 0 ;
9734 0 : int res1 = 0 ;
9735 0 : char *result = 0 ;
9736 :
9737 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9738 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9739 0 : if (!SWIG_IsOK(res1)) {
9740 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_fpr_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9741 : }
9742 0 : arg1 = (struct _gpgme_key *)(argp1);
9743 0 : result = (char *) ((arg1)->fpr);
9744 0 : resultobj = SWIG_FromCharPtr((const char *)result);
9745 0 : return resultobj;
9746 : fail:
9747 : return NULL;
9748 : }
9749 :
9750 :
9751 0 : SWIGINTERN int _wrap_new__gpgme_key(PyObject *self, PyObject *args) {
9752 0 : PyObject *resultobj = 0;
9753 0 : struct _gpgme_key *result = 0 ;
9754 :
9755 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9756 0 : result = (struct _gpgme_key *)calloc(1, sizeof(struct _gpgme_key));
9757 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, SWIG_BUILTIN_INIT | 0 );
9758 0 : return resultobj == Py_None ? -1 : 0;
9759 : fail:
9760 : return -1;
9761 : }
9762 :
9763 :
9764 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_key(PyObject *self, PyObject *args) {
9765 0 : PyObject *resultobj = 0;
9766 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9767 0 : void *argp1 = 0 ;
9768 0 : int res1 = 0 ;
9769 :
9770 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9771 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_key, SWIG_POINTER_DISOWN | 0 );
9772 0 : if (!SWIG_IsOK(res1)) {
9773 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_key" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9774 : }
9775 0 : arg1 = (struct _gpgme_key *)(argp1);
9776 0 : free((char *) arg1);
9777 0 : resultobj = SWIG_Py_Void();
9778 0 : return resultobj;
9779 : fail:
9780 : return NULL;
9781 : }
9782 :
9783 :
9784 0 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_fpr_set(PyObject *self, PyObject *args) {
9785 0 : PyObject *resultobj = 0;
9786 0 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
9787 0 : char *arg2 = (char *) 0 ;
9788 0 : void *argp1 = 0 ;
9789 0 : int res1 = 0 ;
9790 : int res2 ;
9791 0 : char *buf2 = 0 ;
9792 0 : int alloc2 = 0 ;
9793 0 : PyObject * obj1 = 0 ;
9794 :
9795 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_invalid_key_fpr_set",&obj1)) SWIG_fail;
9796 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
9797 0 : if (!SWIG_IsOK(res1)) {
9798 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_fpr_set" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
9799 : }
9800 0 : arg1 = (struct _gpgme_invalid_key *)(argp1);
9801 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9802 0 : if (!SWIG_IsOK(res2)) {
9803 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_invalid_key_fpr_set" "', argument " "2"" of type '" "char *""'");
9804 : }
9805 0 : arg2 = (char *)(buf2);
9806 0 : if (arg1->fpr) free((char*)arg1->fpr);
9807 0 : if (arg2) {
9808 0 : size_t size = strlen((const char *)(arg2)) + 1;
9809 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
9810 : } else {
9811 0 : arg1->fpr = 0;
9812 : }
9813 0 : resultobj = SWIG_Py_Void();
9814 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9815 : return resultobj;
9816 : fail:
9817 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9818 : return NULL;
9819 : }
9820 :
9821 :
9822 3 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_fpr_get(PyObject *self, PyObject *args) {
9823 3 : PyObject *resultobj = 0;
9824 3 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
9825 3 : void *argp1 = 0 ;
9826 3 : int res1 = 0 ;
9827 3 : char *result = 0 ;
9828 :
9829 3 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9830 3 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
9831 3 : if (!SWIG_IsOK(res1)) {
9832 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_fpr_get" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
9833 : }
9834 3 : arg1 = (struct _gpgme_invalid_key *)(argp1);
9835 3 : result = (char *) ((arg1)->fpr);
9836 3 : resultobj = SWIG_FromCharPtr((const char *)result);
9837 3 : return resultobj;
9838 : fail:
9839 : return NULL;
9840 : }
9841 :
9842 :
9843 0 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_reason_set(PyObject *self, PyObject *args) {
9844 0 : PyObject *resultobj = 0;
9845 0 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
9846 : gpgme_error_t arg2 ;
9847 0 : void *argp1 = 0 ;
9848 0 : int res1 = 0 ;
9849 0 : PyObject * obj1 = 0 ;
9850 :
9851 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_invalid_key_reason_set",&obj1)) SWIG_fail;
9852 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
9853 0 : if (!SWIG_IsOK(res1)) {
9854 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_reason_set" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
9855 : }
9856 0 : arg1 = (struct _gpgme_invalid_key *)(argp1);
9857 : {
9858 0 : arg2 = PyLong_AsLong(obj1);
9859 : }
9860 0 : if (arg1) (arg1)->reason = arg2;
9861 0 : resultobj = SWIG_Py_Void();
9862 0 : return resultobj;
9863 : fail:
9864 : return NULL;
9865 : }
9866 :
9867 :
9868 3 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_reason_get(PyObject *self, PyObject *args) {
9869 3 : PyObject *resultobj = 0;
9870 3 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
9871 3 : void *argp1 = 0 ;
9872 3 : int res1 = 0 ;
9873 : gpgme_error_t result;
9874 :
9875 3 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9876 3 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
9877 3 : if (!SWIG_IsOK(res1)) {
9878 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_reason_get" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
9879 : }
9880 3 : arg1 = (struct _gpgme_invalid_key *)(argp1);
9881 3 : result = ((arg1)->reason);
9882 : {
9883 3 : resultobj = PyLong_FromLong(result);
9884 : }
9885 3 : return resultobj;
9886 : fail:
9887 : return NULL;
9888 : }
9889 :
9890 :
9891 0 : SWIGINTERN int _wrap_new__gpgme_invalid_key(PyObject *self, PyObject *args) {
9892 0 : PyObject *resultobj = 0;
9893 0 : struct _gpgme_invalid_key *result = 0 ;
9894 :
9895 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9896 0 : result = (struct _gpgme_invalid_key *)calloc(1, sizeof(struct _gpgme_invalid_key));
9897 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_invalid_key, SWIG_BUILTIN_INIT | 0 );
9898 0 : return resultobj == Py_None ? -1 : 0;
9899 : fail:
9900 : return -1;
9901 : }
9902 :
9903 :
9904 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_invalid_key(PyObject *self, PyObject *args) {
9905 0 : PyObject *resultobj = 0;
9906 0 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
9907 0 : void *argp1 = 0 ;
9908 0 : int res1 = 0 ;
9909 :
9910 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
9911 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_invalid_key, SWIG_POINTER_DISOWN | 0 );
9912 0 : if (!SWIG_IsOK(res1)) {
9913 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_invalid_key" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
9914 : }
9915 0 : arg1 = (struct _gpgme_invalid_key *)(argp1);
9916 0 : free((char *) arg1);
9917 0 : resultobj = SWIG_Py_Void();
9918 0 : return resultobj;
9919 : fail:
9920 : return NULL;
9921 : }
9922 :
9923 :
9924 42 : SWIGINTERN PyObject *_wrap_gpgme_new(PyObject *self, PyObject *args) {
9925 42 : PyObject *resultobj = 0;
9926 42 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
9927 42 : void *argp1 = 0 ;
9928 42 : int res1 = 0 ;
9929 42 : PyObject * obj0 = 0 ;
9930 : gpgme_error_t result;
9931 :
9932 42 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_new",&obj0)) SWIG_fail;
9933 42 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
9934 42 : if (!SWIG_IsOK(res1)) {
9935 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_new" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
9936 : }
9937 42 : arg1 = (gpgme_ctx_t *)(argp1);
9938 42 : result = gpgme_new(arg1);
9939 : {
9940 42 : resultobj = PyLong_FromLong(result);
9941 : }
9942 42 : return resultobj;
9943 : fail:
9944 : return NULL;
9945 : }
9946 :
9947 :
9948 38 : SWIGINTERN PyObject *_wrap_gpgme_release(PyObject *self, PyObject *args) {
9949 38 : PyObject *resultobj = 0;
9950 38 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
9951 38 : void *argp1 = 0 ;
9952 38 : int res1 = 0 ;
9953 38 : PyObject * obj0 = 0 ;
9954 :
9955 38 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_release",&obj0)) SWIG_fail;
9956 38 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
9957 38 : if (!SWIG_IsOK(res1)) {
9958 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_release" "', argument " "1"" of type '" "gpgme_ctx_t""'");
9959 : }
9960 38 : arg1 = (gpgme_ctx_t)(argp1);
9961 38 : gpgme_release(arg1);
9962 38 : resultobj = SWIG_Py_Void();
9963 38 : return resultobj;
9964 : fail:
9965 : return NULL;
9966 : }
9967 :
9968 :
9969 2 : SWIGINTERN PyObject *_wrap_gpgme_set_ctx_flag(PyObject *self, PyObject *args) {
9970 2 : PyObject *resultobj = 0;
9971 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
9972 2 : char *arg2 = (char *) 0 ;
9973 2 : char *arg3 = (char *) 0 ;
9974 2 : void *argp1 = 0 ;
9975 2 : int res1 = 0 ;
9976 2 : PyObject * obj0 = 0 ;
9977 2 : PyObject * obj1 = 0 ;
9978 2 : PyObject * obj2 = 0 ;
9979 : gpgme_error_t result;
9980 :
9981 2 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_ctx_flag",&obj0,&obj1,&obj2)) SWIG_fail;
9982 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
9983 2 : if (!SWIG_IsOK(res1)) {
9984 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_ctx_flag" "', argument " "1"" of type '" "gpgme_ctx_t""'");
9985 : }
9986 2 : arg1 = (gpgme_ctx_t)(argp1);
9987 : {
9988 2 : if (obj1 == Py_None)
9989 : arg2 = NULL;
9990 2 : else if (PyUnicode_Check(obj1))
9991 2 : arg2 = PyUnicode_AsUTF8(obj1);
9992 0 : else if (PyBytes_Check(obj1))
9993 0 : arg2 = PyBytes_AsString(obj1);
9994 : else {
9995 0 : PyErr_Format(PyExc_TypeError,
9996 : "arg %d: expected str, bytes, or None, got %s",
9997 : 2, obj1->ob_type->tp_name);
9998 0 : return NULL;
9999 : }
10000 : }
10001 : {
10002 2 : if (obj2 == Py_None)
10003 : arg3 = NULL;
10004 2 : else if (PyUnicode_Check(obj2))
10005 2 : arg3 = PyUnicode_AsUTF8(obj2);
10006 0 : else if (PyBytes_Check(obj2))
10007 0 : arg3 = PyBytes_AsString(obj2);
10008 : else {
10009 0 : PyErr_Format(PyExc_TypeError,
10010 : "arg %d: expected str, bytes, or None, got %s",
10011 : 3, obj2->ob_type->tp_name);
10012 0 : return NULL;
10013 : }
10014 : }
10015 2 : result = gpgme_set_ctx_flag(arg1,(char const *)arg2,(char const *)arg3);
10016 : {
10017 2 : resultobj = PyLong_FromLong(result);
10018 : }
10019 2 : return resultobj;
10020 : fail:
10021 : return NULL;
10022 : }
10023 :
10024 :
10025 42 : SWIGINTERN PyObject *_wrap_gpgme_set_protocol(PyObject *self, PyObject *args) {
10026 42 : PyObject *resultobj = 0;
10027 42 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10028 : gpgme_protocol_t arg2 ;
10029 42 : void *argp1 = 0 ;
10030 42 : int res1 = 0 ;
10031 : int val2 ;
10032 42 : int ecode2 = 0 ;
10033 42 : PyObject * obj0 = 0 ;
10034 42 : PyObject * obj1 = 0 ;
10035 : gpgme_error_t result;
10036 :
10037 42 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_protocol",&obj0,&obj1)) SWIG_fail;
10038 42 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10039 42 : if (!SWIG_IsOK(res1)) {
10040 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10041 : }
10042 42 : arg1 = (gpgme_ctx_t)(argp1);
10043 42 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10044 42 : if (!SWIG_IsOK(ecode2)) {
10045 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_protocol" "', argument " "2"" of type '" "gpgme_protocol_t""'");
10046 : }
10047 42 : arg2 = (gpgme_protocol_t)(val2);
10048 42 : result = gpgme_set_protocol(arg1,arg2);
10049 : {
10050 42 : resultobj = PyLong_FromLong(result);
10051 : }
10052 42 : return resultobj;
10053 : fail:
10054 : return NULL;
10055 : }
10056 :
10057 :
10058 0 : SWIGINTERN PyObject *_wrap_gpgme_get_protocol(PyObject *self, PyObject *args) {
10059 0 : PyObject *resultobj = 0;
10060 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10061 0 : void *argp1 = 0 ;
10062 0 : int res1 = 0 ;
10063 0 : PyObject * obj0 = 0 ;
10064 : gpgme_protocol_t result;
10065 :
10066 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_protocol",&obj0)) SWIG_fail;
10067 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10068 0 : if (!SWIG_IsOK(res1)) {
10069 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10070 : }
10071 0 : arg1 = (gpgme_ctx_t)(argp1);
10072 0 : result = (gpgme_protocol_t)gpgme_get_protocol(arg1);
10073 0 : resultobj = SWIG_From_int((int)(result));
10074 0 : return resultobj;
10075 : fail:
10076 : return NULL;
10077 : }
10078 :
10079 :
10080 0 : SWIGINTERN PyObject *_wrap_gpgme_set_sub_protocol(PyObject *self, PyObject *args) {
10081 0 : PyObject *resultobj = 0;
10082 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10083 : gpgme_protocol_t arg2 ;
10084 0 : void *argp1 = 0 ;
10085 0 : int res1 = 0 ;
10086 : int val2 ;
10087 0 : int ecode2 = 0 ;
10088 0 : PyObject * obj0 = 0 ;
10089 0 : PyObject * obj1 = 0 ;
10090 : gpgme_error_t result;
10091 :
10092 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_sub_protocol",&obj0,&obj1)) SWIG_fail;
10093 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10094 0 : if (!SWIG_IsOK(res1)) {
10095 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_sub_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10096 : }
10097 0 : arg1 = (gpgme_ctx_t)(argp1);
10098 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10099 0 : if (!SWIG_IsOK(ecode2)) {
10100 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_sub_protocol" "', argument " "2"" of type '" "gpgme_protocol_t""'");
10101 : }
10102 0 : arg2 = (gpgme_protocol_t)(val2);
10103 0 : result = gpgme_set_sub_protocol(arg1,arg2);
10104 : {
10105 0 : resultobj = PyLong_FromLong(result);
10106 : }
10107 0 : return resultobj;
10108 : fail:
10109 : return NULL;
10110 : }
10111 :
10112 :
10113 0 : SWIGINTERN PyObject *_wrap_gpgme_get_sub_protocol(PyObject *self, PyObject *args) {
10114 0 : PyObject *resultobj = 0;
10115 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10116 0 : void *argp1 = 0 ;
10117 0 : int res1 = 0 ;
10118 0 : PyObject * obj0 = 0 ;
10119 : gpgme_protocol_t result;
10120 :
10121 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_sub_protocol",&obj0)) SWIG_fail;
10122 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10123 0 : if (!SWIG_IsOK(res1)) {
10124 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_sub_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10125 : }
10126 0 : arg1 = (gpgme_ctx_t)(argp1);
10127 0 : result = (gpgme_protocol_t)gpgme_get_sub_protocol(arg1);
10128 0 : resultobj = SWIG_From_int((int)(result));
10129 0 : return resultobj;
10130 : fail:
10131 : return NULL;
10132 : }
10133 :
10134 :
10135 0 : SWIGINTERN PyObject *_wrap_gpgme_get_protocol_name(PyObject *self, PyObject *args) {
10136 0 : PyObject *resultobj = 0;
10137 : gpgme_protocol_t arg1 ;
10138 : int val1 ;
10139 0 : int ecode1 = 0 ;
10140 0 : PyObject * obj0 = 0 ;
10141 0 : char *result = 0 ;
10142 :
10143 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_protocol_name",&obj0)) SWIG_fail;
10144 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
10145 0 : if (!SWIG_IsOK(ecode1)) {
10146 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_get_protocol_name" "', argument " "1"" of type '" "gpgme_protocol_t""'");
10147 : }
10148 0 : arg1 = (gpgme_protocol_t)(val1);
10149 0 : result = (char *)gpgme_get_protocol_name(arg1);
10150 0 : resultobj = SWIG_FromCharPtr((const char *)result);
10151 0 : return resultobj;
10152 : fail:
10153 : return NULL;
10154 : }
10155 :
10156 :
10157 55 : SWIGINTERN PyObject *_wrap_gpgme_set_armor(PyObject *self, PyObject *args) {
10158 55 : PyObject *resultobj = 0;
10159 55 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10160 : int arg2 ;
10161 55 : void *argp1 = 0 ;
10162 55 : int res1 = 0 ;
10163 : int val2 ;
10164 55 : int ecode2 = 0 ;
10165 55 : PyObject * obj0 = 0 ;
10166 55 : PyObject * obj1 = 0 ;
10167 :
10168 55 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_armor",&obj0,&obj1)) SWIG_fail;
10169 55 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10170 55 : if (!SWIG_IsOK(res1)) {
10171 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_armor" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10172 : }
10173 55 : arg1 = (gpgme_ctx_t)(argp1);
10174 55 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10175 55 : if (!SWIG_IsOK(ecode2)) {
10176 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_armor" "', argument " "2"" of type '" "int""'");
10177 : }
10178 55 : arg2 = (int)(val2);
10179 55 : gpgme_set_armor(arg1,arg2);
10180 55 : resultobj = SWIG_Py_Void();
10181 55 : return resultobj;
10182 : fail:
10183 : return NULL;
10184 : }
10185 :
10186 :
10187 0 : SWIGINTERN PyObject *_wrap_gpgme_get_armor(PyObject *self, PyObject *args) {
10188 0 : PyObject *resultobj = 0;
10189 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10190 0 : void *argp1 = 0 ;
10191 0 : int res1 = 0 ;
10192 0 : PyObject * obj0 = 0 ;
10193 : int result;
10194 :
10195 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_armor",&obj0)) SWIG_fail;
10196 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10197 0 : if (!SWIG_IsOK(res1)) {
10198 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_armor" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10199 : }
10200 0 : arg1 = (gpgme_ctx_t)(argp1);
10201 0 : result = (int)gpgme_get_armor(arg1);
10202 0 : resultobj = SWIG_From_int((int)(result));
10203 0 : return resultobj;
10204 : fail:
10205 : return NULL;
10206 : }
10207 :
10208 :
10209 44 : SWIGINTERN PyObject *_wrap_gpgme_set_textmode(PyObject *self, PyObject *args) {
10210 44 : PyObject *resultobj = 0;
10211 44 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10212 : int arg2 ;
10213 44 : void *argp1 = 0 ;
10214 44 : int res1 = 0 ;
10215 : int val2 ;
10216 44 : int ecode2 = 0 ;
10217 44 : PyObject * obj0 = 0 ;
10218 44 : PyObject * obj1 = 0 ;
10219 :
10220 44 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_textmode",&obj0,&obj1)) SWIG_fail;
10221 44 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10222 44 : if (!SWIG_IsOK(res1)) {
10223 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_textmode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10224 : }
10225 44 : arg1 = (gpgme_ctx_t)(argp1);
10226 44 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10227 44 : if (!SWIG_IsOK(ecode2)) {
10228 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_textmode" "', argument " "2"" of type '" "int""'");
10229 : }
10230 44 : arg2 = (int)(val2);
10231 44 : gpgme_set_textmode(arg1,arg2);
10232 44 : resultobj = SWIG_Py_Void();
10233 44 : return resultobj;
10234 : fail:
10235 : return NULL;
10236 : }
10237 :
10238 :
10239 0 : SWIGINTERN PyObject *_wrap_gpgme_get_textmode(PyObject *self, PyObject *args) {
10240 0 : PyObject *resultobj = 0;
10241 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10242 0 : void *argp1 = 0 ;
10243 0 : int res1 = 0 ;
10244 0 : PyObject * obj0 = 0 ;
10245 : int result;
10246 :
10247 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_textmode",&obj0)) SWIG_fail;
10248 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10249 0 : if (!SWIG_IsOK(res1)) {
10250 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_textmode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10251 : }
10252 0 : arg1 = (gpgme_ctx_t)(argp1);
10253 0 : result = (int)gpgme_get_textmode(arg1);
10254 0 : resultobj = SWIG_From_int((int)(result));
10255 0 : return resultobj;
10256 : fail:
10257 : return NULL;
10258 : }
10259 :
10260 :
10261 42 : SWIGINTERN PyObject *_wrap_gpgme_set_offline(PyObject *self, PyObject *args) {
10262 42 : PyObject *resultobj = 0;
10263 42 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10264 : int arg2 ;
10265 42 : void *argp1 = 0 ;
10266 42 : int res1 = 0 ;
10267 : int val2 ;
10268 42 : int ecode2 = 0 ;
10269 42 : PyObject * obj0 = 0 ;
10270 42 : PyObject * obj1 = 0 ;
10271 :
10272 42 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_offline",&obj0,&obj1)) SWIG_fail;
10273 42 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10274 42 : if (!SWIG_IsOK(res1)) {
10275 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_offline" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10276 : }
10277 42 : arg1 = (gpgme_ctx_t)(argp1);
10278 42 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10279 42 : if (!SWIG_IsOK(ecode2)) {
10280 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_offline" "', argument " "2"" of type '" "int""'");
10281 : }
10282 42 : arg2 = (int)(val2);
10283 42 : gpgme_set_offline(arg1,arg2);
10284 42 : resultobj = SWIG_Py_Void();
10285 42 : return resultobj;
10286 : fail:
10287 : return NULL;
10288 : }
10289 :
10290 :
10291 0 : SWIGINTERN PyObject *_wrap_gpgme_get_offline(PyObject *self, PyObject *args) {
10292 0 : PyObject *resultobj = 0;
10293 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10294 0 : void *argp1 = 0 ;
10295 0 : int res1 = 0 ;
10296 0 : PyObject * obj0 = 0 ;
10297 : int result;
10298 :
10299 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_offline",&obj0)) SWIG_fail;
10300 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10301 0 : if (!SWIG_IsOK(res1)) {
10302 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_offline" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10303 : }
10304 0 : arg1 = (gpgme_ctx_t)(argp1);
10305 0 : result = (int)gpgme_get_offline(arg1);
10306 0 : resultobj = SWIG_From_int((int)(result));
10307 0 : return resultobj;
10308 : fail:
10309 : return NULL;
10310 : }
10311 :
10312 :
10313 0 : SWIGINTERN PyObject *_wrap_gpgme_set_include_certs(PyObject *self, PyObject *args) {
10314 0 : PyObject *resultobj = 0;
10315 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10316 : int arg2 ;
10317 0 : void *argp1 = 0 ;
10318 0 : int res1 = 0 ;
10319 : int val2 ;
10320 0 : int ecode2 = 0 ;
10321 0 : PyObject * obj0 = 0 ;
10322 0 : PyObject * obj1 = 0 ;
10323 :
10324 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_include_certs",&obj0,&obj1)) SWIG_fail;
10325 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10326 0 : if (!SWIG_IsOK(res1)) {
10327 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_include_certs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10328 : }
10329 0 : arg1 = (gpgme_ctx_t)(argp1);
10330 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10331 0 : if (!SWIG_IsOK(ecode2)) {
10332 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_include_certs" "', argument " "2"" of type '" "int""'");
10333 : }
10334 0 : arg2 = (int)(val2);
10335 0 : gpgme_set_include_certs(arg1,arg2);
10336 0 : resultobj = SWIG_Py_Void();
10337 0 : return resultobj;
10338 : fail:
10339 : return NULL;
10340 : }
10341 :
10342 :
10343 0 : SWIGINTERN PyObject *_wrap_gpgme_get_include_certs(PyObject *self, PyObject *args) {
10344 0 : PyObject *resultobj = 0;
10345 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10346 0 : void *argp1 = 0 ;
10347 0 : int res1 = 0 ;
10348 0 : PyObject * obj0 = 0 ;
10349 : int result;
10350 :
10351 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_include_certs",&obj0)) SWIG_fail;
10352 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10353 0 : if (!SWIG_IsOK(res1)) {
10354 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_include_certs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10355 : }
10356 0 : arg1 = (gpgme_ctx_t)(argp1);
10357 0 : result = (int)gpgme_get_include_certs(arg1);
10358 0 : resultobj = SWIG_From_int((int)(result));
10359 0 : return resultobj;
10360 : fail:
10361 : return NULL;
10362 : }
10363 :
10364 :
10365 0 : SWIGINTERN PyObject *_wrap_gpgme_set_keylist_mode(PyObject *self, PyObject *args) {
10366 0 : PyObject *resultobj = 0;
10367 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10368 : gpgme_keylist_mode_t arg2 ;
10369 0 : void *argp1 = 0 ;
10370 0 : int res1 = 0 ;
10371 : unsigned int val2 ;
10372 0 : int ecode2 = 0 ;
10373 0 : PyObject * obj0 = 0 ;
10374 0 : PyObject * obj1 = 0 ;
10375 : gpgme_error_t result;
10376 :
10377 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_keylist_mode",&obj0,&obj1)) SWIG_fail;
10378 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10379 0 : if (!SWIG_IsOK(res1)) {
10380 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_keylist_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10381 : }
10382 0 : arg1 = (gpgme_ctx_t)(argp1);
10383 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10384 0 : if (!SWIG_IsOK(ecode2)) {
10385 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_keylist_mode" "', argument " "2"" of type '" "gpgme_keylist_mode_t""'");
10386 : }
10387 0 : arg2 = (gpgme_keylist_mode_t)(val2);
10388 0 : result = gpgme_set_keylist_mode(arg1,arg2);
10389 : {
10390 0 : resultobj = PyLong_FromLong(result);
10391 : }
10392 0 : return resultobj;
10393 : fail:
10394 : return NULL;
10395 : }
10396 :
10397 :
10398 0 : SWIGINTERN PyObject *_wrap_gpgme_get_keylist_mode(PyObject *self, PyObject *args) {
10399 0 : PyObject *resultobj = 0;
10400 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10401 0 : void *argp1 = 0 ;
10402 0 : int res1 = 0 ;
10403 0 : PyObject * obj0 = 0 ;
10404 : gpgme_keylist_mode_t result;
10405 :
10406 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_keylist_mode",&obj0)) SWIG_fail;
10407 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10408 0 : if (!SWIG_IsOK(res1)) {
10409 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_keylist_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10410 : }
10411 0 : arg1 = (gpgme_ctx_t)(argp1);
10412 0 : result = (gpgme_keylist_mode_t)gpgme_get_keylist_mode(arg1);
10413 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
10414 0 : return resultobj;
10415 : fail:
10416 : return NULL;
10417 : }
10418 :
10419 :
10420 58 : SWIGINTERN PyObject *_wrap_gpgme_set_pinentry_mode(PyObject *self, PyObject *args) {
10421 58 : PyObject *resultobj = 0;
10422 58 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10423 : gpgme_pinentry_mode_t arg2 ;
10424 58 : void *argp1 = 0 ;
10425 58 : int res1 = 0 ;
10426 : int val2 ;
10427 58 : int ecode2 = 0 ;
10428 58 : PyObject * obj0 = 0 ;
10429 58 : PyObject * obj1 = 0 ;
10430 : gpgme_error_t result;
10431 :
10432 58 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_pinentry_mode",&obj0,&obj1)) SWIG_fail;
10433 58 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10434 58 : if (!SWIG_IsOK(res1)) {
10435 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_pinentry_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10436 : }
10437 58 : arg1 = (gpgme_ctx_t)(argp1);
10438 58 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10439 58 : if (!SWIG_IsOK(ecode2)) {
10440 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_pinentry_mode" "', argument " "2"" of type '" "gpgme_pinentry_mode_t""'");
10441 : }
10442 58 : arg2 = (gpgme_pinentry_mode_t)(val2);
10443 58 : result = gpgme_set_pinentry_mode(arg1,arg2);
10444 : {
10445 58 : resultobj = PyLong_FromLong(result);
10446 : }
10447 58 : return resultobj;
10448 : fail:
10449 : return NULL;
10450 : }
10451 :
10452 :
10453 4 : SWIGINTERN PyObject *_wrap_gpgme_get_pinentry_mode(PyObject *self, PyObject *args) {
10454 4 : PyObject *resultobj = 0;
10455 4 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10456 4 : void *argp1 = 0 ;
10457 4 : int res1 = 0 ;
10458 4 : PyObject * obj0 = 0 ;
10459 : gpgme_pinentry_mode_t result;
10460 :
10461 4 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_pinentry_mode",&obj0)) SWIG_fail;
10462 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10463 4 : if (!SWIG_IsOK(res1)) {
10464 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_pinentry_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10465 : }
10466 4 : arg1 = (gpgme_ctx_t)(argp1);
10467 4 : result = (gpgme_pinentry_mode_t)gpgme_get_pinentry_mode(arg1);
10468 8 : resultobj = SWIG_From_int((int)(result));
10469 4 : return resultobj;
10470 : fail:
10471 : return NULL;
10472 : }
10473 :
10474 :
10475 0 : SWIGINTERN PyObject *_wrap_gpgme_set_passphrase_cb(PyObject *self, PyObject *args) {
10476 0 : PyObject *resultobj = 0;
10477 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10478 0 : gpgme_passphrase_cb_t arg2 = (gpgme_passphrase_cb_t) 0 ;
10479 0 : void *arg3 = (void *) 0 ;
10480 0 : void *argp1 = 0 ;
10481 0 : int res1 = 0 ;
10482 : int res3 ;
10483 0 : PyObject * obj0 = 0 ;
10484 0 : PyObject * obj1 = 0 ;
10485 0 : PyObject * obj2 = 0 ;
10486 :
10487 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_passphrase_cb",&obj0,&obj1,&obj2)) SWIG_fail;
10488 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10489 0 : if (!SWIG_IsOK(res1)) {
10490 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_passphrase_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10491 : }
10492 0 : arg1 = (gpgme_ctx_t)(argp1);
10493 : {
10494 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t);
10495 0 : if (!SWIG_IsOK(res)) {
10496 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_set_passphrase_cb" "', argument " "2"" of type '" "gpgme_passphrase_cb_t""'");
10497 : }
10498 : }
10499 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
10500 0 : if (!SWIG_IsOK(res3)) {
10501 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_set_passphrase_cb" "', argument " "3"" of type '" "void *""'");
10502 : }
10503 0 : gpgme_set_passphrase_cb(arg1,arg2,arg3);
10504 0 : resultobj = SWIG_Py_Void();
10505 0 : return resultobj;
10506 : fail:
10507 : return NULL;
10508 : }
10509 :
10510 :
10511 0 : SWIGINTERN PyObject *_wrap_gpgme_get_passphrase_cb(PyObject *self, PyObject *args) {
10512 0 : PyObject *resultobj = 0;
10513 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10514 0 : gpgme_passphrase_cb_t *arg2 = (gpgme_passphrase_cb_t *) 0 ;
10515 0 : void **arg3 = (void **) 0 ;
10516 0 : void *argp1 = 0 ;
10517 0 : int res1 = 0 ;
10518 0 : void *argp2 = 0 ;
10519 0 : int res2 = 0 ;
10520 0 : void *argp3 = 0 ;
10521 0 : int res3 = 0 ;
10522 0 : PyObject * obj0 = 0 ;
10523 0 : PyObject * obj1 = 0 ;
10524 0 : PyObject * obj2 = 0 ;
10525 :
10526 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_get_passphrase_cb",&obj0,&obj1,&obj2)) SWIG_fail;
10527 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10528 0 : if (!SWIG_IsOK(res1)) {
10529 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_passphrase_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10530 : }
10531 0 : arg1 = (gpgme_ctx_t)(argp1);
10532 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t, 0 | 0 );
10533 0 : if (!SWIG_IsOK(res2)) {
10534 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_passphrase_cb" "', argument " "2"" of type '" "gpgme_passphrase_cb_t *""'");
10535 : }
10536 0 : arg2 = (gpgme_passphrase_cb_t *)(argp2);
10537 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_void, 0 | 0 );
10538 0 : if (!SWIG_IsOK(res3)) {
10539 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_passphrase_cb" "', argument " "3"" of type '" "void **""'");
10540 : }
10541 0 : arg3 = (void **)(argp3);
10542 0 : gpgme_get_passphrase_cb(arg1,arg2,arg3);
10543 0 : resultobj = SWIG_Py_Void();
10544 0 : return resultobj;
10545 : fail:
10546 : return NULL;
10547 : }
10548 :
10549 :
10550 0 : SWIGINTERN PyObject *_wrap_gpgme_set_progress_cb(PyObject *self, PyObject *args) {
10551 0 : PyObject *resultobj = 0;
10552 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10553 0 : gpgme_progress_cb_t arg2 = (gpgme_progress_cb_t) 0 ;
10554 0 : void *arg3 = (void *) 0 ;
10555 0 : void *argp1 = 0 ;
10556 0 : int res1 = 0 ;
10557 : int res3 ;
10558 0 : PyObject * obj0 = 0 ;
10559 0 : PyObject * obj1 = 0 ;
10560 0 : PyObject * obj2 = 0 ;
10561 :
10562 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_progress_cb",&obj0,&obj1,&obj2)) SWIG_fail;
10563 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10564 0 : if (!SWIG_IsOK(res1)) {
10565 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_progress_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10566 : }
10567 0 : arg1 = (gpgme_ctx_t)(argp1);
10568 : {
10569 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_int_int_int__void);
10570 0 : if (!SWIG_IsOK(res)) {
10571 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_set_progress_cb" "', argument " "2"" of type '" "gpgme_progress_cb_t""'");
10572 : }
10573 : }
10574 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
10575 0 : if (!SWIG_IsOK(res3)) {
10576 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_set_progress_cb" "', argument " "3"" of type '" "void *""'");
10577 : }
10578 0 : gpgme_set_progress_cb(arg1,arg2,arg3);
10579 0 : resultobj = SWIG_Py_Void();
10580 0 : return resultobj;
10581 : fail:
10582 : return NULL;
10583 : }
10584 :
10585 :
10586 0 : SWIGINTERN PyObject *_wrap_gpgme_get_progress_cb(PyObject *self, PyObject *args) {
10587 0 : PyObject *resultobj = 0;
10588 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10589 0 : gpgme_progress_cb_t *arg2 = (gpgme_progress_cb_t *) 0 ;
10590 0 : void **arg3 = (void **) 0 ;
10591 0 : void *argp1 = 0 ;
10592 0 : int res1 = 0 ;
10593 0 : void *argp2 = 0 ;
10594 0 : int res2 = 0 ;
10595 0 : void *argp3 = 0 ;
10596 0 : int res3 = 0 ;
10597 0 : PyObject * obj0 = 0 ;
10598 0 : PyObject * obj1 = 0 ;
10599 0 : PyObject * obj2 = 0 ;
10600 :
10601 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_get_progress_cb",&obj0,&obj1,&obj2)) SWIG_fail;
10602 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10603 0 : if (!SWIG_IsOK(res1)) {
10604 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_progress_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10605 : }
10606 0 : arg1 = (gpgme_ctx_t)(argp1);
10607 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_int_int_int__void, 0 | 0 );
10608 0 : if (!SWIG_IsOK(res2)) {
10609 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_progress_cb" "', argument " "2"" of type '" "gpgme_progress_cb_t *""'");
10610 : }
10611 0 : arg2 = (gpgme_progress_cb_t *)(argp2);
10612 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_void, 0 | 0 );
10613 0 : if (!SWIG_IsOK(res3)) {
10614 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_progress_cb" "', argument " "3"" of type '" "void **""'");
10615 : }
10616 0 : arg3 = (void **)(argp3);
10617 0 : gpgme_get_progress_cb(arg1,arg2,arg3);
10618 0 : resultobj = SWIG_Py_Void();
10619 0 : return resultobj;
10620 : fail:
10621 : return NULL;
10622 : }
10623 :
10624 :
10625 0 : SWIGINTERN PyObject *_wrap_gpgme_set_status_cb(PyObject *self, PyObject *args) {
10626 0 : PyObject *resultobj = 0;
10627 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10628 0 : gpgme_status_cb_t arg2 = (gpgme_status_cb_t) 0 ;
10629 0 : void *arg3 = (void *) 0 ;
10630 0 : void *argp1 = 0 ;
10631 0 : int res1 = 0 ;
10632 : int res3 ;
10633 0 : PyObject * obj0 = 0 ;
10634 0 : PyObject * obj1 = 0 ;
10635 0 : PyObject * obj2 = 0 ;
10636 :
10637 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_status_cb",&obj0,&obj1,&obj2)) SWIG_fail;
10638 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10639 0 : if (!SWIG_IsOK(res1)) {
10640 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_status_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10641 : }
10642 0 : arg1 = (gpgme_ctx_t)(argp1);
10643 : {
10644 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t);
10645 0 : if (!SWIG_IsOK(res)) {
10646 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_set_status_cb" "', argument " "2"" of type '" "gpgme_status_cb_t""'");
10647 : }
10648 : }
10649 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
10650 0 : if (!SWIG_IsOK(res3)) {
10651 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_set_status_cb" "', argument " "3"" of type '" "void *""'");
10652 : }
10653 0 : gpgme_set_status_cb(arg1,arg2,arg3);
10654 0 : resultobj = SWIG_Py_Void();
10655 0 : return resultobj;
10656 : fail:
10657 : return NULL;
10658 : }
10659 :
10660 :
10661 0 : SWIGINTERN PyObject *_wrap_gpgme_get_status_cb(PyObject *self, PyObject *args) {
10662 0 : PyObject *resultobj = 0;
10663 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10664 0 : gpgme_status_cb_t *arg2 = (gpgme_status_cb_t *) 0 ;
10665 0 : void **arg3 = (void **) 0 ;
10666 0 : void *argp1 = 0 ;
10667 0 : int res1 = 0 ;
10668 0 : void *argp2 = 0 ;
10669 0 : int res2 = 0 ;
10670 0 : void *argp3 = 0 ;
10671 0 : int res3 = 0 ;
10672 0 : PyObject * obj0 = 0 ;
10673 0 : PyObject * obj1 = 0 ;
10674 0 : PyObject * obj2 = 0 ;
10675 :
10676 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_get_status_cb",&obj0,&obj1,&obj2)) SWIG_fail;
10677 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10678 0 : if (!SWIG_IsOK(res1)) {
10679 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_status_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10680 : }
10681 0 : arg1 = (gpgme_ctx_t)(argp1);
10682 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t, 0 | 0 );
10683 0 : if (!SWIG_IsOK(res2)) {
10684 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_status_cb" "', argument " "2"" of type '" "gpgme_status_cb_t *""'");
10685 : }
10686 0 : arg2 = (gpgme_status_cb_t *)(argp2);
10687 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_void, 0 | 0 );
10688 0 : if (!SWIG_IsOK(res3)) {
10689 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_status_cb" "', argument " "3"" of type '" "void **""'");
10690 : }
10691 0 : arg3 = (void **)(argp3);
10692 0 : gpgme_get_status_cb(arg1,arg2,arg3);
10693 0 : resultobj = SWIG_Py_Void();
10694 0 : return resultobj;
10695 : fail:
10696 : return NULL;
10697 : }
10698 :
10699 :
10700 0 : SWIGINTERN PyObject *_wrap_gpgme_set_locale(PyObject *self, PyObject *args) {
10701 0 : PyObject *resultobj = 0;
10702 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10703 : int arg2 ;
10704 0 : char *arg3 = (char *) 0 ;
10705 0 : void *argp1 = 0 ;
10706 0 : int res1 = 0 ;
10707 : int val2 ;
10708 0 : int ecode2 = 0 ;
10709 0 : PyObject * obj0 = 0 ;
10710 0 : PyObject * obj1 = 0 ;
10711 0 : PyObject * obj2 = 0 ;
10712 : gpgme_error_t result;
10713 :
10714 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_locale",&obj0,&obj1,&obj2)) SWIG_fail;
10715 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10716 0 : if (!SWIG_IsOK(res1)) {
10717 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_locale" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10718 : }
10719 0 : arg1 = (gpgme_ctx_t)(argp1);
10720 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10721 0 : if (!SWIG_IsOK(ecode2)) {
10722 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_locale" "', argument " "2"" of type '" "int""'");
10723 : }
10724 0 : arg2 = (int)(val2);
10725 : {
10726 0 : if (obj2 == Py_None)
10727 : arg3 = NULL;
10728 0 : else if (PyUnicode_Check(obj2))
10729 0 : arg3 = PyUnicode_AsUTF8(obj2);
10730 0 : else if (PyBytes_Check(obj2))
10731 0 : arg3 = PyBytes_AsString(obj2);
10732 : else {
10733 0 : PyErr_Format(PyExc_TypeError,
10734 : "arg %d: expected str, bytes, or None, got %s",
10735 : 3, obj2->ob_type->tp_name);
10736 0 : return NULL;
10737 : }
10738 : }
10739 0 : result = gpgme_set_locale(arg1,arg2,(char const *)arg3);
10740 : {
10741 0 : resultobj = PyLong_FromLong(result);
10742 : }
10743 0 : return resultobj;
10744 : fail:
10745 : return NULL;
10746 : }
10747 :
10748 :
10749 1 : SWIGINTERN PyObject *_wrap_gpgme_ctx_get_engine_info(PyObject *self, PyObject *args) {
10750 1 : PyObject *resultobj = 0;
10751 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10752 1 : void *argp1 = 0 ;
10753 1 : int res1 = 0 ;
10754 1 : PyObject * obj0 = 0 ;
10755 : gpgme_engine_info_t result;
10756 :
10757 1 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_ctx_get_engine_info",&obj0)) SWIG_fail;
10758 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10759 1 : if (!SWIG_IsOK(res1)) {
10760 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_get_engine_info" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10761 : }
10762 1 : arg1 = (gpgme_ctx_t)(argp1);
10763 1 : result = (gpgme_engine_info_t)gpgme_ctx_get_engine_info(arg1);
10764 : {
10765 : int i;
10766 1 : int size = 0;
10767 : gpgme_engine_info_t curr;
10768 7 : for (curr = result; curr != NULL; curr = curr->next) {
10769 6 : size++;
10770 : }
10771 1 : resultobj = PyList_New(size);
10772 7 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
10773 : PyObject *fragile, *o;
10774 6 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_engine_info,
10775 : 0 );
10776 6 : o = _pyme_wrap_result(fragile, "EngineInfo");
10777 6 : if (o == NULL)
10778 : return NULL; /* raise */
10779 6 : Py_DECREF(fragile);
10780 6 : PyList_SetItem(resultobj, i, o);
10781 : }
10782 : }
10783 : return resultobj;
10784 : fail:
10785 : return NULL;
10786 : }
10787 :
10788 :
10789 0 : SWIGINTERN PyObject *_wrap_gpgme_ctx_set_engine_info(PyObject *self, PyObject *args) {
10790 0 : PyObject *resultobj = 0;
10791 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10792 : gpgme_protocol_t arg2 ;
10793 0 : char *arg3 = (char *) 0 ;
10794 0 : char *arg4 = (char *) 0 ;
10795 0 : void *argp1 = 0 ;
10796 0 : int res1 = 0 ;
10797 : int val2 ;
10798 0 : int ecode2 = 0 ;
10799 0 : PyObject * obj0 = 0 ;
10800 0 : PyObject * obj1 = 0 ;
10801 0 : PyObject * obj2 = 0 ;
10802 0 : PyObject * obj3 = 0 ;
10803 : gpgme_error_t result;
10804 :
10805 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_ctx_set_engine_info",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10806 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10807 0 : if (!SWIG_IsOK(res1)) {
10808 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_set_engine_info" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10809 : }
10810 0 : arg1 = (gpgme_ctx_t)(argp1);
10811 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10812 0 : if (!SWIG_IsOK(ecode2)) {
10813 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_ctx_set_engine_info" "', argument " "2"" of type '" "gpgme_protocol_t""'");
10814 : }
10815 0 : arg2 = (gpgme_protocol_t)(val2);
10816 : {
10817 0 : if (obj2 == Py_None)
10818 : arg3 = NULL;
10819 0 : else if (PyUnicode_Check(obj2))
10820 0 : arg3 = PyUnicode_AsUTF8(obj2);
10821 0 : else if (PyBytes_Check(obj2))
10822 0 : arg3 = PyBytes_AsString(obj2);
10823 : else {
10824 0 : PyErr_Format(PyExc_TypeError,
10825 : "arg %d: expected str, bytes, or None, got %s",
10826 : 3, obj2->ob_type->tp_name);
10827 0 : return NULL;
10828 : }
10829 : }
10830 : {
10831 0 : if (obj3 == Py_None)
10832 : arg4 = NULL;
10833 0 : else if (PyUnicode_Check(obj3))
10834 0 : arg4 = PyUnicode_AsUTF8(obj3);
10835 0 : else if (PyBytes_Check(obj3))
10836 0 : arg4 = PyBytes_AsString(obj3);
10837 : else {
10838 0 : PyErr_Format(PyExc_TypeError,
10839 : "arg %d: expected str, bytes, or None, got %s",
10840 : 4, obj3->ob_type->tp_name);
10841 0 : return NULL;
10842 : }
10843 : }
10844 0 : result = gpgme_ctx_set_engine_info(arg1,arg2,(char const *)arg3,(char const *)arg4);
10845 : {
10846 0 : resultobj = PyLong_FromLong(result);
10847 : }
10848 0 : return resultobj;
10849 : fail:
10850 : return NULL;
10851 : }
10852 :
10853 :
10854 46 : SWIGINTERN PyObject *_wrap_gpgme_signers_clear(PyObject *self, PyObject *args) {
10855 46 : PyObject *resultobj = 0;
10856 46 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10857 46 : void *argp1 = 0 ;
10858 46 : int res1 = 0 ;
10859 46 : PyObject * obj0 = 0 ;
10860 :
10861 46 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_signers_clear",&obj0)) SWIG_fail;
10862 46 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10863 46 : if (!SWIG_IsOK(res1)) {
10864 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_clear" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10865 : }
10866 46 : arg1 = (gpgme_ctx_t)(argp1);
10867 46 : gpgme_signers_clear(arg1);
10868 46 : resultobj = SWIG_Py_Void();
10869 46 : return resultobj;
10870 : fail:
10871 : return NULL;
10872 : }
10873 :
10874 :
10875 8 : SWIGINTERN PyObject *_wrap_gpgme_signers_add(PyObject *self, PyObject *args) {
10876 8 : PyObject *resultobj = 0;
10877 8 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10878 8 : gpgme_key_t arg2 = (gpgme_key_t) (gpgme_key_t)0 ;
10879 8 : void *argp1 = 0 ;
10880 8 : int res1 = 0 ;
10881 8 : void *argp2 = 0 ;
10882 8 : int res2 = 0 ;
10883 8 : PyObject * obj0 = 0 ;
10884 8 : PyObject * obj1 = 0 ;
10885 : gpgme_error_t result;
10886 :
10887 8 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_signers_add",&obj0,&obj1)) SWIG_fail;
10888 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10889 8 : if (!SWIG_IsOK(res1)) {
10890 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_add" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10891 : }
10892 8 : arg1 = (gpgme_ctx_t)(argp1);
10893 8 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
10894 8 : if (!SWIG_IsOK(res2)) {
10895 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_signers_add" "', argument " "2"" of type '" "gpgme_key_t const""'");
10896 : }
10897 8 : arg2 = (gpgme_key_t)(argp2);
10898 8 : result = gpgme_signers_add(arg1,arg2);
10899 : {
10900 8 : resultobj = PyLong_FromLong(result);
10901 : }
10902 8 : return resultobj;
10903 : fail:
10904 : return NULL;
10905 : }
10906 :
10907 :
10908 46 : SWIGINTERN PyObject *_wrap_gpgme_signers_count(PyObject *self, PyObject *args) {
10909 46 : PyObject *resultobj = 0;
10910 46 : gpgme_ctx_t arg1 = (gpgme_ctx_t) (gpgme_ctx_t)0 ;
10911 46 : void *argp1 = 0 ;
10912 46 : int res1 = 0 ;
10913 46 : PyObject * obj0 = 0 ;
10914 : unsigned int result;
10915 :
10916 46 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_signers_count",&obj0)) SWIG_fail;
10917 46 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10918 46 : if (!SWIG_IsOK(res1)) {
10919 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_count" "', argument " "1"" of type '" "gpgme_ctx_t const""'");
10920 : }
10921 46 : arg1 = (gpgme_ctx_t)(argp1);
10922 46 : result = (unsigned int)gpgme_signers_count(arg1);
10923 46 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
10924 46 : return resultobj;
10925 : fail:
10926 : return NULL;
10927 : }
10928 :
10929 :
10930 2 : SWIGINTERN PyObject *_wrap_gpgme_signers_enum(PyObject *self, PyObject *args) {
10931 2 : PyObject *resultobj = 0;
10932 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) (gpgme_ctx_t)0 ;
10933 : int arg2 ;
10934 2 : void *argp1 = 0 ;
10935 2 : int res1 = 0 ;
10936 : int val2 ;
10937 2 : int ecode2 = 0 ;
10938 2 : PyObject * obj0 = 0 ;
10939 2 : PyObject * obj1 = 0 ;
10940 : gpgme_key_t result;
10941 :
10942 2 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_signers_enum",&obj0,&obj1)) SWIG_fail;
10943 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10944 2 : if (!SWIG_IsOK(res1)) {
10945 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_enum" "', argument " "1"" of type '" "gpgme_ctx_t const""'");
10946 : }
10947 2 : arg1 = (gpgme_ctx_t)(argp1);
10948 2 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10949 2 : if (!SWIG_IsOK(ecode2)) {
10950 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_signers_enum" "', argument " "2"" of type '" "int""'");
10951 : }
10952 2 : arg2 = (int)(val2);
10953 2 : result = (gpgme_key_t)gpgme_signers_enum(arg1,arg2);
10954 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, 0 | 0 );
10955 2 : return resultobj;
10956 : fail:
10957 : return NULL;
10958 : }
10959 :
10960 :
10961 0 : SWIGINTERN PyObject *_wrap_gpgme_sig_notation_clear(PyObject *self, PyObject *args) {
10962 0 : PyObject *resultobj = 0;
10963 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10964 0 : void *argp1 = 0 ;
10965 0 : int res1 = 0 ;
10966 0 : PyObject * obj0 = 0 ;
10967 :
10968 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_sig_notation_clear",&obj0)) SWIG_fail;
10969 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10970 0 : if (!SWIG_IsOK(res1)) {
10971 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_sig_notation_clear" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10972 : }
10973 0 : arg1 = (gpgme_ctx_t)(argp1);
10974 0 : gpgme_sig_notation_clear(arg1);
10975 0 : resultobj = SWIG_Py_Void();
10976 0 : return resultobj;
10977 : fail:
10978 : return NULL;
10979 : }
10980 :
10981 :
10982 3 : SWIGINTERN PyObject *_wrap_gpgme_sig_notation_add(PyObject *self, PyObject *args) {
10983 3 : PyObject *resultobj = 0;
10984 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10985 3 : char *arg2 = (char *) 0 ;
10986 3 : char *arg3 = (char *) 0 ;
10987 : gpgme_sig_notation_flags_t arg4 ;
10988 3 : void *argp1 = 0 ;
10989 3 : int res1 = 0 ;
10990 : unsigned int val4 ;
10991 3 : int ecode4 = 0 ;
10992 3 : PyObject * obj0 = 0 ;
10993 3 : PyObject * obj1 = 0 ;
10994 3 : PyObject * obj2 = 0 ;
10995 3 : PyObject * obj3 = 0 ;
10996 : gpgme_error_t result;
10997 :
10998 3 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_sig_notation_add",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10999 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11000 3 : if (!SWIG_IsOK(res1)) {
11001 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_sig_notation_add" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11002 : }
11003 3 : arg1 = (gpgme_ctx_t)(argp1);
11004 : {
11005 3 : if (obj1 == Py_None)
11006 : arg2 = NULL;
11007 2 : else if (PyUnicode_Check(obj1))
11008 2 : arg2 = PyUnicode_AsUTF8(obj1);
11009 0 : else if (PyBytes_Check(obj1))
11010 0 : arg2 = PyBytes_AsString(obj1);
11011 : else {
11012 0 : PyErr_Format(PyExc_TypeError,
11013 : "arg %d: expected str, bytes, or None, got %s",
11014 : 2, obj1->ob_type->tp_name);
11015 0 : return NULL;
11016 : }
11017 : }
11018 : {
11019 3 : if (obj2 == Py_None)
11020 : arg3 = NULL;
11021 3 : else if (PyUnicode_Check(obj2))
11022 3 : arg3 = PyUnicode_AsUTF8(obj2);
11023 0 : else if (PyBytes_Check(obj2))
11024 0 : arg3 = PyBytes_AsString(obj2);
11025 : else {
11026 0 : PyErr_Format(PyExc_TypeError,
11027 : "arg %d: expected str, bytes, or None, got %s",
11028 : 3, obj2->ob_type->tp_name);
11029 0 : return NULL;
11030 : }
11031 : }
11032 3 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
11033 3 : if (!SWIG_IsOK(ecode4)) {
11034 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_sig_notation_add" "', argument " "4"" of type '" "gpgme_sig_notation_flags_t""'");
11035 : }
11036 3 : arg4 = (gpgme_sig_notation_flags_t)(val4);
11037 3 : result = gpgme_sig_notation_add(arg1,(char const *)arg2,(char const *)arg3,arg4);
11038 : {
11039 3 : resultobj = PyLong_FromLong(result);
11040 : }
11041 3 : return resultobj;
11042 : fail:
11043 : return NULL;
11044 : }
11045 :
11046 :
11047 0 : SWIGINTERN PyObject *_wrap_gpgme_sig_notation_get(PyObject *self, PyObject *args) {
11048 0 : PyObject *resultobj = 0;
11049 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11050 0 : void *argp1 = 0 ;
11051 0 : int res1 = 0 ;
11052 0 : PyObject * obj0 = 0 ;
11053 : gpgme_sig_notation_t result;
11054 :
11055 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_sig_notation_get",&obj0)) SWIG_fail;
11056 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11057 0 : if (!SWIG_IsOK(res1)) {
11058 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_sig_notation_get" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11059 : }
11060 0 : arg1 = (gpgme_ctx_t)(argp1);
11061 0 : result = (gpgme_sig_notation_t)gpgme_sig_notation_get(arg1);
11062 : {
11063 : int i;
11064 0 : int size = 0;
11065 : gpgme_sig_notation_t curr;
11066 0 : for (curr = result; curr != NULL; curr = curr->next) {
11067 0 : size++;
11068 : }
11069 0 : resultobj = PyList_New(size);
11070 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
11071 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
11072 0 : PyList_SetItem(resultobj, i, o);
11073 : }
11074 : }
11075 : return resultobj;
11076 : fail:
11077 : return NULL;
11078 : }
11079 :
11080 :
11081 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_err_set(PyObject *self, PyObject *args) {
11082 0 : PyObject *resultobj = 0;
11083 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
11084 : gpgme_error_t arg2 ;
11085 0 : void *argp1 = 0 ;
11086 0 : int res1 = 0 ;
11087 0 : PyObject * obj1 = 0 ;
11088 :
11089 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_event_done_data_err_set",&obj1)) SWIG_fail;
11090 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
11091 0 : if (!SWIG_IsOK(res1)) {
11092 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_event_done_data_err_set" "', argument " "1"" of type '" "struct gpgme_io_event_done_data *""'");
11093 : }
11094 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
11095 : {
11096 0 : arg2 = PyLong_AsLong(obj1);
11097 : }
11098 0 : if (arg1) (arg1)->err = arg2;
11099 0 : resultobj = SWIG_Py_Void();
11100 0 : return resultobj;
11101 : fail:
11102 : return NULL;
11103 : }
11104 :
11105 :
11106 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_err_get(PyObject *self, PyObject *args) {
11107 0 : PyObject *resultobj = 0;
11108 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
11109 0 : void *argp1 = 0 ;
11110 0 : int res1 = 0 ;
11111 : gpgme_error_t result;
11112 :
11113 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11114 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
11115 0 : if (!SWIG_IsOK(res1)) {
11116 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_event_done_data_err_get" "', argument " "1"" of type '" "struct gpgme_io_event_done_data *""'");
11117 : }
11118 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
11119 0 : result = ((arg1)->err);
11120 : {
11121 0 : resultobj = PyLong_FromLong(result);
11122 : }
11123 0 : return resultobj;
11124 : fail:
11125 : return NULL;
11126 : }
11127 :
11128 :
11129 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_op_err_set(PyObject *self, PyObject *args) {
11130 0 : PyObject *resultobj = 0;
11131 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
11132 : gpgme_error_t arg2 ;
11133 0 : void *argp1 = 0 ;
11134 0 : int res1 = 0 ;
11135 0 : PyObject * obj1 = 0 ;
11136 :
11137 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_event_done_data_op_err_set",&obj1)) SWIG_fail;
11138 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
11139 0 : if (!SWIG_IsOK(res1)) {
11140 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_event_done_data_op_err_set" "', argument " "1"" of type '" "struct gpgme_io_event_done_data *""'");
11141 : }
11142 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
11143 : {
11144 0 : arg2 = PyLong_AsLong(obj1);
11145 : }
11146 0 : if (arg1) (arg1)->op_err = arg2;
11147 0 : resultobj = SWIG_Py_Void();
11148 0 : return resultobj;
11149 : fail:
11150 : return NULL;
11151 : }
11152 :
11153 :
11154 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_op_err_get(PyObject *self, PyObject *args) {
11155 0 : PyObject *resultobj = 0;
11156 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
11157 0 : void *argp1 = 0 ;
11158 0 : int res1 = 0 ;
11159 : gpgme_error_t result;
11160 :
11161 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11162 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
11163 0 : if (!SWIG_IsOK(res1)) {
11164 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_event_done_data_op_err_get" "', argument " "1"" of type '" "struct gpgme_io_event_done_data *""'");
11165 : }
11166 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
11167 0 : result = ((arg1)->op_err);
11168 : {
11169 0 : resultobj = PyLong_FromLong(result);
11170 : }
11171 0 : return resultobj;
11172 : fail:
11173 : return NULL;
11174 : }
11175 :
11176 :
11177 0 : SWIGINTERN int _wrap_new_gpgme_io_event_done_data(PyObject *self, PyObject *args) {
11178 0 : PyObject *resultobj = 0;
11179 0 : struct gpgme_io_event_done_data *result = 0 ;
11180 :
11181 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11182 0 : result = (struct gpgme_io_event_done_data *)calloc(1, sizeof(struct gpgme_io_event_done_data));
11183 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_io_event_done_data, SWIG_BUILTIN_INIT | 0 );
11184 0 : return resultobj == Py_None ? -1 : 0;
11185 : fail:
11186 : return -1;
11187 : }
11188 :
11189 :
11190 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_io_event_done_data(PyObject *self, PyObject *args) {
11191 0 : PyObject *resultobj = 0;
11192 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
11193 0 : void *argp1 = 0 ;
11194 0 : int res1 = 0 ;
11195 :
11196 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11197 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, SWIG_POINTER_DISOWN | 0 );
11198 0 : if (!SWIG_IsOK(res1)) {
11199 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_io_event_done_data" "', argument " "1"" of type '" "struct gpgme_io_event_done_data *""'");
11200 : }
11201 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
11202 0 : free((char *) arg1);
11203 0 : resultobj = SWIG_Py_Void();
11204 0 : return resultobj;
11205 : fail:
11206 : return NULL;
11207 : }
11208 :
11209 :
11210 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_set(PyObject *self, PyObject *args) {
11211 0 : PyObject *resultobj = 0;
11212 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
11213 0 : gpgme_register_io_cb_t arg2 = (gpgme_register_io_cb_t) 0 ;
11214 0 : void *argp1 = 0 ;
11215 0 : int res1 = 0 ;
11216 0 : PyObject * obj1 = 0 ;
11217 :
11218 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_add_set",&obj1)) SWIG_fail;
11219 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11220 0 : if (!SWIG_IsOK(res1)) {
11221 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
11222 : }
11223 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
11224 : {
11225 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t);
11226 0 : if (!SWIG_IsOK(res)) {
11227 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_io_cbs_add_set" "', argument " "2"" of type '" "gpgme_register_io_cb_t""'");
11228 : }
11229 : }
11230 0 : if (arg1) (arg1)->add = arg2;
11231 0 : resultobj = SWIG_Py_Void();
11232 0 : return resultobj;
11233 : fail:
11234 : return NULL;
11235 : }
11236 :
11237 :
11238 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_get(PyObject *self, PyObject *args) {
11239 0 : PyObject *resultobj = 0;
11240 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
11241 0 : void *argp1 = 0 ;
11242 0 : int res1 = 0 ;
11243 : gpgme_register_io_cb_t result;
11244 :
11245 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11246 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11247 0 : if (!SWIG_IsOK(res1)) {
11248 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
11249 : }
11250 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
11251 0 : result = (gpgme_register_io_cb_t) ((arg1)->add);
11252 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t);
11253 0 : return resultobj;
11254 : fail:
11255 : return NULL;
11256 : }
11257 :
11258 :
11259 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_priv_set(PyObject *self, PyObject *args) {
11260 0 : PyObject *resultobj = 0;
11261 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
11262 0 : void *arg2 = (void *) 0 ;
11263 0 : void *argp1 = 0 ;
11264 0 : int res1 = 0 ;
11265 : int res2 ;
11266 0 : PyObject * obj1 = 0 ;
11267 :
11268 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_add_priv_set",&obj1)) SWIG_fail;
11269 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11270 0 : if (!SWIG_IsOK(res1)) {
11271 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_priv_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
11272 : }
11273 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
11274 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
11275 0 : if (!SWIG_IsOK(res2)) {
11276 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_cbs_add_priv_set" "', argument " "2"" of type '" "void *""'");
11277 : }
11278 0 : if (arg1) (arg1)->add_priv = arg2;
11279 0 : resultobj = SWIG_Py_Void();
11280 0 : return resultobj;
11281 : fail:
11282 : return NULL;
11283 : }
11284 :
11285 :
11286 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_priv_get(PyObject *self, PyObject *args) {
11287 0 : PyObject *resultobj = 0;
11288 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
11289 0 : void *argp1 = 0 ;
11290 0 : int res1 = 0 ;
11291 0 : void *result = 0 ;
11292 :
11293 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11294 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11295 0 : if (!SWIG_IsOK(res1)) {
11296 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_priv_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
11297 : }
11298 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
11299 0 : result = (void *) ((arg1)->add_priv);
11300 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
11301 0 : return resultobj;
11302 : fail:
11303 : return NULL;
11304 : }
11305 :
11306 :
11307 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_remove_set(PyObject *self, PyObject *args) {
11308 0 : PyObject *resultobj = 0;
11309 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
11310 0 : gpgme_remove_io_cb_t arg2 = (gpgme_remove_io_cb_t) 0 ;
11311 0 : void *argp1 = 0 ;
11312 0 : int res1 = 0 ;
11313 0 : PyObject * obj1 = 0 ;
11314 :
11315 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_remove_set",&obj1)) SWIG_fail;
11316 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11317 0 : if (!SWIG_IsOK(res1)) {
11318 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_remove_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
11319 : }
11320 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
11321 : {
11322 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
11323 0 : if (!SWIG_IsOK(res)) {
11324 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_io_cbs_remove_set" "', argument " "2"" of type '" "gpgme_remove_io_cb_t""'");
11325 : }
11326 : }
11327 0 : if (arg1) (arg1)->remove = arg2;
11328 0 : resultobj = SWIG_Py_Void();
11329 0 : return resultobj;
11330 : fail:
11331 : return NULL;
11332 : }
11333 :
11334 :
11335 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_remove_get(PyObject *self, PyObject *args) {
11336 0 : PyObject *resultobj = 0;
11337 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
11338 0 : void *argp1 = 0 ;
11339 0 : int res1 = 0 ;
11340 : gpgme_remove_io_cb_t result;
11341 :
11342 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11343 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11344 0 : if (!SWIG_IsOK(res1)) {
11345 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_remove_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
11346 : }
11347 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
11348 0 : result = (gpgme_remove_io_cb_t) ((arg1)->remove);
11349 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
11350 0 : return resultobj;
11351 : fail:
11352 : return NULL;
11353 : }
11354 :
11355 :
11356 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_set(PyObject *self, PyObject *args) {
11357 0 : PyObject *resultobj = 0;
11358 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
11359 0 : gpgme_event_io_cb_t arg2 = (gpgme_event_io_cb_t) 0 ;
11360 0 : void *argp1 = 0 ;
11361 0 : int res1 = 0 ;
11362 0 : PyObject * obj1 = 0 ;
11363 :
11364 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_event_set",&obj1)) SWIG_fail;
11365 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11366 0 : if (!SWIG_IsOK(res1)) {
11367 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
11368 : }
11369 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
11370 : {
11371 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_enum_gpgme_event_io_t_p_void__void);
11372 0 : if (!SWIG_IsOK(res)) {
11373 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_io_cbs_event_set" "', argument " "2"" of type '" "gpgme_event_io_cb_t""'");
11374 : }
11375 : }
11376 0 : if (arg1) (arg1)->event = arg2;
11377 0 : resultobj = SWIG_Py_Void();
11378 0 : return resultobj;
11379 : fail:
11380 : return NULL;
11381 : }
11382 :
11383 :
11384 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_get(PyObject *self, PyObject *args) {
11385 0 : PyObject *resultobj = 0;
11386 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
11387 0 : void *argp1 = 0 ;
11388 0 : int res1 = 0 ;
11389 : gpgme_event_io_cb_t result;
11390 :
11391 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11392 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11393 0 : if (!SWIG_IsOK(res1)) {
11394 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
11395 : }
11396 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
11397 0 : result = (gpgme_event_io_cb_t) ((arg1)->event);
11398 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_enum_gpgme_event_io_t_p_void__void);
11399 0 : return resultobj;
11400 : fail:
11401 : return NULL;
11402 : }
11403 :
11404 :
11405 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_priv_set(PyObject *self, PyObject *args) {
11406 0 : PyObject *resultobj = 0;
11407 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
11408 0 : void *arg2 = (void *) 0 ;
11409 0 : void *argp1 = 0 ;
11410 0 : int res1 = 0 ;
11411 : int res2 ;
11412 0 : PyObject * obj1 = 0 ;
11413 :
11414 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_event_priv_set",&obj1)) SWIG_fail;
11415 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11416 0 : if (!SWIG_IsOK(res1)) {
11417 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_priv_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
11418 : }
11419 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
11420 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
11421 0 : if (!SWIG_IsOK(res2)) {
11422 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_cbs_event_priv_set" "', argument " "2"" of type '" "void *""'");
11423 : }
11424 0 : if (arg1) (arg1)->event_priv = arg2;
11425 0 : resultobj = SWIG_Py_Void();
11426 0 : return resultobj;
11427 : fail:
11428 : return NULL;
11429 : }
11430 :
11431 :
11432 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_priv_get(PyObject *self, PyObject *args) {
11433 0 : PyObject *resultobj = 0;
11434 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
11435 0 : void *argp1 = 0 ;
11436 0 : int res1 = 0 ;
11437 0 : void *result = 0 ;
11438 :
11439 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11440 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11441 0 : if (!SWIG_IsOK(res1)) {
11442 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_priv_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
11443 : }
11444 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
11445 0 : result = (void *) ((arg1)->event_priv);
11446 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
11447 0 : return resultobj;
11448 : fail:
11449 : return NULL;
11450 : }
11451 :
11452 :
11453 0 : SWIGINTERN int _wrap_new_gpgme_io_cbs(PyObject *self, PyObject *args) {
11454 0 : PyObject *resultobj = 0;
11455 0 : struct gpgme_io_cbs *result = 0 ;
11456 :
11457 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11458 0 : result = (struct gpgme_io_cbs *)calloc(1, sizeof(struct gpgme_io_cbs));
11459 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_io_cbs, SWIG_BUILTIN_INIT | 0 );
11460 0 : return resultobj == Py_None ? -1 : 0;
11461 : fail:
11462 : return -1;
11463 : }
11464 :
11465 :
11466 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_io_cbs(PyObject *self, PyObject *args) {
11467 0 : PyObject *resultobj = 0;
11468 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
11469 0 : void *argp1 = 0 ;
11470 0 : int res1 = 0 ;
11471 :
11472 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11473 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_io_cbs, SWIG_POINTER_DISOWN | 0 );
11474 0 : if (!SWIG_IsOK(res1)) {
11475 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_io_cbs" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
11476 : }
11477 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
11478 0 : free((char *) arg1);
11479 0 : resultobj = SWIG_Py_Void();
11480 0 : return resultobj;
11481 : fail:
11482 : return NULL;
11483 : }
11484 :
11485 :
11486 0 : SWIGINTERN PyObject *_wrap_gpgme_set_io_cbs(PyObject *self, PyObject *args) {
11487 0 : PyObject *resultobj = 0;
11488 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11489 0 : gpgme_io_cbs_t arg2 = (gpgme_io_cbs_t) 0 ;
11490 0 : void *argp1 = 0 ;
11491 0 : int res1 = 0 ;
11492 0 : void *argp2 = 0 ;
11493 0 : int res2 = 0 ;
11494 0 : PyObject * obj0 = 0 ;
11495 0 : PyObject * obj1 = 0 ;
11496 :
11497 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_io_cbs",&obj0,&obj1)) SWIG_fail;
11498 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11499 0 : if (!SWIG_IsOK(res1)) {
11500 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_io_cbs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11501 : }
11502 0 : arg1 = (gpgme_ctx_t)(argp1);
11503 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11504 0 : if (!SWIG_IsOK(res2)) {
11505 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_set_io_cbs" "', argument " "2"" of type '" "gpgme_io_cbs_t""'");
11506 : }
11507 0 : arg2 = (gpgme_io_cbs_t)(argp2);
11508 0 : gpgme_set_io_cbs(arg1,arg2);
11509 0 : resultobj = SWIG_Py_Void();
11510 0 : return resultobj;
11511 : fail:
11512 : return NULL;
11513 : }
11514 :
11515 :
11516 0 : SWIGINTERN PyObject *_wrap_gpgme_get_io_cbs(PyObject *self, PyObject *args) {
11517 0 : PyObject *resultobj = 0;
11518 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11519 0 : gpgme_io_cbs_t arg2 = (gpgme_io_cbs_t) 0 ;
11520 0 : void *argp1 = 0 ;
11521 0 : int res1 = 0 ;
11522 0 : void *argp2 = 0 ;
11523 0 : int res2 = 0 ;
11524 0 : PyObject * obj0 = 0 ;
11525 0 : PyObject * obj1 = 0 ;
11526 :
11527 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_get_io_cbs",&obj0,&obj1)) SWIG_fail;
11528 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11529 0 : if (!SWIG_IsOK(res1)) {
11530 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_io_cbs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11531 : }
11532 0 : arg1 = (gpgme_ctx_t)(argp1);
11533 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
11534 0 : if (!SWIG_IsOK(res2)) {
11535 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_io_cbs" "', argument " "2"" of type '" "gpgme_io_cbs_t""'");
11536 : }
11537 0 : arg2 = (gpgme_io_cbs_t)(argp2);
11538 0 : gpgme_get_io_cbs(arg1,arg2);
11539 0 : resultobj = SWIG_Py_Void();
11540 0 : return resultobj;
11541 : fail:
11542 : return NULL;
11543 : }
11544 :
11545 :
11546 0 : SWIGINTERN PyObject *_wrap_gpgme_io_read(PyObject *self, PyObject *args) {
11547 0 : PyObject *resultobj = 0;
11548 : int arg1 ;
11549 0 : void *arg2 = (void *) 0 ;
11550 : size_t arg3 ;
11551 : int val1 ;
11552 0 : int ecode1 = 0 ;
11553 : int res2 ;
11554 : size_t val3 ;
11555 0 : int ecode3 = 0 ;
11556 0 : PyObject * obj0 = 0 ;
11557 0 : PyObject * obj1 = 0 ;
11558 0 : PyObject * obj2 = 0 ;
11559 : ssize_t result;
11560 :
11561 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_io_read",&obj0,&obj1,&obj2)) SWIG_fail;
11562 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
11563 0 : if (!SWIG_IsOK(ecode1)) {
11564 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_io_read" "', argument " "1"" of type '" "int""'");
11565 : }
11566 0 : arg1 = (int)(val1);
11567 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
11568 0 : if (!SWIG_IsOK(res2)) {
11569 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_read" "', argument " "2"" of type '" "void *""'");
11570 : }
11571 0 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
11572 0 : if (!SWIG_IsOK(ecode3)) {
11573 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_io_read" "', argument " "3"" of type '" "size_t""'");
11574 : }
11575 0 : arg3 = (size_t)(val3);
11576 0 : result = gpgme_io_read(arg1,arg2,arg3);
11577 : {
11578 0 : resultobj = PyLong_FromLong(result);
11579 : }
11580 0 : return resultobj;
11581 : fail:
11582 : return NULL;
11583 : }
11584 :
11585 :
11586 0 : SWIGINTERN PyObject *_wrap_gpgme_io_write(PyObject *self, PyObject *args) {
11587 0 : PyObject *resultobj = 0;
11588 : int arg1 ;
11589 0 : void *arg2 = (void *) 0 ;
11590 : size_t arg3 ;
11591 : int val1 ;
11592 0 : int ecode1 = 0 ;
11593 : int res2 ;
11594 : size_t val3 ;
11595 0 : int ecode3 = 0 ;
11596 0 : PyObject * obj0 = 0 ;
11597 0 : PyObject * obj1 = 0 ;
11598 0 : PyObject * obj2 = 0 ;
11599 : ssize_t result;
11600 :
11601 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_io_write",&obj0,&obj1,&obj2)) SWIG_fail;
11602 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
11603 0 : if (!SWIG_IsOK(ecode1)) {
11604 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_io_write" "', argument " "1"" of type '" "int""'");
11605 : }
11606 0 : arg1 = (int)(val1);
11607 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
11608 0 : if (!SWIG_IsOK(res2)) {
11609 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_write" "', argument " "2"" of type '" "void const *""'");
11610 : }
11611 0 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
11612 0 : if (!SWIG_IsOK(ecode3)) {
11613 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_io_write" "', argument " "3"" of type '" "size_t""'");
11614 : }
11615 0 : arg3 = (size_t)(val3);
11616 0 : result = gpgme_io_write(arg1,(void const *)arg2,arg3);
11617 : {
11618 0 : resultobj = PyLong_FromLong(result);
11619 : }
11620 0 : return resultobj;
11621 : fail:
11622 : return NULL;
11623 : }
11624 :
11625 :
11626 0 : SWIGINTERN PyObject *_wrap_gpgme_io_writen(PyObject *self, PyObject *args) {
11627 0 : PyObject *resultobj = 0;
11628 : int arg1 ;
11629 0 : void *arg2 = (void *) 0 ;
11630 : size_t arg3 ;
11631 : int val1 ;
11632 0 : int ecode1 = 0 ;
11633 : int res2 ;
11634 : size_t val3 ;
11635 0 : int ecode3 = 0 ;
11636 0 : PyObject * obj0 = 0 ;
11637 0 : PyObject * obj1 = 0 ;
11638 0 : PyObject * obj2 = 0 ;
11639 : int result;
11640 :
11641 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_io_writen",&obj0,&obj1,&obj2)) SWIG_fail;
11642 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
11643 0 : if (!SWIG_IsOK(ecode1)) {
11644 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_io_writen" "', argument " "1"" of type '" "int""'");
11645 : }
11646 0 : arg1 = (int)(val1);
11647 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
11648 0 : if (!SWIG_IsOK(res2)) {
11649 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_writen" "', argument " "2"" of type '" "void const *""'");
11650 : }
11651 0 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
11652 0 : if (!SWIG_IsOK(ecode3)) {
11653 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_io_writen" "', argument " "3"" of type '" "size_t""'");
11654 : }
11655 0 : arg3 = (size_t)(val3);
11656 0 : result = (int)gpgme_io_writen(arg1,(void const *)arg2,arg3);
11657 0 : resultobj = SWIG_From_int((int)(result));
11658 0 : return resultobj;
11659 : fail:
11660 : return NULL;
11661 : }
11662 :
11663 :
11664 3 : SWIGINTERN PyObject *_wrap_gpgme_wait(PyObject *self, PyObject *args) {
11665 3 : PyObject *resultobj = 0;
11666 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11667 3 : gpgme_error_t *arg2 = (gpgme_error_t *) 0 ;
11668 : int arg3 ;
11669 3 : void *argp1 = 0 ;
11670 3 : int res1 = 0 ;
11671 3 : void *argp2 = 0 ;
11672 3 : int res2 = 0 ;
11673 : int val3 ;
11674 3 : int ecode3 = 0 ;
11675 3 : PyObject * obj0 = 0 ;
11676 3 : PyObject * obj1 = 0 ;
11677 3 : PyObject * obj2 = 0 ;
11678 : gpgme_ctx_t result;
11679 :
11680 3 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_wait",&obj0,&obj1,&obj2)) SWIG_fail;
11681 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11682 3 : if (!SWIG_IsOK(res1)) {
11683 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_wait" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11684 : }
11685 3 : arg1 = (gpgme_ctx_t)(argp1);
11686 3 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpg_error_t, 0 | 0 );
11687 3 : if (!SWIG_IsOK(res2)) {
11688 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_wait" "', argument " "2"" of type '" "gpgme_error_t *""'");
11689 : }
11690 3 : arg2 = (gpgme_error_t *)(argp2);
11691 3 : ecode3 = SWIG_AsVal_int(obj2, &val3);
11692 3 : if (!SWIG_IsOK(ecode3)) {
11693 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_wait" "', argument " "3"" of type '" "int""'");
11694 : }
11695 3 : arg3 = (int)(val3);
11696 3 : result = (gpgme_ctx_t)gpgme_wait(arg1,arg2,arg3);
11697 3 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_context, 0 | 0 );
11698 3 : return resultobj;
11699 : fail:
11700 : return NULL;
11701 : }
11702 :
11703 :
11704 0 : SWIGINTERN PyObject *_wrap_gpgme_wait_ext(PyObject *self, PyObject *args) {
11705 0 : PyObject *resultobj = 0;
11706 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11707 0 : gpgme_error_t *arg2 = (gpgme_error_t *) 0 ;
11708 0 : gpgme_error_t *arg3 = (gpgme_error_t *) 0 ;
11709 : int arg4 ;
11710 0 : void *argp1 = 0 ;
11711 0 : int res1 = 0 ;
11712 0 : void *argp2 = 0 ;
11713 0 : int res2 = 0 ;
11714 0 : void *argp3 = 0 ;
11715 0 : int res3 = 0 ;
11716 : int val4 ;
11717 0 : int ecode4 = 0 ;
11718 0 : PyObject * obj0 = 0 ;
11719 0 : PyObject * obj1 = 0 ;
11720 0 : PyObject * obj2 = 0 ;
11721 0 : PyObject * obj3 = 0 ;
11722 : gpgme_ctx_t result;
11723 :
11724 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_wait_ext",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11725 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11726 0 : if (!SWIG_IsOK(res1)) {
11727 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_wait_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11728 : }
11729 0 : arg1 = (gpgme_ctx_t)(argp1);
11730 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpg_error_t, 0 | 0 );
11731 0 : if (!SWIG_IsOK(res2)) {
11732 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_wait_ext" "', argument " "2"" of type '" "gpgme_error_t *""'");
11733 : }
11734 0 : arg2 = (gpgme_error_t *)(argp2);
11735 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_gpg_error_t, 0 | 0 );
11736 0 : if (!SWIG_IsOK(res3)) {
11737 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_wait_ext" "', argument " "3"" of type '" "gpgme_error_t *""'");
11738 : }
11739 0 : arg3 = (gpgme_error_t *)(argp3);
11740 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
11741 0 : if (!SWIG_IsOK(ecode4)) {
11742 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_wait_ext" "', argument " "4"" of type '" "int""'");
11743 : }
11744 0 : arg4 = (int)(val4);
11745 0 : result = (gpgme_ctx_t)gpgme_wait_ext(arg1,arg2,arg3,arg4);
11746 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_context, 0 | 0 );
11747 0 : return resultobj;
11748 : fail:
11749 : return NULL;
11750 : }
11751 :
11752 :
11753 0 : SWIGINTERN PyObject *_wrap_gpgme_cancel(PyObject *self, PyObject *args) {
11754 0 : PyObject *resultobj = 0;
11755 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11756 0 : void *argp1 = 0 ;
11757 0 : int res1 = 0 ;
11758 0 : PyObject * obj0 = 0 ;
11759 : gpgme_error_t result;
11760 :
11761 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_cancel",&obj0)) SWIG_fail;
11762 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11763 0 : if (!SWIG_IsOK(res1)) {
11764 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_cancel" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11765 : }
11766 0 : arg1 = (gpgme_ctx_t)(argp1);
11767 0 : result = gpgme_cancel(arg1);
11768 : {
11769 0 : resultobj = PyLong_FromLong(result);
11770 : }
11771 0 : return resultobj;
11772 : fail:
11773 : return NULL;
11774 : }
11775 :
11776 :
11777 0 : SWIGINTERN PyObject *_wrap_gpgme_cancel_async(PyObject *self, PyObject *args) {
11778 0 : PyObject *resultobj = 0;
11779 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11780 0 : void *argp1 = 0 ;
11781 0 : int res1 = 0 ;
11782 0 : PyObject * obj0 = 0 ;
11783 : gpgme_error_t result;
11784 :
11785 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_cancel_async",&obj0)) SWIG_fail;
11786 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11787 0 : if (!SWIG_IsOK(res1)) {
11788 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_cancel_async" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11789 : }
11790 0 : arg1 = (gpgme_ctx_t)(argp1);
11791 0 : result = gpgme_cancel_async(arg1);
11792 : {
11793 0 : resultobj = PyLong_FromLong(result);
11794 : }
11795 0 : return resultobj;
11796 : fail:
11797 : return NULL;
11798 : }
11799 :
11800 :
11801 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_read_set(PyObject *self, PyObject *args) {
11802 0 : PyObject *resultobj = 0;
11803 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
11804 0 : gpgme_data_read_cb_t arg2 = (gpgme_data_read_cb_t) 0 ;
11805 0 : void *argp1 = 0 ;
11806 0 : int res1 = 0 ;
11807 0 : PyObject * obj1 = 0 ;
11808 :
11809 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_read_set",&obj1)) SWIG_fail;
11810 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
11811 0 : if (!SWIG_IsOK(res1)) {
11812 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_read_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
11813 : }
11814 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
11815 : {
11816 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void_size_t__ssize_t);
11817 0 : if (!SWIG_IsOK(res)) {
11818 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_read_set" "', argument " "2"" of type '" "gpgme_data_read_cb_t""'");
11819 : }
11820 : }
11821 0 : if (arg1) (arg1)->read = arg2;
11822 0 : resultobj = SWIG_Py_Void();
11823 0 : return resultobj;
11824 : fail:
11825 : return NULL;
11826 : }
11827 :
11828 :
11829 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_read_get(PyObject *self, PyObject *args) {
11830 0 : PyObject *resultobj = 0;
11831 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
11832 0 : void *argp1 = 0 ;
11833 0 : int res1 = 0 ;
11834 : gpgme_data_read_cb_t result;
11835 :
11836 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11837 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
11838 0 : if (!SWIG_IsOK(res1)) {
11839 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_read_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
11840 : }
11841 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
11842 0 : result = (gpgme_data_read_cb_t) ((arg1)->read);
11843 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_void_size_t__ssize_t);
11844 0 : return resultobj;
11845 : fail:
11846 : return NULL;
11847 : }
11848 :
11849 :
11850 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_write_set(PyObject *self, PyObject *args) {
11851 0 : PyObject *resultobj = 0;
11852 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
11853 0 : gpgme_data_write_cb_t arg2 = (gpgme_data_write_cb_t) 0 ;
11854 0 : void *argp1 = 0 ;
11855 0 : int res1 = 0 ;
11856 0 : PyObject * obj1 = 0 ;
11857 :
11858 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_write_set",&obj1)) SWIG_fail;
11859 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
11860 0 : if (!SWIG_IsOK(res1)) {
11861 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_write_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
11862 : }
11863 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
11864 : {
11865 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__void_size_t__ssize_t);
11866 0 : if (!SWIG_IsOK(res)) {
11867 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_write_set" "', argument " "2"" of type '" "gpgme_data_write_cb_t""'");
11868 : }
11869 : }
11870 0 : if (arg1) (arg1)->write = arg2;
11871 0 : resultobj = SWIG_Py_Void();
11872 0 : return resultobj;
11873 : fail:
11874 : return NULL;
11875 : }
11876 :
11877 :
11878 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_write_get(PyObject *self, PyObject *args) {
11879 0 : PyObject *resultobj = 0;
11880 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
11881 0 : void *argp1 = 0 ;
11882 0 : int res1 = 0 ;
11883 : gpgme_data_write_cb_t result;
11884 :
11885 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11886 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
11887 0 : if (!SWIG_IsOK(res1)) {
11888 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_write_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
11889 : }
11890 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
11891 0 : result = (gpgme_data_write_cb_t) ((arg1)->write);
11892 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__void_size_t__ssize_t);
11893 0 : return resultobj;
11894 : fail:
11895 : return NULL;
11896 : }
11897 :
11898 :
11899 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_seek_set(PyObject *self, PyObject *args) {
11900 0 : PyObject *resultobj = 0;
11901 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
11902 0 : gpgme_data_seek_cb_t arg2 = (gpgme_data_seek_cb_t) 0 ;
11903 0 : void *argp1 = 0 ;
11904 0 : int res1 = 0 ;
11905 0 : PyObject * obj1 = 0 ;
11906 :
11907 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_seek_set",&obj1)) SWIG_fail;
11908 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
11909 0 : if (!SWIG_IsOK(res1)) {
11910 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_seek_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
11911 : }
11912 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
11913 : {
11914 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_off_t_int__off_t);
11915 0 : if (!SWIG_IsOK(res)) {
11916 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_seek_set" "', argument " "2"" of type '" "gpgme_data_seek_cb_t""'");
11917 : }
11918 : }
11919 0 : if (arg1) (arg1)->seek = arg2;
11920 0 : resultobj = SWIG_Py_Void();
11921 0 : return resultobj;
11922 : fail:
11923 : return NULL;
11924 : }
11925 :
11926 :
11927 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_seek_get(PyObject *self, PyObject *args) {
11928 0 : PyObject *resultobj = 0;
11929 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
11930 0 : void *argp1 = 0 ;
11931 0 : int res1 = 0 ;
11932 : gpgme_data_seek_cb_t result;
11933 :
11934 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11935 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
11936 0 : if (!SWIG_IsOK(res1)) {
11937 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_seek_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
11938 : }
11939 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
11940 0 : result = (gpgme_data_seek_cb_t) ((arg1)->seek);
11941 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_off_t_int__off_t);
11942 0 : return resultobj;
11943 : fail:
11944 : return NULL;
11945 : }
11946 :
11947 :
11948 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_release_set(PyObject *self, PyObject *args) {
11949 0 : PyObject *resultobj = 0;
11950 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
11951 0 : gpgme_data_release_cb_t arg2 = (gpgme_data_release_cb_t) 0 ;
11952 0 : void *argp1 = 0 ;
11953 0 : int res1 = 0 ;
11954 0 : PyObject * obj1 = 0 ;
11955 :
11956 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_release_set",&obj1)) SWIG_fail;
11957 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
11958 0 : if (!SWIG_IsOK(res1)) {
11959 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_release_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
11960 : }
11961 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
11962 : {
11963 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
11964 0 : if (!SWIG_IsOK(res)) {
11965 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_release_set" "', argument " "2"" of type '" "gpgme_data_release_cb_t""'");
11966 : }
11967 : }
11968 0 : if (arg1) (arg1)->release = arg2;
11969 0 : resultobj = SWIG_Py_Void();
11970 0 : return resultobj;
11971 : fail:
11972 : return NULL;
11973 : }
11974 :
11975 :
11976 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_release_get(PyObject *self, PyObject *args) {
11977 0 : PyObject *resultobj = 0;
11978 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
11979 0 : void *argp1 = 0 ;
11980 0 : int res1 = 0 ;
11981 : gpgme_data_release_cb_t result;
11982 :
11983 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
11984 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
11985 0 : if (!SWIG_IsOK(res1)) {
11986 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_release_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
11987 : }
11988 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
11989 0 : result = (gpgme_data_release_cb_t) ((arg1)->release);
11990 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
11991 0 : return resultobj;
11992 : fail:
11993 : return NULL;
11994 : }
11995 :
11996 :
11997 0 : SWIGINTERN int _wrap_new_gpgme_data_cbs(PyObject *self, PyObject *args) {
11998 0 : PyObject *resultobj = 0;
11999 0 : struct gpgme_data_cbs *result = 0 ;
12000 :
12001 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
12002 0 : result = (struct gpgme_data_cbs *)calloc(1, sizeof(struct gpgme_data_cbs));
12003 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_data_cbs, SWIG_BUILTIN_INIT | 0 );
12004 0 : return resultobj == Py_None ? -1 : 0;
12005 : fail:
12006 : return -1;
12007 : }
12008 :
12009 :
12010 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_data_cbs(PyObject *self, PyObject *args) {
12011 0 : PyObject *resultobj = 0;
12012 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
12013 0 : void *argp1 = 0 ;
12014 0 : int res1 = 0 ;
12015 :
12016 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
12017 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_data_cbs, SWIG_POINTER_DISOWN | 0 );
12018 0 : if (!SWIG_IsOK(res1)) {
12019 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_data_cbs" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
12020 : }
12021 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
12022 0 : free((char *) arg1);
12023 0 : resultobj = SWIG_Py_Void();
12024 0 : return resultobj;
12025 : fail:
12026 : return NULL;
12027 : }
12028 :
12029 :
12030 72 : SWIGINTERN PyObject *_wrap_gpgme_data_read(PyObject *self, PyObject *args) {
12031 72 : PyObject *resultobj = 0;
12032 72 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
12033 72 : void *arg2 = (void *) 0 ;
12034 : size_t arg3 ;
12035 72 : void *argp1 = 0 ;
12036 72 : int res1 = 0 ;
12037 72 : PyObject * obj0 = 0 ;
12038 72 : PyObject * obj1 = 0 ;
12039 : ssize_t result;
12040 :
12041 72 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_read",&obj0,&obj1)) SWIG_fail;
12042 72 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
12043 72 : if (!SWIG_IsOK(res1)) {
12044 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_read" "', argument " "1"" of type '" "gpgme_data_t""'");
12045 : }
12046 72 : arg1 = (gpgme_data_t)(argp1);
12047 : {
12048 72 : arg3 = PyLong_AsLong(obj1);
12049 : if (arg3 < 0) {
12050 : PyErr_SetString(PyExc_ValueError, "Positive integer expected");
12051 : return NULL;
12052 : }
12053 72 : arg2 = (void *) malloc(arg3+1);
12054 : }
12055 72 : result = gpgme_data_read(arg1,arg2,arg3);
12056 : {
12057 72 : resultobj = PyLong_FromLong(result);
12058 : }
12059 : {
12060 72 : Py_XDECREF(resultobj); /* Blow away any previous result */
12061 72 : if (result < 0) {
12062 : /* Check for I/O error */
12063 2 : free(arg2);
12064 2 : return PyErr_SetFromErrno(PyExc_RuntimeError);
12065 : }
12066 70 : resultobj = PyBytes_FromStringAndSize(arg2,result);
12067 70 : free(arg2);
12068 : }
12069 70 : return resultobj;
12070 : fail:
12071 : return NULL;
12072 : }
12073 :
12074 :
12075 8 : SWIGINTERN PyObject *_wrap_gpgme_data_write(PyObject *self, PyObject *args) {
12076 8 : PyObject *resultobj = 0;
12077 8 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
12078 8 : void *arg2 = (void *) 0 ;
12079 : size_t arg3 ;
12080 8 : void *argp1 = 0 ;
12081 8 : int res1 = 0 ;
12082 8 : PyObject * obj0 = 0 ;
12083 8 : PyObject * obj1 = 0 ;
12084 : ssize_t result;
12085 :
12086 8 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_write",&obj0,&obj1)) SWIG_fail;
12087 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
12088 8 : if (!SWIG_IsOK(res1)) {
12089 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_write" "', argument " "1"" of type '" "gpgme_data_t""'");
12090 : }
12091 8 : arg1 = (gpgme_data_t)(argp1);
12092 : {
12093 : Py_ssize_t ssize;
12094 :
12095 8 : if (obj1 == Py_None)
12096 0 : arg2 = NULL, arg3 = 0;
12097 8 : else if (PyUnicode_Check(obj1))
12098 3 : arg2 = PyUnicode_AsUTF8AndSize(obj1, &ssize);
12099 5 : else if (PyBytes_Check(obj1))
12100 5 : PyBytes_AsStringAndSize(obj1, (char **) &arg2, &ssize);
12101 : else {
12102 0 : PyErr_Format(PyExc_TypeError,
12103 : "arg %d: expected str, bytes, or None, got %s",
12104 : 2, obj1->ob_type->tp_name);
12105 0 : return NULL;
12106 : }
12107 :
12108 8 : if (! arg2)
12109 : arg3 = 0;
12110 : else
12111 : {
12112 : assert (ssize >= 0);
12113 8 : arg3 = (size_t) ssize;
12114 : }
12115 : }
12116 8 : result = gpgme_data_write(arg1,(void const *)arg2,arg3);
12117 : {
12118 8 : resultobj = PyLong_FromLong(result);
12119 : }
12120 8 : return resultobj;
12121 : fail:
12122 : return NULL;
12123 : }
12124 :
12125 :
12126 36 : SWIGINTERN PyObject *_wrap_gpgme_data_seek(PyObject *self, PyObject *args) {
12127 36 : PyObject *resultobj = 0;
12128 36 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
12129 : off_t arg2 ;
12130 : int arg3 ;
12131 36 : void *argp1 = 0 ;
12132 36 : int res1 = 0 ;
12133 : int val3 ;
12134 36 : int ecode3 = 0 ;
12135 36 : PyObject * obj0 = 0 ;
12136 36 : PyObject * obj1 = 0 ;
12137 36 : PyObject * obj2 = 0 ;
12138 : off_t result;
12139 :
12140 36 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_seek",&obj0,&obj1,&obj2)) SWIG_fail;
12141 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
12142 36 : if (!SWIG_IsOK(res1)) {
12143 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_seek" "', argument " "1"" of type '" "gpgme_data_t""'");
12144 : }
12145 36 : arg1 = (gpgme_data_t)(argp1);
12146 : {
12147 36 : arg2 = PyLong_AsLong(obj1);
12148 : }
12149 36 : ecode3 = SWIG_AsVal_int(obj2, &val3);
12150 36 : if (!SWIG_IsOK(ecode3)) {
12151 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_data_seek" "', argument " "3"" of type '" "int""'");
12152 : }
12153 36 : arg3 = (int)(val3);
12154 36 : result = gpgme_data_seek(arg1,arg2,arg3);
12155 : {
12156 36 : resultobj = PyLong_FromLong(result);
12157 : }
12158 36 : return resultobj;
12159 : fail:
12160 : return NULL;
12161 : }
12162 :
12163 :
12164 61 : SWIGINTERN PyObject *_wrap_gpgme_data_new(PyObject *self, PyObject *args) {
12165 61 : PyObject *resultobj = 0;
12166 61 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
12167 61 : void *argp1 = 0 ;
12168 61 : int res1 = 0 ;
12169 61 : PyObject * obj0 = 0 ;
12170 : gpgme_error_t result;
12171 :
12172 61 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_new",&obj0)) SWIG_fail;
12173 61 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
12174 61 : if (!SWIG_IsOK(res1)) {
12175 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new" "', argument " "1"" of type '" "gpgme_data_t *""'");
12176 : }
12177 61 : arg1 = (gpgme_data_t *)(argp1);
12178 61 : result = gpgme_data_new(arg1);
12179 : {
12180 61 : resultobj = PyLong_FromLong(result);
12181 : }
12182 61 : return resultobj;
12183 : fail:
12184 : return NULL;
12185 : }
12186 :
12187 :
12188 95 : SWIGINTERN PyObject *_wrap_gpgme_data_release(PyObject *self, PyObject *args) {
12189 95 : PyObject *resultobj = 0;
12190 95 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
12191 95 : void *argp1 = 0 ;
12192 95 : int res1 = 0 ;
12193 95 : PyObject * obj0 = 0 ;
12194 :
12195 95 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_release",&obj0)) SWIG_fail;
12196 95 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
12197 95 : if (!SWIG_IsOK(res1)) {
12198 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_release" "', argument " "1"" of type '" "gpgme_data_t""'");
12199 : }
12200 95 : arg1 = (gpgme_data_t)(argp1);
12201 95 : gpgme_data_release(arg1);
12202 95 : resultobj = SWIG_Py_Void();
12203 95 : return resultobj;
12204 : fail:
12205 : return NULL;
12206 : }
12207 :
12208 :
12209 24 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_mem(PyObject *self, PyObject *args) {
12210 24 : PyObject *resultobj = 0;
12211 24 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
12212 24 : char *arg2 = (char *) 0 ;
12213 : size_t arg3 ;
12214 : int arg4 ;
12215 24 : void *argp1 = 0 ;
12216 24 : int res1 = 0 ;
12217 : size_t val3 ;
12218 24 : int ecode3 = 0 ;
12219 : int val4 ;
12220 24 : int ecode4 = 0 ;
12221 24 : PyObject * obj0 = 0 ;
12222 24 : PyObject * obj1 = 0 ;
12223 24 : PyObject * obj2 = 0 ;
12224 24 : PyObject * obj3 = 0 ;
12225 : gpgme_error_t result;
12226 :
12227 24 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_data_new_from_mem",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12228 24 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
12229 24 : if (!SWIG_IsOK(res1)) {
12230 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_mem" "', argument " "1"" of type '" "gpgme_data_t *""'");
12231 : }
12232 24 : arg1 = (gpgme_data_t *)(argp1);
12233 : {
12234 24 : if (obj1 == Py_None)
12235 : arg2 = NULL;
12236 24 : else if (PyUnicode_Check(obj1))
12237 16 : arg2 = PyUnicode_AsUTF8(obj1);
12238 8 : else if (PyBytes_Check(obj1))
12239 8 : arg2 = PyBytes_AsString(obj1);
12240 : else {
12241 0 : PyErr_Format(PyExc_TypeError,
12242 : "arg %d: expected str, bytes, or None, got %s",
12243 : 2, obj1->ob_type->tp_name);
12244 0 : return NULL;
12245 : }
12246 : }
12247 24 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
12248 24 : if (!SWIG_IsOK(ecode3)) {
12249 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_data_new_from_mem" "', argument " "3"" of type '" "size_t""'");
12250 : }
12251 24 : arg3 = (size_t)(val3);
12252 24 : ecode4 = SWIG_AsVal_int(obj3, &val4);
12253 24 : if (!SWIG_IsOK(ecode4)) {
12254 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_data_new_from_mem" "', argument " "4"" of type '" "int""'");
12255 : }
12256 24 : arg4 = (int)(val4);
12257 24 : result = gpgme_data_new_from_mem(arg1,(char const *)arg2,arg3,arg4);
12258 : {
12259 24 : resultobj = PyLong_FromLong(result);
12260 : }
12261 24 : return resultobj;
12262 : fail:
12263 : return NULL;
12264 : }
12265 :
12266 :
12267 0 : SWIGINTERN PyObject *_wrap_gpgme_data_release_and_get_mem(PyObject *self, PyObject *args) {
12268 0 : PyObject *resultobj = 0;
12269 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
12270 0 : size_t *arg2 = (size_t *) 0 ;
12271 0 : void *argp1 = 0 ;
12272 0 : int res1 = 0 ;
12273 0 : void *argp2 = 0 ;
12274 0 : int res2 = 0 ;
12275 0 : PyObject * obj0 = 0 ;
12276 0 : PyObject * obj1 = 0 ;
12277 0 : char *result = 0 ;
12278 :
12279 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_release_and_get_mem",&obj0,&obj1)) SWIG_fail;
12280 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
12281 0 : if (!SWIG_IsOK(res1)) {
12282 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_release_and_get_mem" "', argument " "1"" of type '" "gpgme_data_t""'");
12283 : }
12284 0 : arg1 = (gpgme_data_t)(argp1);
12285 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_size_t, 0 | 0 );
12286 0 : if (!SWIG_IsOK(res2)) {
12287 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_release_and_get_mem" "', argument " "2"" of type '" "size_t *""'");
12288 : }
12289 0 : arg2 = (size_t *)(argp2);
12290 0 : result = (char *)gpgme_data_release_and_get_mem(arg1,arg2);
12291 0 : resultobj = SWIG_FromCharPtr((const char *)result);
12292 0 : free(result);
12293 0 : return resultobj;
12294 : fail:
12295 : return NULL;
12296 : }
12297 :
12298 :
12299 0 : SWIGINTERN PyObject *_wrap_gpgme_free(PyObject *self, PyObject *args) {
12300 0 : PyObject *resultobj = 0;
12301 0 : void *arg1 = (void *) 0 ;
12302 : int res1 ;
12303 0 : PyObject * obj0 = 0 ;
12304 :
12305 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_free",&obj0)) SWIG_fail;
12306 0 : res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
12307 0 : if (!SWIG_IsOK(res1)) {
12308 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_free" "', argument " "1"" of type '" "void *""'");
12309 : }
12310 0 : gpgme_free(arg1);
12311 0 : resultobj = SWIG_Py_Void();
12312 0 : return resultobj;
12313 : fail:
12314 : return NULL;
12315 : }
12316 :
12317 :
12318 0 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_cbs(PyObject *self, PyObject *args) {
12319 0 : PyObject *resultobj = 0;
12320 0 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
12321 0 : gpgme_data_cbs_t arg2 = (gpgme_data_cbs_t) 0 ;
12322 0 : void *arg3 = (void *) 0 ;
12323 0 : void *argp1 = 0 ;
12324 0 : int res1 = 0 ;
12325 0 : void *argp2 = 0 ;
12326 0 : int res2 = 0 ;
12327 : int res3 ;
12328 0 : PyObject * obj0 = 0 ;
12329 0 : PyObject * obj1 = 0 ;
12330 0 : PyObject * obj2 = 0 ;
12331 : gpgme_error_t result;
12332 :
12333 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_new_from_cbs",&obj0,&obj1,&obj2)) SWIG_fail;
12334 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
12335 0 : if (!SWIG_IsOK(res1)) {
12336 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_cbs" "', argument " "1"" of type '" "gpgme_data_t *""'");
12337 : }
12338 0 : arg1 = (gpgme_data_t *)(argp1);
12339 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
12340 0 : if (!SWIG_IsOK(res2)) {
12341 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_new_from_cbs" "', argument " "2"" of type '" "gpgme_data_cbs_t""'");
12342 : }
12343 0 : arg2 = (gpgme_data_cbs_t)(argp2);
12344 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
12345 0 : if (!SWIG_IsOK(res3)) {
12346 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_data_new_from_cbs" "', argument " "3"" of type '" "void *""'");
12347 : }
12348 0 : result = gpgme_data_new_from_cbs(arg1,arg2,arg3);
12349 : {
12350 0 : resultobj = PyLong_FromLong(result);
12351 : }
12352 0 : return resultobj;
12353 : fail:
12354 : return NULL;
12355 : }
12356 :
12357 :
12358 1 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_fd(PyObject *self, PyObject *args) {
12359 1 : PyObject *resultobj = 0;
12360 1 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
12361 : int arg2 ;
12362 1 : void *argp1 = 0 ;
12363 1 : int res1 = 0 ;
12364 : int val2 ;
12365 1 : int ecode2 = 0 ;
12366 1 : PyObject * obj0 = 0 ;
12367 1 : PyObject * obj1 = 0 ;
12368 : gpgme_error_t result;
12369 :
12370 1 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_new_from_fd",&obj0,&obj1)) SWIG_fail;
12371 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
12372 1 : if (!SWIG_IsOK(res1)) {
12373 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_fd" "', argument " "1"" of type '" "gpgme_data_t *""'");
12374 : }
12375 1 : arg1 = (gpgme_data_t *)(argp1);
12376 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12377 1 : if (!SWIG_IsOK(ecode2)) {
12378 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_data_new_from_fd" "', argument " "2"" of type '" "int""'");
12379 : }
12380 1 : arg2 = (int)(val2);
12381 1 : result = gpgme_data_new_from_fd(arg1,arg2);
12382 : {
12383 1 : resultobj = PyLong_FromLong(result);
12384 : }
12385 1 : return resultobj;
12386 : fail:
12387 : return NULL;
12388 : }
12389 :
12390 :
12391 0 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_stream(PyObject *self, PyObject *args) {
12392 0 : PyObject *resultobj = 0;
12393 0 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
12394 0 : FILE *arg2 = (FILE *) 0 ;
12395 0 : void *argp1 = 0 ;
12396 0 : int res1 = 0 ;
12397 0 : void *argp2 = 0 ;
12398 0 : int res2 = 0 ;
12399 0 : PyObject * obj0 = 0 ;
12400 0 : PyObject * obj1 = 0 ;
12401 : gpgme_error_t result;
12402 :
12403 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_new_from_stream",&obj0,&obj1)) SWIG_fail;
12404 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
12405 0 : if (!SWIG_IsOK(res1)) {
12406 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_stream" "', argument " "1"" of type '" "gpgme_data_t *""'");
12407 : }
12408 0 : arg1 = (gpgme_data_t *)(argp1);
12409 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 | 0 );
12410 0 : if (!SWIG_IsOK(res2)) {
12411 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_new_from_stream" "', argument " "2"" of type '" "FILE *""'");
12412 : }
12413 0 : arg2 = (FILE *)(argp2);
12414 0 : result = gpgme_data_new_from_stream(arg1,arg2);
12415 : {
12416 0 : resultobj = PyLong_FromLong(result);
12417 : }
12418 0 : return resultobj;
12419 : fail:
12420 : return NULL;
12421 : }
12422 :
12423 :
12424 0 : SWIGINTERN PyObject *_wrap_gpgme_data_get_encoding(PyObject *self, PyObject *args) {
12425 0 : PyObject *resultobj = 0;
12426 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
12427 0 : void *argp1 = 0 ;
12428 0 : int res1 = 0 ;
12429 0 : PyObject * obj0 = 0 ;
12430 : gpgme_data_encoding_t result;
12431 :
12432 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_get_encoding",&obj0)) SWIG_fail;
12433 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
12434 0 : if (!SWIG_IsOK(res1)) {
12435 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_get_encoding" "', argument " "1"" of type '" "gpgme_data_t""'");
12436 : }
12437 0 : arg1 = (gpgme_data_t)(argp1);
12438 0 : result = (gpgme_data_encoding_t)gpgme_data_get_encoding(arg1);
12439 0 : resultobj = SWIG_From_int((int)(result));
12440 0 : return resultobj;
12441 : fail:
12442 : return NULL;
12443 : }
12444 :
12445 :
12446 0 : SWIGINTERN PyObject *_wrap_gpgme_data_set_encoding(PyObject *self, PyObject *args) {
12447 0 : PyObject *resultobj = 0;
12448 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
12449 : gpgme_data_encoding_t arg2 ;
12450 0 : void *argp1 = 0 ;
12451 0 : int res1 = 0 ;
12452 : int val2 ;
12453 0 : int ecode2 = 0 ;
12454 0 : PyObject * obj0 = 0 ;
12455 0 : PyObject * obj1 = 0 ;
12456 : gpgme_error_t result;
12457 :
12458 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_set_encoding",&obj0,&obj1)) SWIG_fail;
12459 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
12460 0 : if (!SWIG_IsOK(res1)) {
12461 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_set_encoding" "', argument " "1"" of type '" "gpgme_data_t""'");
12462 : }
12463 0 : arg1 = (gpgme_data_t)(argp1);
12464 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12465 0 : if (!SWIG_IsOK(ecode2)) {
12466 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_data_set_encoding" "', argument " "2"" of type '" "gpgme_data_encoding_t""'");
12467 : }
12468 0 : arg2 = (gpgme_data_encoding_t)(val2);
12469 0 : result = gpgme_data_set_encoding(arg1,arg2);
12470 : {
12471 0 : resultobj = PyLong_FromLong(result);
12472 : }
12473 0 : return resultobj;
12474 : fail:
12475 : return NULL;
12476 : }
12477 :
12478 :
12479 1 : SWIGINTERN PyObject *_wrap_gpgme_data_get_file_name(PyObject *self, PyObject *args) {
12480 1 : PyObject *resultobj = 0;
12481 1 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
12482 1 : void *argp1 = 0 ;
12483 1 : int res1 = 0 ;
12484 1 : PyObject * obj0 = 0 ;
12485 1 : char *result = 0 ;
12486 :
12487 1 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_get_file_name",&obj0)) SWIG_fail;
12488 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
12489 1 : if (!SWIG_IsOK(res1)) {
12490 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_get_file_name" "', argument " "1"" of type '" "gpgme_data_t""'");
12491 : }
12492 1 : arg1 = (gpgme_data_t)(argp1);
12493 1 : result = (char *)gpgme_data_get_file_name(arg1);
12494 1 : resultobj = SWIG_FromCharPtr((const char *)result);
12495 1 : return resultobj;
12496 : fail:
12497 : return NULL;
12498 : }
12499 :
12500 :
12501 2 : SWIGINTERN PyObject *_wrap_gpgme_data_set_file_name(PyObject *self, PyObject *args) {
12502 2 : PyObject *resultobj = 0;
12503 2 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
12504 2 : char *arg2 = (char *) 0 ;
12505 2 : void *argp1 = 0 ;
12506 2 : int res1 = 0 ;
12507 2 : PyObject * obj0 = 0 ;
12508 2 : PyObject * obj1 = 0 ;
12509 : gpgme_error_t result;
12510 :
12511 2 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_set_file_name",&obj0,&obj1)) SWIG_fail;
12512 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
12513 2 : if (!SWIG_IsOK(res1)) {
12514 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_set_file_name" "', argument " "1"" of type '" "gpgme_data_t""'");
12515 : }
12516 2 : arg1 = (gpgme_data_t)(argp1);
12517 : {
12518 2 : if (obj1 == Py_None)
12519 : arg2 = NULL;
12520 2 : else if (PyUnicode_Check(obj1))
12521 2 : arg2 = PyUnicode_AsUTF8(obj1);
12522 0 : else if (PyBytes_Check(obj1))
12523 0 : arg2 = PyBytes_AsString(obj1);
12524 : else {
12525 0 : PyErr_Format(PyExc_TypeError,
12526 : "arg %d: expected str, bytes, or None, got %s",
12527 : 2, obj1->ob_type->tp_name);
12528 0 : return NULL;
12529 : }
12530 : }
12531 2 : result = gpgme_data_set_file_name(arg1,(char const *)arg2);
12532 : {
12533 2 : resultobj = PyLong_FromLong(result);
12534 : }
12535 2 : return resultobj;
12536 : fail:
12537 : return NULL;
12538 : }
12539 :
12540 :
12541 0 : SWIGINTERN PyObject *_wrap_gpgme_data_set_flag(PyObject *self, PyObject *args) {
12542 0 : PyObject *resultobj = 0;
12543 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
12544 0 : char *arg2 = (char *) 0 ;
12545 0 : char *arg3 = (char *) 0 ;
12546 0 : void *argp1 = 0 ;
12547 0 : int res1 = 0 ;
12548 0 : PyObject * obj0 = 0 ;
12549 0 : PyObject * obj1 = 0 ;
12550 0 : PyObject * obj2 = 0 ;
12551 : gpg_error_t result;
12552 :
12553 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_set_flag",&obj0,&obj1,&obj2)) SWIG_fail;
12554 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
12555 0 : if (!SWIG_IsOK(res1)) {
12556 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_set_flag" "', argument " "1"" of type '" "gpgme_data_t""'");
12557 : }
12558 0 : arg1 = (gpgme_data_t)(argp1);
12559 : {
12560 0 : if (obj1 == Py_None)
12561 : arg2 = NULL;
12562 0 : else if (PyUnicode_Check(obj1))
12563 0 : arg2 = PyUnicode_AsUTF8(obj1);
12564 0 : else if (PyBytes_Check(obj1))
12565 0 : arg2 = PyBytes_AsString(obj1);
12566 : else {
12567 0 : PyErr_Format(PyExc_TypeError,
12568 : "arg %d: expected str, bytes, or None, got %s",
12569 : 2, obj1->ob_type->tp_name);
12570 0 : return NULL;
12571 : }
12572 : }
12573 : {
12574 0 : if (obj2 == Py_None)
12575 : arg3 = NULL;
12576 0 : else if (PyUnicode_Check(obj2))
12577 0 : arg3 = PyUnicode_AsUTF8(obj2);
12578 0 : else if (PyBytes_Check(obj2))
12579 0 : arg3 = PyBytes_AsString(obj2);
12580 : else {
12581 0 : PyErr_Format(PyExc_TypeError,
12582 : "arg %d: expected str, bytes, or None, got %s",
12583 : 3, obj2->ob_type->tp_name);
12584 0 : return NULL;
12585 : }
12586 : }
12587 0 : result = gpgme_data_set_flag(arg1,(char const *)arg2,(char const *)arg3);
12588 : {
12589 0 : resultobj = PyLong_FromLong(result);
12590 : }
12591 0 : return resultobj;
12592 : fail:
12593 : return NULL;
12594 : }
12595 :
12596 :
12597 0 : SWIGINTERN PyObject *_wrap_gpgme_data_identify(PyObject *self, PyObject *args) {
12598 0 : PyObject *resultobj = 0;
12599 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
12600 : int arg2 ;
12601 0 : void *argp1 = 0 ;
12602 0 : int res1 = 0 ;
12603 : int val2 ;
12604 0 : int ecode2 = 0 ;
12605 0 : PyObject * obj0 = 0 ;
12606 0 : PyObject * obj1 = 0 ;
12607 : gpgme_data_type_t result;
12608 :
12609 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_identify",&obj0,&obj1)) SWIG_fail;
12610 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
12611 0 : if (!SWIG_IsOK(res1)) {
12612 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_identify" "', argument " "1"" of type '" "gpgme_data_t""'");
12613 : }
12614 0 : arg1 = (gpgme_data_t)(argp1);
12615 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12616 0 : if (!SWIG_IsOK(ecode2)) {
12617 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_data_identify" "', argument " "2"" of type '" "int""'");
12618 : }
12619 0 : arg2 = (int)(val2);
12620 0 : result = (gpgme_data_type_t)gpgme_data_identify(arg1,arg2);
12621 0 : resultobj = SWIG_From_int((int)(result));
12622 0 : return resultobj;
12623 : fail:
12624 : return NULL;
12625 : }
12626 :
12627 :
12628 5 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_file(PyObject *self, PyObject *args) {
12629 5 : PyObject *resultobj = 0;
12630 5 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
12631 5 : char *arg2 = (char *) 0 ;
12632 : int arg3 ;
12633 5 : void *argp1 = 0 ;
12634 5 : int res1 = 0 ;
12635 : int val3 ;
12636 5 : int ecode3 = 0 ;
12637 5 : PyObject * obj0 = 0 ;
12638 5 : PyObject * obj1 = 0 ;
12639 5 : PyObject * obj2 = 0 ;
12640 : gpgme_error_t result;
12641 :
12642 5 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_new_from_file",&obj0,&obj1,&obj2)) SWIG_fail;
12643 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
12644 5 : if (!SWIG_IsOK(res1)) {
12645 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_file" "', argument " "1"" of type '" "gpgme_data_t *""'");
12646 : }
12647 5 : arg1 = (gpgme_data_t *)(argp1);
12648 : {
12649 5 : if (obj1 == Py_None)
12650 : arg2 = NULL;
12651 5 : else if (PyUnicode_Check(obj1))
12652 5 : arg2 = PyUnicode_AsUTF8(obj1);
12653 0 : else if (PyBytes_Check(obj1))
12654 0 : arg2 = PyBytes_AsString(obj1);
12655 : else {
12656 0 : PyErr_Format(PyExc_TypeError,
12657 : "arg %d: expected str, bytes, or None, got %s",
12658 : 2, obj1->ob_type->tp_name);
12659 0 : return NULL;
12660 : }
12661 : }
12662 5 : ecode3 = SWIG_AsVal_int(obj2, &val3);
12663 5 : if (!SWIG_IsOK(ecode3)) {
12664 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_data_new_from_file" "', argument " "3"" of type '" "int""'");
12665 : }
12666 5 : arg3 = (int)(val3);
12667 5 : result = gpgme_data_new_from_file(arg1,(char const *)arg2,arg3);
12668 : {
12669 5 : resultobj = PyLong_FromLong(result);
12670 : }
12671 5 : return resultobj;
12672 : fail:
12673 : return NULL;
12674 : }
12675 :
12676 :
12677 2 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_filepart(PyObject *self, PyObject *args) {
12678 2 : PyObject *resultobj = 0;
12679 2 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
12680 2 : char *arg2 = (char *) 0 ;
12681 2 : FILE *arg3 = (FILE *) 0 ;
12682 : off_t arg4 ;
12683 : size_t arg5 ;
12684 2 : void *argp1 = 0 ;
12685 2 : int res1 = 0 ;
12686 2 : void *argp3 = 0 ;
12687 2 : int res3 = 0 ;
12688 : size_t val5 ;
12689 2 : int ecode5 = 0 ;
12690 2 : PyObject * obj0 = 0 ;
12691 2 : PyObject * obj1 = 0 ;
12692 2 : PyObject * obj2 = 0 ;
12693 2 : PyObject * obj3 = 0 ;
12694 2 : PyObject * obj4 = 0 ;
12695 : gpgme_error_t result;
12696 :
12697 2 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_data_new_from_filepart",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12698 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
12699 2 : if (!SWIG_IsOK(res1)) {
12700 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_filepart" "', argument " "1"" of type '" "gpgme_data_t *""'");
12701 : }
12702 2 : arg1 = (gpgme_data_t *)(argp1);
12703 : {
12704 2 : if (obj1 == Py_None)
12705 : arg2 = NULL;
12706 1 : else if (PyUnicode_Check(obj1))
12707 1 : arg2 = PyUnicode_AsUTF8(obj1);
12708 0 : else if (PyBytes_Check(obj1))
12709 0 : arg2 = PyBytes_AsString(obj1);
12710 : else {
12711 0 : PyErr_Format(PyExc_TypeError,
12712 : "arg %d: expected str, bytes, or None, got %s",
12713 : 2, obj1->ob_type->tp_name);
12714 0 : return NULL;
12715 : }
12716 : }
12717 2 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FILE, 0 | 0 );
12718 2 : if (!SWIG_IsOK(res3)) {
12719 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_data_new_from_filepart" "', argument " "3"" of type '" "FILE *""'");
12720 : }
12721 2 : arg3 = (FILE *)(argp3);
12722 : {
12723 2 : arg4 = PyLong_AsLong(obj3);
12724 : }
12725 2 : ecode5 = SWIG_AsVal_size_t(obj4, &val5);
12726 2 : if (!SWIG_IsOK(ecode5)) {
12727 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_data_new_from_filepart" "', argument " "5"" of type '" "size_t""'");
12728 : }
12729 2 : arg5 = (size_t)(val5);
12730 2 : result = gpgme_data_new_from_filepart(arg1,(char const *)arg2,arg3,arg4,arg5);
12731 : {
12732 2 : resultobj = PyLong_FromLong(result);
12733 : }
12734 2 : return resultobj;
12735 : fail:
12736 : return NULL;
12737 : }
12738 :
12739 :
12740 23 : SWIGINTERN PyObject *_wrap_gpgme_get_key(PyObject *self, PyObject *args) {
12741 23 : PyObject *resultobj = 0;
12742 23 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12743 23 : char *arg2 = (char *) 0 ;
12744 23 : gpgme_key_t *arg3 = (gpgme_key_t *) 0 ;
12745 : int arg4 ;
12746 23 : void *argp1 = 0 ;
12747 23 : int res1 = 0 ;
12748 23 : void *argp3 = 0 ;
12749 23 : int res3 = 0 ;
12750 : int val4 ;
12751 23 : int ecode4 = 0 ;
12752 23 : PyObject * obj0 = 0 ;
12753 23 : PyObject * obj1 = 0 ;
12754 23 : PyObject * obj2 = 0 ;
12755 23 : PyObject * obj3 = 0 ;
12756 : gpgme_error_t result;
12757 :
12758 23 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_get_key",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12759 23 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12760 23 : if (!SWIG_IsOK(res1)) {
12761 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_key" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12762 : }
12763 23 : arg1 = (gpgme_ctx_t)(argp1);
12764 : {
12765 23 : if (obj1 == Py_None)
12766 : arg2 = NULL;
12767 23 : else if (PyUnicode_Check(obj1))
12768 23 : arg2 = PyUnicode_AsUTF8(obj1);
12769 0 : else if (PyBytes_Check(obj1))
12770 0 : arg2 = PyBytes_AsString(obj1);
12771 : else {
12772 0 : PyErr_Format(PyExc_TypeError,
12773 : "arg %d: expected str, bytes, or None, got %s",
12774 : 2, obj1->ob_type->tp_name);
12775 0 : return NULL;
12776 : }
12777 : }
12778 23 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
12779 23 : if (!SWIG_IsOK(res3)) {
12780 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_key" "', argument " "3"" of type '" "gpgme_key_t *""'");
12781 : }
12782 23 : arg3 = (gpgme_key_t *)(argp3);
12783 23 : ecode4 = SWIG_AsVal_int(obj3, &val4);
12784 23 : if (!SWIG_IsOK(ecode4)) {
12785 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_get_key" "', argument " "4"" of type '" "int""'");
12786 : }
12787 23 : arg4 = (int)(val4);
12788 23 : result = gpgme_get_key(arg1,(char const *)arg2,arg3,arg4);
12789 : {
12790 23 : resultobj = PyLong_FromLong(result);
12791 : }
12792 23 : return resultobj;
12793 : fail:
12794 : return NULL;
12795 : }
12796 :
12797 :
12798 0 : SWIGINTERN PyObject *_wrap_gpgme_key_from_uid(PyObject *self, PyObject *args) {
12799 0 : PyObject *resultobj = 0;
12800 0 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
12801 0 : char *arg2 = (char *) 0 ;
12802 0 : void *argp1 = 0 ;
12803 0 : int res1 = 0 ;
12804 0 : PyObject * obj0 = 0 ;
12805 0 : PyObject * obj1 = 0 ;
12806 : gpgme_error_t result;
12807 :
12808 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_key_from_uid",&obj0,&obj1)) SWIG_fail;
12809 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
12810 0 : if (!SWIG_IsOK(res1)) {
12811 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_from_uid" "', argument " "1"" of type '" "gpgme_key_t *""'");
12812 : }
12813 0 : arg1 = (gpgme_key_t *)(argp1);
12814 : {
12815 0 : if (obj1 == Py_None)
12816 : arg2 = NULL;
12817 0 : else if (PyUnicode_Check(obj1))
12818 0 : arg2 = PyUnicode_AsUTF8(obj1);
12819 0 : else if (PyBytes_Check(obj1))
12820 0 : arg2 = PyBytes_AsString(obj1);
12821 : else {
12822 0 : PyErr_Format(PyExc_TypeError,
12823 : "arg %d: expected str, bytes, or None, got %s",
12824 : 2, obj1->ob_type->tp_name);
12825 0 : return NULL;
12826 : }
12827 : }
12828 0 : result = gpgme_key_from_uid(arg1,(char const *)arg2);
12829 : {
12830 0 : resultobj = PyLong_FromLong(result);
12831 : }
12832 0 : return resultobj;
12833 : fail:
12834 : return NULL;
12835 : }
12836 :
12837 :
12838 0 : SWIGINTERN PyObject *_wrap_gpgme_key_ref(PyObject *self, PyObject *args) {
12839 0 : PyObject *resultobj = 0;
12840 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
12841 0 : void *argp1 = 0 ;
12842 0 : int res1 = 0 ;
12843 0 : PyObject * obj0 = 0 ;
12844 :
12845 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_ref",&obj0)) SWIG_fail;
12846 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
12847 0 : if (!SWIG_IsOK(res1)) {
12848 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_ref" "', argument " "1"" of type '" "gpgme_key_t""'");
12849 : }
12850 0 : arg1 = (gpgme_key_t)(argp1);
12851 0 : gpgme_key_ref(arg1);
12852 0 : resultobj = SWIG_Py_Void();
12853 0 : return resultobj;
12854 : fail:
12855 : return NULL;
12856 : }
12857 :
12858 :
12859 0 : SWIGINTERN PyObject *_wrap_gpgme_key_unref(PyObject *self, PyObject *args) {
12860 0 : PyObject *resultobj = 0;
12861 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
12862 0 : void *argp1 = 0 ;
12863 0 : int res1 = 0 ;
12864 0 : PyObject * obj0 = 0 ;
12865 :
12866 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_unref",&obj0)) SWIG_fail;
12867 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
12868 0 : if (!SWIG_IsOK(res1)) {
12869 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_unref" "', argument " "1"" of type '" "gpgme_key_t""'");
12870 : }
12871 0 : arg1 = (gpgme_key_t)(argp1);
12872 0 : gpgme_key_unref(arg1);
12873 0 : resultobj = SWIG_Py_Void();
12874 0 : return resultobj;
12875 : fail:
12876 : return NULL;
12877 : }
12878 :
12879 :
12880 0 : SWIGINTERN PyObject *_wrap_gpgme_key_release(PyObject *self, PyObject *args) {
12881 0 : PyObject *resultobj = 0;
12882 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
12883 0 : void *argp1 = 0 ;
12884 0 : int res1 = 0 ;
12885 0 : PyObject * obj0 = 0 ;
12886 :
12887 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_release",&obj0)) SWIG_fail;
12888 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
12889 0 : if (!SWIG_IsOK(res1)) {
12890 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_release" "', argument " "1"" of type '" "gpgme_key_t""'");
12891 : }
12892 0 : arg1 = (gpgme_key_t)(argp1);
12893 0 : gpgme_key_release(arg1);
12894 0 : resultobj = SWIG_Py_Void();
12895 0 : return resultobj;
12896 : fail:
12897 : return NULL;
12898 : }
12899 :
12900 :
12901 0 : SWIGINTERN PyObject *_wrap__gpgme_op_encrypt_result_invalid_recipients_set(PyObject *self, PyObject *args) {
12902 0 : PyObject *resultobj = 0;
12903 0 : struct _gpgme_op_encrypt_result *arg1 = (struct _gpgme_op_encrypt_result *) 0 ;
12904 0 : gpgme_invalid_key_t arg2 = (gpgme_invalid_key_t) 0 ;
12905 0 : void *argp1 = 0 ;
12906 0 : int res1 = 0 ;
12907 0 : void *argp2 = 0 ;
12908 0 : int res2 = 0 ;
12909 0 : PyObject * obj1 = 0 ;
12910 :
12911 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_encrypt_result_invalid_recipients_set",&obj1)) SWIG_fail;
12912 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_encrypt_result, 0 | 0 );
12913 0 : if (!SWIG_IsOK(res1)) {
12914 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_encrypt_result_invalid_recipients_set" "', argument " "1"" of type '" "struct _gpgme_op_encrypt_result *""'");
12915 : }
12916 0 : arg1 = (struct _gpgme_op_encrypt_result *)(argp1);
12917 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_invalid_key, SWIG_POINTER_DISOWN | 0 );
12918 0 : if (!SWIG_IsOK(res2)) {
12919 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_encrypt_result_invalid_recipients_set" "', argument " "2"" of type '" "gpgme_invalid_key_t""'");
12920 : }
12921 0 : arg2 = (gpgme_invalid_key_t)(argp2);
12922 0 : if (arg1) (arg1)->invalid_recipients = arg2;
12923 0 : resultobj = SWIG_Py_Void();
12924 0 : return resultobj;
12925 : fail:
12926 : return NULL;
12927 : }
12928 :
12929 :
12930 22 : SWIGINTERN PyObject *_wrap__gpgme_op_encrypt_result_invalid_recipients_get(PyObject *self, PyObject *args) {
12931 22 : PyObject *resultobj = 0;
12932 22 : struct _gpgme_op_encrypt_result *arg1 = (struct _gpgme_op_encrypt_result *) 0 ;
12933 22 : void *argp1 = 0 ;
12934 22 : int res1 = 0 ;
12935 : gpgme_invalid_key_t result;
12936 :
12937 22 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
12938 22 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_encrypt_result, 0 | 0 );
12939 22 : if (!SWIG_IsOK(res1)) {
12940 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_encrypt_result_invalid_recipients_get" "', argument " "1"" of type '" "struct _gpgme_op_encrypt_result *""'");
12941 : }
12942 22 : arg1 = (struct _gpgme_op_encrypt_result *)(argp1);
12943 22 : result = (gpgme_invalid_key_t) ((arg1)->invalid_recipients);
12944 : {
12945 : int i;
12946 22 : int size = 0;
12947 : gpgme_invalid_key_t curr;
12948 24 : for (curr = result; curr != NULL; curr = curr->next) {
12949 2 : size++;
12950 : }
12951 22 : resultobj = PyList_New(size);
12952 24 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
12953 2 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_invalid_key, 0 );
12954 2 : PyList_SetItem(resultobj, i, o);
12955 : }
12956 : }
12957 : return resultobj;
12958 : fail:
12959 : return NULL;
12960 : }
12961 :
12962 :
12963 0 : SWIGINTERN int _wrap_new__gpgme_op_encrypt_result(PyObject *self, PyObject *args) {
12964 0 : PyObject *resultobj = 0;
12965 0 : struct _gpgme_op_encrypt_result *result = 0 ;
12966 :
12967 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
12968 0 : result = (struct _gpgme_op_encrypt_result *)calloc(1, sizeof(struct _gpgme_op_encrypt_result));
12969 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_encrypt_result, SWIG_BUILTIN_INIT | 0 );
12970 0 : return resultobj == Py_None ? -1 : 0;
12971 : fail:
12972 : return -1;
12973 : }
12974 :
12975 :
12976 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_encrypt_result(PyObject *self, PyObject *args) {
12977 0 : PyObject *resultobj = 0;
12978 0 : struct _gpgme_op_encrypt_result *arg1 = (struct _gpgme_op_encrypt_result *) 0 ;
12979 0 : void *argp1 = 0 ;
12980 0 : int res1 = 0 ;
12981 :
12982 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
12983 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_encrypt_result, SWIG_POINTER_DISOWN | 0 );
12984 0 : if (!SWIG_IsOK(res1)) {
12985 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_encrypt_result" "', argument " "1"" of type '" "struct _gpgme_op_encrypt_result *""'");
12986 : }
12987 0 : arg1 = (struct _gpgme_op_encrypt_result *)(argp1);
12988 0 : free((char *) arg1);
12989 0 : resultobj = SWIG_Py_Void();
12990 0 : return resultobj;
12991 : fail:
12992 : return NULL;
12993 : }
12994 :
12995 :
12996 11 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_result(PyObject *self, PyObject *args) {
12997 11 : PyObject *resultobj = 0;
12998 11 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12999 11 : void *argp1 = 0 ;
13000 11 : int res1 = 0 ;
13001 11 : PyObject * obj0 = 0 ;
13002 : gpgme_encrypt_result_t result;
13003 :
13004 11 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_encrypt_result",&obj0)) SWIG_fail;
13005 11 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13006 11 : if (!SWIG_IsOK(res1)) {
13007 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13008 : }
13009 11 : arg1 = (gpgme_ctx_t)(argp1);
13010 11 : result = (gpgme_encrypt_result_t)gpgme_op_encrypt_result(arg1);
13011 : {
13012 : PyObject *fragile;
13013 11 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_encrypt_result,
13014 : 0 );
13015 11 : resultobj = _pyme_wrap_result(fragile, "EncryptResult");
13016 11 : Py_DECREF(fragile);
13017 : }
13018 11 : return resultobj;
13019 : fail:
13020 : return NULL;
13021 : }
13022 :
13023 :
13024 0 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_start(PyObject *self, PyObject *args) {
13025 0 : PyObject *resultobj = 0;
13026 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13027 : gpgme_key_t *arg2 ;
13028 : gpgme_encrypt_flags_t arg3 ;
13029 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
13030 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
13031 0 : void *argp1 = 0 ;
13032 0 : int res1 = 0 ;
13033 : int val3 ;
13034 0 : int ecode3 = 0 ;
13035 0 : gpgme_data_t wrapper4 = NULL ;
13036 0 : PyObject *bytesio4 = NULL ;
13037 : Py_buffer view4 ;
13038 0 : int have_view4 = 0 ;
13039 0 : gpgme_data_t wrapper5 = NULL ;
13040 0 : PyObject *bytesio5 = NULL ;
13041 : Py_buffer view5 ;
13042 0 : int have_view5 = 0 ;
13043 0 : PyObject * obj0 = 0 ;
13044 0 : PyObject * obj1 = 0 ;
13045 0 : PyObject * obj2 = 0 ;
13046 0 : PyObject * obj3 = 0 ;
13047 0 : PyObject * obj4 = 0 ;
13048 : gpgme_error_t result;
13049 :
13050 : {
13051 0 : arg2 = NULL;
13052 : }
13053 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13054 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13055 0 : if (!SWIG_IsOK(res1)) {
13056 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13057 : }
13058 0 : arg1 = (gpgme_ctx_t)(argp1);
13059 : {
13060 0 : int i, numb = 0;
13061 0 : if (!PySequence_Check(obj1)) {
13062 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
13063 : 2);
13064 0 : return NULL;
13065 : }
13066 0 : if((numb = PySequence_Length(obj1)) != 0) {
13067 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
13068 0 : for(i=0; i<numb; i++) {
13069 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
13070 :
13071 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
13072 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
13073 :
13074 : // Following code is from swig's python.swg
13075 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
13076 0 : Py_DECREF(pypointer);
13077 : return NULL;
13078 : }
13079 0 : Py_DECREF(pypointer);
13080 : }
13081 0 : arg2[numb] = NULL;
13082 : }
13083 : }
13084 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
13085 0 : if (!SWIG_IsOK(ecode3)) {
13086 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt_start" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
13087 : }
13088 0 : arg3 = (gpgme_encrypt_flags_t)(val3);
13089 : {
13090 : /* If we create a temporary wrapper4 object, we will store it in
13091 : wrapperN, where N is 4. Here in this fragment, SWIG will
13092 : automatically append 4. */
13093 : memset(&view4, 0, sizeof view4);
13094 0 : if (obj3 == Py_None)
13095 0 : arg4 = NULL;
13096 : else {
13097 : PyObject *pypointer;
13098 0 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
13099 : &bytesio4, &view4);
13100 0 : if (pypointer == NULL)
13101 : return NULL;
13102 0 : have_view4 = !! view4.obj;
13103 :
13104 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
13105 :
13106 : // Following code is from swig's python.swg
13107 :
13108 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
13109 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
13110 0 : Py_DECREF(pypointer);
13111 : return NULL;
13112 : }
13113 0 : Py_DECREF(pypointer);
13114 : }
13115 : }
13116 : {
13117 : /* If we create a temporary wrapper5 object, we will store it in
13118 : wrapperN, where N is 5. Here in this fragment, SWIG will
13119 : automatically append 5. */
13120 : memset(&view5, 0, sizeof view5);
13121 0 : if (obj4 == Py_None)
13122 0 : arg5 = NULL;
13123 : else {
13124 : PyObject *pypointer;
13125 0 : pypointer = _pyme_obj2gpgme_data_t(obj4, 5, &wrapper5,
13126 : &bytesio5, &view5);
13127 0 : if (pypointer == NULL)
13128 : return NULL;
13129 0 : have_view5 = !! view5.obj;
13130 :
13131 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
13132 :
13133 : // Following code is from swig's python.swg
13134 :
13135 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
13136 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
13137 0 : Py_DECREF(pypointer);
13138 : return NULL;
13139 : }
13140 0 : Py_DECREF(pypointer);
13141 : }
13142 : }
13143 0 : result = gpgme_op_encrypt_start(arg1,arg2,arg3,arg4,arg5);
13144 : {
13145 0 : resultobj = PyLong_FromLong(result);
13146 : }
13147 : {
13148 0 : if (arg2) free(arg2);
13149 : }
13150 : {
13151 : /* See whether we need to update the Python buffer. */
13152 0 : if (resultobj && wrapper4 && view4.buf)
13153 : {
13154 : int dirty;
13155 0 : char *new_data = NULL;
13156 : size_t new_size;
13157 :
13158 :
13159 0 : new_data = wrapper4->data.mem.buffer;
13160 0 : new_size = wrapper4->data.mem.length;
13161 0 : dirty = new_data != NULL;
13162 :
13163 :
13164 :
13165 :
13166 :
13167 :
13168 :
13169 0 : if (dirty)
13170 : {
13171 : /* The buffer is dirty. */
13172 0 : if (view4.readonly)
13173 : {
13174 0 : Py_XDECREF(resultobj);
13175 0 : resultobj = NULL;
13176 0 : PyErr_SetString(PyExc_ValueError,
13177 : "cannot update read-only buffer");
13178 : }
13179 :
13180 : /* See if we need to truncate the buffer. */
13181 0 : if (resultobj && view4.len != new_size)
13182 : {
13183 0 : if (bytesio4 == NULL)
13184 : {
13185 0 : Py_XDECREF(resultobj);
13186 0 : resultobj = NULL;
13187 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
13188 : }
13189 : else
13190 : {
13191 : PyObject *retval;
13192 0 : PyBuffer_Release(&view4);
13193 : assert(view4.obj == NULL);
13194 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
13195 : "l", (long) new_size);
13196 0 : if (retval == NULL)
13197 : {
13198 0 : Py_XDECREF(resultobj);
13199 : resultobj = NULL;
13200 : }
13201 : else
13202 : {
13203 0 : Py_DECREF(retval);
13204 :
13205 0 : retval = PyObject_CallMethod(bytesio4,
13206 : "getbuffer", NULL);
13207 0 : if (retval == NULL
13208 0 : || PyObject_GetBuffer(retval, &view4,
13209 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
13210 : {
13211 0 : Py_XDECREF(resultobj);
13212 : resultobj = NULL;
13213 : }
13214 :
13215 0 : Py_XDECREF(retval);
13216 :
13217 0 : if (resultobj && view4.len
13218 0 : != new_size)
13219 : {
13220 0 : Py_XDECREF(resultobj);
13221 0 : resultobj = NULL;
13222 0 : PyErr_Format(PyExc_ValueError,
13223 : "Expected buffer of length %zu, got %zi",
13224 : new_size,
13225 : view4.len);
13226 : }
13227 : }
13228 : }
13229 : }
13230 0 : if (resultobj)
13231 0 : memcpy(view4.buf, new_data, new_size);
13232 : }
13233 :
13234 :
13235 :
13236 : }
13237 :
13238 : /* Free the temporary wrapper, if any. */
13239 0 : if (wrapper4)
13240 0 : gpgme_data_release(wrapper4);
13241 0 : Py_XDECREF (bytesio4);
13242 0 : if (have_view4 && view4.buf)
13243 0 : PyBuffer_Release(&view4);
13244 : }
13245 : {
13246 : /* See whether we need to update the Python buffer. */
13247 0 : if (resultobj && wrapper5 && view5.buf)
13248 : {
13249 : int dirty;
13250 0 : char *new_data = NULL;
13251 : size_t new_size;
13252 :
13253 :
13254 0 : new_data = wrapper5->data.mem.buffer;
13255 0 : new_size = wrapper5->data.mem.length;
13256 0 : dirty = new_data != NULL;
13257 :
13258 :
13259 :
13260 :
13261 :
13262 :
13263 :
13264 0 : if (dirty)
13265 : {
13266 : /* The buffer is dirty. */
13267 0 : if (view5.readonly)
13268 : {
13269 0 : Py_XDECREF(resultobj);
13270 0 : resultobj = NULL;
13271 0 : PyErr_SetString(PyExc_ValueError,
13272 : "cannot update read-only buffer");
13273 : }
13274 :
13275 : /* See if we need to truncate the buffer. */
13276 0 : if (resultobj && view5.len != new_size)
13277 : {
13278 0 : if (bytesio5 == NULL)
13279 : {
13280 0 : Py_XDECREF(resultobj);
13281 0 : resultobj = NULL;
13282 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
13283 : }
13284 : else
13285 : {
13286 : PyObject *retval;
13287 0 : PyBuffer_Release(&view5);
13288 : assert(view5.obj == NULL);
13289 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
13290 : "l", (long) new_size);
13291 0 : if (retval == NULL)
13292 : {
13293 0 : Py_XDECREF(resultobj);
13294 : resultobj = NULL;
13295 : }
13296 : else
13297 : {
13298 0 : Py_DECREF(retval);
13299 :
13300 0 : retval = PyObject_CallMethod(bytesio5,
13301 : "getbuffer", NULL);
13302 0 : if (retval == NULL
13303 0 : || PyObject_GetBuffer(retval, &view5,
13304 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
13305 : {
13306 0 : Py_XDECREF(resultobj);
13307 : resultobj = NULL;
13308 : }
13309 :
13310 0 : Py_XDECREF(retval);
13311 :
13312 0 : if (resultobj && view5.len
13313 0 : != new_size)
13314 : {
13315 0 : Py_XDECREF(resultobj);
13316 0 : resultobj = NULL;
13317 0 : PyErr_Format(PyExc_ValueError,
13318 : "Expected buffer of length %zu, got %zi",
13319 : new_size,
13320 : view5.len);
13321 : }
13322 : }
13323 : }
13324 : }
13325 0 : if (resultobj)
13326 0 : memcpy(view5.buf, new_data, new_size);
13327 : }
13328 :
13329 :
13330 :
13331 : }
13332 :
13333 : /* Free the temporary wrapper, if any. */
13334 0 : if (wrapper5)
13335 0 : gpgme_data_release(wrapper5);
13336 0 : Py_XDECREF (bytesio5);
13337 0 : if (have_view5 && view5.buf)
13338 0 : PyBuffer_Release(&view5);
13339 : }
13340 0 : return resultobj;
13341 : fail:
13342 : {
13343 0 : if (arg2) free(arg2);
13344 : }
13345 : {
13346 : /* See whether we need to update the Python buffer. */
13347 : if (resultobj && wrapper4 && view4.buf)
13348 : {
13349 : int dirty;
13350 : char *new_data = NULL;
13351 : size_t new_size;
13352 :
13353 :
13354 : new_data = wrapper4->data.mem.buffer;
13355 : new_size = wrapper4->data.mem.length;
13356 : dirty = new_data != NULL;
13357 :
13358 :
13359 :
13360 :
13361 :
13362 :
13363 :
13364 : if (dirty)
13365 : {
13366 : /* The buffer is dirty. */
13367 : if (view4.readonly)
13368 : {
13369 : Py_XDECREF(resultobj);
13370 : resultobj = NULL;
13371 : PyErr_SetString(PyExc_ValueError,
13372 : "cannot update read-only buffer");
13373 : }
13374 :
13375 : /* See if we need to truncate the buffer. */
13376 : if (resultobj && view4.len != new_size)
13377 : {
13378 : if (bytesio4 == NULL)
13379 : {
13380 : Py_XDECREF(resultobj);
13381 : resultobj = NULL;
13382 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
13383 : }
13384 : else
13385 : {
13386 : PyObject *retval;
13387 : PyBuffer_Release(&view4);
13388 : assert(view4.obj == NULL);
13389 : retval = PyObject_CallMethod(bytesio4, "truncate",
13390 : "l", (long) new_size);
13391 : if (retval == NULL)
13392 : {
13393 : Py_XDECREF(resultobj);
13394 : resultobj = NULL;
13395 : }
13396 : else
13397 : {
13398 : Py_DECREF(retval);
13399 :
13400 : retval = PyObject_CallMethod(bytesio4,
13401 : "getbuffer", NULL);
13402 : if (retval == NULL
13403 : || PyObject_GetBuffer(retval, &view4,
13404 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
13405 : {
13406 : Py_XDECREF(resultobj);
13407 : resultobj = NULL;
13408 : }
13409 :
13410 : Py_XDECREF(retval);
13411 :
13412 : if (resultobj && view4.len
13413 : != new_size)
13414 : {
13415 : Py_XDECREF(resultobj);
13416 : resultobj = NULL;
13417 : PyErr_Format(PyExc_ValueError,
13418 : "Expected buffer of length %zu, got %zi",
13419 : new_size,
13420 : view4.len);
13421 : }
13422 : }
13423 : }
13424 : }
13425 : if (resultobj)
13426 : memcpy(view4.buf, new_data, new_size);
13427 : }
13428 :
13429 :
13430 :
13431 : }
13432 :
13433 : /* Free the temporary wrapper, if any. */
13434 0 : if (wrapper4)
13435 0 : gpgme_data_release(wrapper4);
13436 0 : Py_XDECREF (bytesio4);
13437 : if (have_view4 && view4.buf)
13438 : PyBuffer_Release(&view4);
13439 : }
13440 : {
13441 : /* See whether we need to update the Python buffer. */
13442 : if (resultobj && wrapper5 && view5.buf)
13443 : {
13444 : int dirty;
13445 : char *new_data = NULL;
13446 : size_t new_size;
13447 :
13448 :
13449 : new_data = wrapper5->data.mem.buffer;
13450 : new_size = wrapper5->data.mem.length;
13451 : dirty = new_data != NULL;
13452 :
13453 :
13454 :
13455 :
13456 :
13457 :
13458 :
13459 : if (dirty)
13460 : {
13461 : /* The buffer is dirty. */
13462 : if (view5.readonly)
13463 : {
13464 : Py_XDECREF(resultobj);
13465 : resultobj = NULL;
13466 : PyErr_SetString(PyExc_ValueError,
13467 : "cannot update read-only buffer");
13468 : }
13469 :
13470 : /* See if we need to truncate the buffer. */
13471 : if (resultobj && view5.len != new_size)
13472 : {
13473 : if (bytesio5 == NULL)
13474 : {
13475 : Py_XDECREF(resultobj);
13476 : resultobj = NULL;
13477 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
13478 : }
13479 : else
13480 : {
13481 : PyObject *retval;
13482 : PyBuffer_Release(&view5);
13483 : assert(view5.obj == NULL);
13484 : retval = PyObject_CallMethod(bytesio5, "truncate",
13485 : "l", (long) new_size);
13486 : if (retval == NULL)
13487 : {
13488 : Py_XDECREF(resultobj);
13489 : resultobj = NULL;
13490 : }
13491 : else
13492 : {
13493 : Py_DECREF(retval);
13494 :
13495 : retval = PyObject_CallMethod(bytesio5,
13496 : "getbuffer", NULL);
13497 : if (retval == NULL
13498 : || PyObject_GetBuffer(retval, &view5,
13499 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
13500 : {
13501 : Py_XDECREF(resultobj);
13502 : resultobj = NULL;
13503 : }
13504 :
13505 : Py_XDECREF(retval);
13506 :
13507 : if (resultobj && view5.len
13508 : != new_size)
13509 : {
13510 : Py_XDECREF(resultobj);
13511 : resultobj = NULL;
13512 : PyErr_Format(PyExc_ValueError,
13513 : "Expected buffer of length %zu, got %zi",
13514 : new_size,
13515 : view5.len);
13516 : }
13517 : }
13518 : }
13519 : }
13520 : if (resultobj)
13521 : memcpy(view5.buf, new_data, new_size);
13522 : }
13523 :
13524 :
13525 :
13526 : }
13527 :
13528 : /* Free the temporary wrapper, if any. */
13529 0 : if (wrapper5)
13530 0 : gpgme_data_release(wrapper5);
13531 0 : Py_XDECREF (bytesio5);
13532 : if (have_view5 && view5.buf)
13533 : PyBuffer_Release(&view5);
13534 : }
13535 : return NULL;
13536 : }
13537 :
13538 :
13539 17 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt(PyObject *self, PyObject *args) {
13540 17 : PyObject *resultobj = 0;
13541 17 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13542 : gpgme_key_t *arg2 ;
13543 : gpgme_encrypt_flags_t arg3 ;
13544 17 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
13545 17 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
13546 17 : void *argp1 = 0 ;
13547 17 : int res1 = 0 ;
13548 : int val3 ;
13549 17 : int ecode3 = 0 ;
13550 17 : gpgme_data_t wrapper4 = NULL ;
13551 17 : PyObject *bytesio4 = NULL ;
13552 : Py_buffer view4 ;
13553 17 : int have_view4 = 0 ;
13554 17 : gpgme_data_t wrapper5 = NULL ;
13555 17 : PyObject *bytesio5 = NULL ;
13556 : Py_buffer view5 ;
13557 17 : int have_view5 = 0 ;
13558 17 : PyObject * obj0 = 0 ;
13559 17 : PyObject * obj1 = 0 ;
13560 17 : PyObject * obj2 = 0 ;
13561 17 : PyObject * obj3 = 0 ;
13562 17 : PyObject * obj4 = 0 ;
13563 : gpgme_error_t result;
13564 :
13565 : {
13566 17 : arg2 = NULL;
13567 : }
13568 17 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13569 17 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13570 17 : if (!SWIG_IsOK(res1)) {
13571 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13572 : }
13573 17 : arg1 = (gpgme_ctx_t)(argp1);
13574 : {
13575 17 : int i, numb = 0;
13576 17 : if (!PySequence_Check(obj1)) {
13577 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
13578 : 2);
13579 0 : return NULL;
13580 : }
13581 17 : if((numb = PySequence_Length(obj1)) != 0) {
13582 8 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
13583 19 : for(i=0; i<numb; i++) {
13584 11 : PyObject *pypointer = PySequence_GetItem(obj1, i);
13585 :
13586 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
13587 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
13588 :
13589 : // Following code is from swig's python.swg
13590 11 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
13591 0 : Py_DECREF(pypointer);
13592 : return NULL;
13593 : }
13594 11 : Py_DECREF(pypointer);
13595 : }
13596 8 : arg2[numb] = NULL;
13597 : }
13598 : }
13599 17 : ecode3 = SWIG_AsVal_int(obj2, &val3);
13600 17 : if (!SWIG_IsOK(ecode3)) {
13601 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
13602 : }
13603 17 : arg3 = (gpgme_encrypt_flags_t)(val3);
13604 : {
13605 : /* If we create a temporary wrapper4 object, we will store it in
13606 : wrapperN, where N is 4. Here in this fragment, SWIG will
13607 : automatically append 4. */
13608 : memset(&view4, 0, sizeof view4);
13609 17 : if (obj3 == Py_None)
13610 0 : arg4 = NULL;
13611 : else {
13612 : PyObject *pypointer;
13613 17 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
13614 : &bytesio4, &view4);
13615 17 : if (pypointer == NULL)
13616 : return NULL;
13617 17 : have_view4 = !! view4.obj;
13618 :
13619 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
13620 :
13621 : // Following code is from swig's python.swg
13622 :
13623 17 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
13624 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
13625 0 : Py_DECREF(pypointer);
13626 : return NULL;
13627 : }
13628 17 : Py_DECREF(pypointer);
13629 : }
13630 : }
13631 : {
13632 : /* If we create a temporary wrapper5 object, we will store it in
13633 : wrapperN, where N is 5. Here in this fragment, SWIG will
13634 : automatically append 5. */
13635 : memset(&view5, 0, sizeof view5);
13636 17 : if (obj4 == Py_None)
13637 0 : arg5 = NULL;
13638 : else {
13639 : PyObject *pypointer;
13640 17 : pypointer = _pyme_obj2gpgme_data_t(obj4, 5, &wrapper5,
13641 : &bytesio5, &view5);
13642 17 : if (pypointer == NULL)
13643 : return NULL;
13644 17 : have_view5 = !! view5.obj;
13645 :
13646 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
13647 :
13648 : // Following code is from swig's python.swg
13649 :
13650 17 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
13651 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
13652 0 : Py_DECREF(pypointer);
13653 : return NULL;
13654 : }
13655 17 : Py_DECREF(pypointer);
13656 : }
13657 : }
13658 17 : result = gpgme_op_encrypt(arg1,arg2,arg3,arg4,arg5);
13659 : {
13660 17 : resultobj = PyLong_FromLong(result);
13661 : }
13662 : {
13663 17 : if (arg2) free(arg2);
13664 : }
13665 : {
13666 : /* See whether we need to update the Python buffer. */
13667 17 : if (resultobj && wrapper4 && view4.buf)
13668 : {
13669 : int dirty;
13670 5 : char *new_data = NULL;
13671 : size_t new_size;
13672 :
13673 :
13674 5 : new_data = wrapper4->data.mem.buffer;
13675 5 : new_size = wrapper4->data.mem.length;
13676 5 : dirty = new_data != NULL;
13677 :
13678 :
13679 :
13680 :
13681 :
13682 :
13683 :
13684 5 : if (dirty)
13685 : {
13686 : /* The buffer is dirty. */
13687 0 : if (view4.readonly)
13688 : {
13689 0 : Py_XDECREF(resultobj);
13690 0 : resultobj = NULL;
13691 0 : PyErr_SetString(PyExc_ValueError,
13692 : "cannot update read-only buffer");
13693 : }
13694 :
13695 : /* See if we need to truncate the buffer. */
13696 0 : if (resultobj && view4.len != new_size)
13697 : {
13698 0 : if (bytesio4 == NULL)
13699 : {
13700 0 : Py_XDECREF(resultobj);
13701 0 : resultobj = NULL;
13702 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
13703 : }
13704 : else
13705 : {
13706 : PyObject *retval;
13707 0 : PyBuffer_Release(&view4);
13708 : assert(view4.obj == NULL);
13709 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
13710 : "l", (long) new_size);
13711 0 : if (retval == NULL)
13712 : {
13713 0 : Py_XDECREF(resultobj);
13714 : resultobj = NULL;
13715 : }
13716 : else
13717 : {
13718 0 : Py_DECREF(retval);
13719 :
13720 0 : retval = PyObject_CallMethod(bytesio4,
13721 : "getbuffer", NULL);
13722 0 : if (retval == NULL
13723 0 : || PyObject_GetBuffer(retval, &view4,
13724 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
13725 : {
13726 0 : Py_XDECREF(resultobj);
13727 : resultobj = NULL;
13728 : }
13729 :
13730 0 : Py_XDECREF(retval);
13731 :
13732 0 : if (resultobj && view4.len
13733 0 : != new_size)
13734 : {
13735 0 : Py_XDECREF(resultobj);
13736 0 : resultobj = NULL;
13737 0 : PyErr_Format(PyExc_ValueError,
13738 : "Expected buffer of length %zu, got %zi",
13739 : new_size,
13740 : view4.len);
13741 : }
13742 : }
13743 : }
13744 : }
13745 0 : if (resultobj)
13746 0 : memcpy(view4.buf, new_data, new_size);
13747 : }
13748 :
13749 :
13750 :
13751 : }
13752 :
13753 : /* Free the temporary wrapper, if any. */
13754 17 : if (wrapper4)
13755 5 : gpgme_data_release(wrapper4);
13756 17 : Py_XDECREF (bytesio4);
13757 17 : if (have_view4 && view4.buf)
13758 5 : PyBuffer_Release(&view4);
13759 : }
13760 : {
13761 : /* See whether we need to update the Python buffer. */
13762 17 : if (resultobj && wrapper5 && view5.buf)
13763 : {
13764 : int dirty;
13765 0 : char *new_data = NULL;
13766 : size_t new_size;
13767 :
13768 :
13769 0 : new_data = wrapper5->data.mem.buffer;
13770 0 : new_size = wrapper5->data.mem.length;
13771 0 : dirty = new_data != NULL;
13772 :
13773 :
13774 :
13775 :
13776 :
13777 :
13778 :
13779 0 : if (dirty)
13780 : {
13781 : /* The buffer is dirty. */
13782 0 : if (view5.readonly)
13783 : {
13784 0 : Py_XDECREF(resultobj);
13785 0 : resultobj = NULL;
13786 0 : PyErr_SetString(PyExc_ValueError,
13787 : "cannot update read-only buffer");
13788 : }
13789 :
13790 : /* See if we need to truncate the buffer. */
13791 0 : if (resultobj && view5.len != new_size)
13792 : {
13793 0 : if (bytesio5 == NULL)
13794 : {
13795 0 : Py_XDECREF(resultobj);
13796 0 : resultobj = NULL;
13797 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
13798 : }
13799 : else
13800 : {
13801 : PyObject *retval;
13802 0 : PyBuffer_Release(&view5);
13803 : assert(view5.obj == NULL);
13804 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
13805 : "l", (long) new_size);
13806 0 : if (retval == NULL)
13807 : {
13808 0 : Py_XDECREF(resultobj);
13809 : resultobj = NULL;
13810 : }
13811 : else
13812 : {
13813 0 : Py_DECREF(retval);
13814 :
13815 0 : retval = PyObject_CallMethod(bytesio5,
13816 : "getbuffer", NULL);
13817 0 : if (retval == NULL
13818 0 : || PyObject_GetBuffer(retval, &view5,
13819 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
13820 : {
13821 0 : Py_XDECREF(resultobj);
13822 : resultobj = NULL;
13823 : }
13824 :
13825 0 : Py_XDECREF(retval);
13826 :
13827 0 : if (resultobj && view5.len
13828 0 : != new_size)
13829 : {
13830 0 : Py_XDECREF(resultobj);
13831 0 : resultobj = NULL;
13832 0 : PyErr_Format(PyExc_ValueError,
13833 : "Expected buffer of length %zu, got %zi",
13834 : new_size,
13835 : view5.len);
13836 : }
13837 : }
13838 : }
13839 : }
13840 0 : if (resultobj)
13841 0 : memcpy(view5.buf, new_data, new_size);
13842 : }
13843 :
13844 :
13845 :
13846 : }
13847 :
13848 : /* Free the temporary wrapper, if any. */
13849 17 : if (wrapper5)
13850 0 : gpgme_data_release(wrapper5);
13851 17 : Py_XDECREF (bytesio5);
13852 17 : if (have_view5 && view5.buf)
13853 0 : PyBuffer_Release(&view5);
13854 : }
13855 17 : return resultobj;
13856 : fail:
13857 : {
13858 0 : if (arg2) free(arg2);
13859 : }
13860 : {
13861 : /* See whether we need to update the Python buffer. */
13862 : if (resultobj && wrapper4 && view4.buf)
13863 : {
13864 : int dirty;
13865 : char *new_data = NULL;
13866 : size_t new_size;
13867 :
13868 :
13869 : new_data = wrapper4->data.mem.buffer;
13870 : new_size = wrapper4->data.mem.length;
13871 : dirty = new_data != NULL;
13872 :
13873 :
13874 :
13875 :
13876 :
13877 :
13878 :
13879 : if (dirty)
13880 : {
13881 : /* The buffer is dirty. */
13882 : if (view4.readonly)
13883 : {
13884 : Py_XDECREF(resultobj);
13885 : resultobj = NULL;
13886 : PyErr_SetString(PyExc_ValueError,
13887 : "cannot update read-only buffer");
13888 : }
13889 :
13890 : /* See if we need to truncate the buffer. */
13891 : if (resultobj && view4.len != new_size)
13892 : {
13893 : if (bytesio4 == NULL)
13894 : {
13895 : Py_XDECREF(resultobj);
13896 : resultobj = NULL;
13897 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
13898 : }
13899 : else
13900 : {
13901 : PyObject *retval;
13902 : PyBuffer_Release(&view4);
13903 : assert(view4.obj == NULL);
13904 : retval = PyObject_CallMethod(bytesio4, "truncate",
13905 : "l", (long) new_size);
13906 : if (retval == NULL)
13907 : {
13908 : Py_XDECREF(resultobj);
13909 : resultobj = NULL;
13910 : }
13911 : else
13912 : {
13913 : Py_DECREF(retval);
13914 :
13915 : retval = PyObject_CallMethod(bytesio4,
13916 : "getbuffer", NULL);
13917 : if (retval == NULL
13918 : || PyObject_GetBuffer(retval, &view4,
13919 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
13920 : {
13921 : Py_XDECREF(resultobj);
13922 : resultobj = NULL;
13923 : }
13924 :
13925 : Py_XDECREF(retval);
13926 :
13927 : if (resultobj && view4.len
13928 : != new_size)
13929 : {
13930 : Py_XDECREF(resultobj);
13931 : resultobj = NULL;
13932 : PyErr_Format(PyExc_ValueError,
13933 : "Expected buffer of length %zu, got %zi",
13934 : new_size,
13935 : view4.len);
13936 : }
13937 : }
13938 : }
13939 : }
13940 : if (resultobj)
13941 : memcpy(view4.buf, new_data, new_size);
13942 : }
13943 :
13944 :
13945 :
13946 : }
13947 :
13948 : /* Free the temporary wrapper, if any. */
13949 0 : if (wrapper4)
13950 0 : gpgme_data_release(wrapper4);
13951 0 : Py_XDECREF (bytesio4);
13952 : if (have_view4 && view4.buf)
13953 : PyBuffer_Release(&view4);
13954 : }
13955 : {
13956 : /* See whether we need to update the Python buffer. */
13957 : if (resultobj && wrapper5 && view5.buf)
13958 : {
13959 : int dirty;
13960 : char *new_data = NULL;
13961 : size_t new_size;
13962 :
13963 :
13964 : new_data = wrapper5->data.mem.buffer;
13965 : new_size = wrapper5->data.mem.length;
13966 : dirty = new_data != NULL;
13967 :
13968 :
13969 :
13970 :
13971 :
13972 :
13973 :
13974 : if (dirty)
13975 : {
13976 : /* The buffer is dirty. */
13977 : if (view5.readonly)
13978 : {
13979 : Py_XDECREF(resultobj);
13980 : resultobj = NULL;
13981 : PyErr_SetString(PyExc_ValueError,
13982 : "cannot update read-only buffer");
13983 : }
13984 :
13985 : /* See if we need to truncate the buffer. */
13986 : if (resultobj && view5.len != new_size)
13987 : {
13988 : if (bytesio5 == NULL)
13989 : {
13990 : Py_XDECREF(resultobj);
13991 : resultobj = NULL;
13992 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
13993 : }
13994 : else
13995 : {
13996 : PyObject *retval;
13997 : PyBuffer_Release(&view5);
13998 : assert(view5.obj == NULL);
13999 : retval = PyObject_CallMethod(bytesio5, "truncate",
14000 : "l", (long) new_size);
14001 : if (retval == NULL)
14002 : {
14003 : Py_XDECREF(resultobj);
14004 : resultobj = NULL;
14005 : }
14006 : else
14007 : {
14008 : Py_DECREF(retval);
14009 :
14010 : retval = PyObject_CallMethod(bytesio5,
14011 : "getbuffer", NULL);
14012 : if (retval == NULL
14013 : || PyObject_GetBuffer(retval, &view5,
14014 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
14015 : {
14016 : Py_XDECREF(resultobj);
14017 : resultobj = NULL;
14018 : }
14019 :
14020 : Py_XDECREF(retval);
14021 :
14022 : if (resultobj && view5.len
14023 : != new_size)
14024 : {
14025 : Py_XDECREF(resultobj);
14026 : resultobj = NULL;
14027 : PyErr_Format(PyExc_ValueError,
14028 : "Expected buffer of length %zu, got %zi",
14029 : new_size,
14030 : view5.len);
14031 : }
14032 : }
14033 : }
14034 : }
14035 : if (resultobj)
14036 : memcpy(view5.buf, new_data, new_size);
14037 : }
14038 :
14039 :
14040 :
14041 : }
14042 :
14043 : /* Free the temporary wrapper, if any. */
14044 0 : if (wrapper5)
14045 0 : gpgme_data_release(wrapper5);
14046 0 : Py_XDECREF (bytesio5);
14047 : if (have_view5 && view5.buf)
14048 : PyBuffer_Release(&view5);
14049 : }
14050 : return NULL;
14051 : }
14052 :
14053 :
14054 0 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_sign_start(PyObject *self, PyObject *args) {
14055 0 : PyObject *resultobj = 0;
14056 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
14057 : gpgme_key_t *arg2 ;
14058 : gpgme_encrypt_flags_t arg3 ;
14059 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
14060 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
14061 0 : void *argp1 = 0 ;
14062 0 : int res1 = 0 ;
14063 : int val3 ;
14064 0 : int ecode3 = 0 ;
14065 0 : gpgme_data_t wrapper4 = NULL ;
14066 0 : PyObject *bytesio4 = NULL ;
14067 : Py_buffer view4 ;
14068 0 : int have_view4 = 0 ;
14069 0 : gpgme_data_t wrapper5 = NULL ;
14070 0 : PyObject *bytesio5 = NULL ;
14071 : Py_buffer view5 ;
14072 0 : int have_view5 = 0 ;
14073 0 : PyObject * obj0 = 0 ;
14074 0 : PyObject * obj1 = 0 ;
14075 0 : PyObject * obj2 = 0 ;
14076 0 : PyObject * obj3 = 0 ;
14077 0 : PyObject * obj4 = 0 ;
14078 : gpgme_error_t result;
14079 :
14080 : {
14081 0 : arg2 = NULL;
14082 : }
14083 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt_sign_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14084 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
14085 0 : if (!SWIG_IsOK(res1)) {
14086 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_sign_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
14087 : }
14088 0 : arg1 = (gpgme_ctx_t)(argp1);
14089 : {
14090 0 : int i, numb = 0;
14091 0 : if (!PySequence_Check(obj1)) {
14092 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
14093 : 2);
14094 0 : return NULL;
14095 : }
14096 0 : if((numb = PySequence_Length(obj1)) != 0) {
14097 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
14098 0 : for(i=0; i<numb; i++) {
14099 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
14100 :
14101 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
14102 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
14103 :
14104 : // Following code is from swig's python.swg
14105 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
14106 0 : Py_DECREF(pypointer);
14107 : return NULL;
14108 : }
14109 0 : Py_DECREF(pypointer);
14110 : }
14111 0 : arg2[numb] = NULL;
14112 : }
14113 : }
14114 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
14115 0 : if (!SWIG_IsOK(ecode3)) {
14116 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt_sign_start" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
14117 : }
14118 0 : arg3 = (gpgme_encrypt_flags_t)(val3);
14119 : {
14120 : /* If we create a temporary wrapper4 object, we will store it in
14121 : wrapperN, where N is 4. Here in this fragment, SWIG will
14122 : automatically append 4. */
14123 : memset(&view4, 0, sizeof view4);
14124 0 : if (obj3 == Py_None)
14125 0 : arg4 = NULL;
14126 : else {
14127 : PyObject *pypointer;
14128 0 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
14129 : &bytesio4, &view4);
14130 0 : if (pypointer == NULL)
14131 : return NULL;
14132 0 : have_view4 = !! view4.obj;
14133 :
14134 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
14135 :
14136 : // Following code is from swig's python.swg
14137 :
14138 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
14139 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
14140 0 : Py_DECREF(pypointer);
14141 : return NULL;
14142 : }
14143 0 : Py_DECREF(pypointer);
14144 : }
14145 : }
14146 : {
14147 : /* If we create a temporary wrapper5 object, we will store it in
14148 : wrapperN, where N is 5. Here in this fragment, SWIG will
14149 : automatically append 5. */
14150 : memset(&view5, 0, sizeof view5);
14151 0 : if (obj4 == Py_None)
14152 0 : arg5 = NULL;
14153 : else {
14154 : PyObject *pypointer;
14155 0 : pypointer = _pyme_obj2gpgme_data_t(obj4, 5, &wrapper5,
14156 : &bytesio5, &view5);
14157 0 : if (pypointer == NULL)
14158 : return NULL;
14159 0 : have_view5 = !! view5.obj;
14160 :
14161 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
14162 :
14163 : // Following code is from swig's python.swg
14164 :
14165 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
14166 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
14167 0 : Py_DECREF(pypointer);
14168 : return NULL;
14169 : }
14170 0 : Py_DECREF(pypointer);
14171 : }
14172 : }
14173 0 : result = gpgme_op_encrypt_sign_start(arg1,arg2,arg3,arg4,arg5);
14174 : {
14175 0 : resultobj = PyLong_FromLong(result);
14176 : }
14177 : {
14178 0 : if (arg2) free(arg2);
14179 : }
14180 : {
14181 : /* See whether we need to update the Python buffer. */
14182 0 : if (resultobj && wrapper4 && view4.buf)
14183 : {
14184 : int dirty;
14185 0 : char *new_data = NULL;
14186 : size_t new_size;
14187 :
14188 :
14189 0 : new_data = wrapper4->data.mem.buffer;
14190 0 : new_size = wrapper4->data.mem.length;
14191 0 : dirty = new_data != NULL;
14192 :
14193 :
14194 :
14195 :
14196 :
14197 :
14198 :
14199 0 : if (dirty)
14200 : {
14201 : /* The buffer is dirty. */
14202 0 : if (view4.readonly)
14203 : {
14204 0 : Py_XDECREF(resultobj);
14205 0 : resultobj = NULL;
14206 0 : PyErr_SetString(PyExc_ValueError,
14207 : "cannot update read-only buffer");
14208 : }
14209 :
14210 : /* See if we need to truncate the buffer. */
14211 0 : if (resultobj && view4.len != new_size)
14212 : {
14213 0 : if (bytesio4 == NULL)
14214 : {
14215 0 : Py_XDECREF(resultobj);
14216 0 : resultobj = NULL;
14217 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
14218 : }
14219 : else
14220 : {
14221 : PyObject *retval;
14222 0 : PyBuffer_Release(&view4);
14223 : assert(view4.obj == NULL);
14224 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
14225 : "l", (long) new_size);
14226 0 : if (retval == NULL)
14227 : {
14228 0 : Py_XDECREF(resultobj);
14229 : resultobj = NULL;
14230 : }
14231 : else
14232 : {
14233 0 : Py_DECREF(retval);
14234 :
14235 0 : retval = PyObject_CallMethod(bytesio4,
14236 : "getbuffer", NULL);
14237 0 : if (retval == NULL
14238 0 : || PyObject_GetBuffer(retval, &view4,
14239 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
14240 : {
14241 0 : Py_XDECREF(resultobj);
14242 : resultobj = NULL;
14243 : }
14244 :
14245 0 : Py_XDECREF(retval);
14246 :
14247 0 : if (resultobj && view4.len
14248 0 : != new_size)
14249 : {
14250 0 : Py_XDECREF(resultobj);
14251 0 : resultobj = NULL;
14252 0 : PyErr_Format(PyExc_ValueError,
14253 : "Expected buffer of length %zu, got %zi",
14254 : new_size,
14255 : view4.len);
14256 : }
14257 : }
14258 : }
14259 : }
14260 0 : if (resultobj)
14261 0 : memcpy(view4.buf, new_data, new_size);
14262 : }
14263 :
14264 :
14265 :
14266 : }
14267 :
14268 : /* Free the temporary wrapper, if any. */
14269 0 : if (wrapper4)
14270 0 : gpgme_data_release(wrapper4);
14271 0 : Py_XDECREF (bytesio4);
14272 0 : if (have_view4 && view4.buf)
14273 0 : PyBuffer_Release(&view4);
14274 : }
14275 : {
14276 : /* See whether we need to update the Python buffer. */
14277 0 : if (resultobj && wrapper5 && view5.buf)
14278 : {
14279 : int dirty;
14280 0 : char *new_data = NULL;
14281 : size_t new_size;
14282 :
14283 :
14284 0 : new_data = wrapper5->data.mem.buffer;
14285 0 : new_size = wrapper5->data.mem.length;
14286 0 : dirty = new_data != NULL;
14287 :
14288 :
14289 :
14290 :
14291 :
14292 :
14293 :
14294 0 : if (dirty)
14295 : {
14296 : /* The buffer is dirty. */
14297 0 : if (view5.readonly)
14298 : {
14299 0 : Py_XDECREF(resultobj);
14300 0 : resultobj = NULL;
14301 0 : PyErr_SetString(PyExc_ValueError,
14302 : "cannot update read-only buffer");
14303 : }
14304 :
14305 : /* See if we need to truncate the buffer. */
14306 0 : if (resultobj && view5.len != new_size)
14307 : {
14308 0 : if (bytesio5 == NULL)
14309 : {
14310 0 : Py_XDECREF(resultobj);
14311 0 : resultobj = NULL;
14312 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
14313 : }
14314 : else
14315 : {
14316 : PyObject *retval;
14317 0 : PyBuffer_Release(&view5);
14318 : assert(view5.obj == NULL);
14319 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
14320 : "l", (long) new_size);
14321 0 : if (retval == NULL)
14322 : {
14323 0 : Py_XDECREF(resultobj);
14324 : resultobj = NULL;
14325 : }
14326 : else
14327 : {
14328 0 : Py_DECREF(retval);
14329 :
14330 0 : retval = PyObject_CallMethod(bytesio5,
14331 : "getbuffer", NULL);
14332 0 : if (retval == NULL
14333 0 : || PyObject_GetBuffer(retval, &view5,
14334 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
14335 : {
14336 0 : Py_XDECREF(resultobj);
14337 : resultobj = NULL;
14338 : }
14339 :
14340 0 : Py_XDECREF(retval);
14341 :
14342 0 : if (resultobj && view5.len
14343 0 : != new_size)
14344 : {
14345 0 : Py_XDECREF(resultobj);
14346 0 : resultobj = NULL;
14347 0 : PyErr_Format(PyExc_ValueError,
14348 : "Expected buffer of length %zu, got %zi",
14349 : new_size,
14350 : view5.len);
14351 : }
14352 : }
14353 : }
14354 : }
14355 0 : if (resultobj)
14356 0 : memcpy(view5.buf, new_data, new_size);
14357 : }
14358 :
14359 :
14360 :
14361 : }
14362 :
14363 : /* Free the temporary wrapper, if any. */
14364 0 : if (wrapper5)
14365 0 : gpgme_data_release(wrapper5);
14366 0 : Py_XDECREF (bytesio5);
14367 0 : if (have_view5 && view5.buf)
14368 0 : PyBuffer_Release(&view5);
14369 : }
14370 0 : return resultobj;
14371 : fail:
14372 : {
14373 0 : if (arg2) free(arg2);
14374 : }
14375 : {
14376 : /* See whether we need to update the Python buffer. */
14377 : if (resultobj && wrapper4 && view4.buf)
14378 : {
14379 : int dirty;
14380 : char *new_data = NULL;
14381 : size_t new_size;
14382 :
14383 :
14384 : new_data = wrapper4->data.mem.buffer;
14385 : new_size = wrapper4->data.mem.length;
14386 : dirty = new_data != NULL;
14387 :
14388 :
14389 :
14390 :
14391 :
14392 :
14393 :
14394 : if (dirty)
14395 : {
14396 : /* The buffer is dirty. */
14397 : if (view4.readonly)
14398 : {
14399 : Py_XDECREF(resultobj);
14400 : resultobj = NULL;
14401 : PyErr_SetString(PyExc_ValueError,
14402 : "cannot update read-only buffer");
14403 : }
14404 :
14405 : /* See if we need to truncate the buffer. */
14406 : if (resultobj && view4.len != new_size)
14407 : {
14408 : if (bytesio4 == NULL)
14409 : {
14410 : Py_XDECREF(resultobj);
14411 : resultobj = NULL;
14412 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
14413 : }
14414 : else
14415 : {
14416 : PyObject *retval;
14417 : PyBuffer_Release(&view4);
14418 : assert(view4.obj == NULL);
14419 : retval = PyObject_CallMethod(bytesio4, "truncate",
14420 : "l", (long) new_size);
14421 : if (retval == NULL)
14422 : {
14423 : Py_XDECREF(resultobj);
14424 : resultobj = NULL;
14425 : }
14426 : else
14427 : {
14428 : Py_DECREF(retval);
14429 :
14430 : retval = PyObject_CallMethod(bytesio4,
14431 : "getbuffer", NULL);
14432 : if (retval == NULL
14433 : || PyObject_GetBuffer(retval, &view4,
14434 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
14435 : {
14436 : Py_XDECREF(resultobj);
14437 : resultobj = NULL;
14438 : }
14439 :
14440 : Py_XDECREF(retval);
14441 :
14442 : if (resultobj && view4.len
14443 : != new_size)
14444 : {
14445 : Py_XDECREF(resultobj);
14446 : resultobj = NULL;
14447 : PyErr_Format(PyExc_ValueError,
14448 : "Expected buffer of length %zu, got %zi",
14449 : new_size,
14450 : view4.len);
14451 : }
14452 : }
14453 : }
14454 : }
14455 : if (resultobj)
14456 : memcpy(view4.buf, new_data, new_size);
14457 : }
14458 :
14459 :
14460 :
14461 : }
14462 :
14463 : /* Free the temporary wrapper, if any. */
14464 0 : if (wrapper4)
14465 0 : gpgme_data_release(wrapper4);
14466 0 : Py_XDECREF (bytesio4);
14467 : if (have_view4 && view4.buf)
14468 : PyBuffer_Release(&view4);
14469 : }
14470 : {
14471 : /* See whether we need to update the Python buffer. */
14472 : if (resultobj && wrapper5 && view5.buf)
14473 : {
14474 : int dirty;
14475 : char *new_data = NULL;
14476 : size_t new_size;
14477 :
14478 :
14479 : new_data = wrapper5->data.mem.buffer;
14480 : new_size = wrapper5->data.mem.length;
14481 : dirty = new_data != NULL;
14482 :
14483 :
14484 :
14485 :
14486 :
14487 :
14488 :
14489 : if (dirty)
14490 : {
14491 : /* The buffer is dirty. */
14492 : if (view5.readonly)
14493 : {
14494 : Py_XDECREF(resultobj);
14495 : resultobj = NULL;
14496 : PyErr_SetString(PyExc_ValueError,
14497 : "cannot update read-only buffer");
14498 : }
14499 :
14500 : /* See if we need to truncate the buffer. */
14501 : if (resultobj && view5.len != new_size)
14502 : {
14503 : if (bytesio5 == NULL)
14504 : {
14505 : Py_XDECREF(resultobj);
14506 : resultobj = NULL;
14507 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
14508 : }
14509 : else
14510 : {
14511 : PyObject *retval;
14512 : PyBuffer_Release(&view5);
14513 : assert(view5.obj == NULL);
14514 : retval = PyObject_CallMethod(bytesio5, "truncate",
14515 : "l", (long) new_size);
14516 : if (retval == NULL)
14517 : {
14518 : Py_XDECREF(resultobj);
14519 : resultobj = NULL;
14520 : }
14521 : else
14522 : {
14523 : Py_DECREF(retval);
14524 :
14525 : retval = PyObject_CallMethod(bytesio5,
14526 : "getbuffer", NULL);
14527 : if (retval == NULL
14528 : || PyObject_GetBuffer(retval, &view5,
14529 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
14530 : {
14531 : Py_XDECREF(resultobj);
14532 : resultobj = NULL;
14533 : }
14534 :
14535 : Py_XDECREF(retval);
14536 :
14537 : if (resultobj && view5.len
14538 : != new_size)
14539 : {
14540 : Py_XDECREF(resultobj);
14541 : resultobj = NULL;
14542 : PyErr_Format(PyExc_ValueError,
14543 : "Expected buffer of length %zu, got %zi",
14544 : new_size,
14545 : view5.len);
14546 : }
14547 : }
14548 : }
14549 : }
14550 : if (resultobj)
14551 : memcpy(view5.buf, new_data, new_size);
14552 : }
14553 :
14554 :
14555 :
14556 : }
14557 :
14558 : /* Free the temporary wrapper, if any. */
14559 0 : if (wrapper5)
14560 0 : gpgme_data_release(wrapper5);
14561 0 : Py_XDECREF (bytesio5);
14562 : if (have_view5 && view5.buf)
14563 : PyBuffer_Release(&view5);
14564 : }
14565 : return NULL;
14566 : }
14567 :
14568 :
14569 5 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_sign(PyObject *self, PyObject *args) {
14570 5 : PyObject *resultobj = 0;
14571 5 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
14572 : gpgme_key_t *arg2 ;
14573 : gpgme_encrypt_flags_t arg3 ;
14574 5 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
14575 5 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
14576 5 : void *argp1 = 0 ;
14577 5 : int res1 = 0 ;
14578 : int val3 ;
14579 5 : int ecode3 = 0 ;
14580 5 : gpgme_data_t wrapper4 = NULL ;
14581 5 : PyObject *bytesio4 = NULL ;
14582 : Py_buffer view4 ;
14583 5 : int have_view4 = 0 ;
14584 5 : gpgme_data_t wrapper5 = NULL ;
14585 5 : PyObject *bytesio5 = NULL ;
14586 : Py_buffer view5 ;
14587 5 : int have_view5 = 0 ;
14588 5 : PyObject * obj0 = 0 ;
14589 5 : PyObject * obj1 = 0 ;
14590 5 : PyObject * obj2 = 0 ;
14591 5 : PyObject * obj3 = 0 ;
14592 5 : PyObject * obj4 = 0 ;
14593 : gpgme_error_t result;
14594 :
14595 : {
14596 5 : arg2 = NULL;
14597 : }
14598 5 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt_sign",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14599 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
14600 5 : if (!SWIG_IsOK(res1)) {
14601 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_sign" "', argument " "1"" of type '" "gpgme_ctx_t""'");
14602 : }
14603 5 : arg1 = (gpgme_ctx_t)(argp1);
14604 : {
14605 5 : int i, numb = 0;
14606 5 : if (!PySequence_Check(obj1)) {
14607 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
14608 : 2);
14609 0 : return NULL;
14610 : }
14611 5 : if((numb = PySequence_Length(obj1)) != 0) {
14612 4 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
14613 12 : for(i=0; i<numb; i++) {
14614 8 : PyObject *pypointer = PySequence_GetItem(obj1, i);
14615 :
14616 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
14617 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
14618 :
14619 : // Following code is from swig's python.swg
14620 8 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
14621 0 : Py_DECREF(pypointer);
14622 : return NULL;
14623 : }
14624 8 : Py_DECREF(pypointer);
14625 : }
14626 4 : arg2[numb] = NULL;
14627 : }
14628 : }
14629 5 : ecode3 = SWIG_AsVal_int(obj2, &val3);
14630 5 : if (!SWIG_IsOK(ecode3)) {
14631 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt_sign" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
14632 : }
14633 5 : arg3 = (gpgme_encrypt_flags_t)(val3);
14634 : {
14635 : /* If we create a temporary wrapper4 object, we will store it in
14636 : wrapperN, where N is 4. Here in this fragment, SWIG will
14637 : automatically append 4. */
14638 : memset(&view4, 0, sizeof view4);
14639 5 : if (obj3 == Py_None)
14640 0 : arg4 = NULL;
14641 : else {
14642 : PyObject *pypointer;
14643 5 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
14644 : &bytesio4, &view4);
14645 5 : if (pypointer == NULL)
14646 : return NULL;
14647 5 : have_view4 = !! view4.obj;
14648 :
14649 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
14650 :
14651 : // Following code is from swig's python.swg
14652 :
14653 5 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
14654 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
14655 0 : Py_DECREF(pypointer);
14656 : return NULL;
14657 : }
14658 5 : Py_DECREF(pypointer);
14659 : }
14660 : }
14661 : {
14662 : /* If we create a temporary wrapper5 object, we will store it in
14663 : wrapperN, where N is 5. Here in this fragment, SWIG will
14664 : automatically append 5. */
14665 : memset(&view5, 0, sizeof view5);
14666 5 : if (obj4 == Py_None)
14667 0 : arg5 = NULL;
14668 : else {
14669 : PyObject *pypointer;
14670 5 : pypointer = _pyme_obj2gpgme_data_t(obj4, 5, &wrapper5,
14671 : &bytesio5, &view5);
14672 5 : if (pypointer == NULL)
14673 : return NULL;
14674 5 : have_view5 = !! view5.obj;
14675 :
14676 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
14677 :
14678 : // Following code is from swig's python.swg
14679 :
14680 5 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
14681 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
14682 0 : Py_DECREF(pypointer);
14683 : return NULL;
14684 : }
14685 5 : Py_DECREF(pypointer);
14686 : }
14687 : }
14688 5 : result = gpgme_op_encrypt_sign(arg1,arg2,arg3,arg4,arg5);
14689 : {
14690 5 : resultobj = PyLong_FromLong(result);
14691 : }
14692 : {
14693 5 : if (arg2) free(arg2);
14694 : }
14695 : {
14696 : /* See whether we need to update the Python buffer. */
14697 5 : if (resultobj && wrapper4 && view4.buf)
14698 : {
14699 : int dirty;
14700 3 : char *new_data = NULL;
14701 : size_t new_size;
14702 :
14703 :
14704 3 : new_data = wrapper4->data.mem.buffer;
14705 3 : new_size = wrapper4->data.mem.length;
14706 3 : dirty = new_data != NULL;
14707 :
14708 :
14709 :
14710 :
14711 :
14712 :
14713 :
14714 3 : if (dirty)
14715 : {
14716 : /* The buffer is dirty. */
14717 0 : if (view4.readonly)
14718 : {
14719 0 : Py_XDECREF(resultobj);
14720 0 : resultobj = NULL;
14721 0 : PyErr_SetString(PyExc_ValueError,
14722 : "cannot update read-only buffer");
14723 : }
14724 :
14725 : /* See if we need to truncate the buffer. */
14726 0 : if (resultobj && view4.len != new_size)
14727 : {
14728 0 : if (bytesio4 == NULL)
14729 : {
14730 0 : Py_XDECREF(resultobj);
14731 0 : resultobj = NULL;
14732 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
14733 : }
14734 : else
14735 : {
14736 : PyObject *retval;
14737 0 : PyBuffer_Release(&view4);
14738 : assert(view4.obj == NULL);
14739 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
14740 : "l", (long) new_size);
14741 0 : if (retval == NULL)
14742 : {
14743 0 : Py_XDECREF(resultobj);
14744 : resultobj = NULL;
14745 : }
14746 : else
14747 : {
14748 0 : Py_DECREF(retval);
14749 :
14750 0 : retval = PyObject_CallMethod(bytesio4,
14751 : "getbuffer", NULL);
14752 0 : if (retval == NULL
14753 0 : || PyObject_GetBuffer(retval, &view4,
14754 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
14755 : {
14756 0 : Py_XDECREF(resultobj);
14757 : resultobj = NULL;
14758 : }
14759 :
14760 0 : Py_XDECREF(retval);
14761 :
14762 0 : if (resultobj && view4.len
14763 0 : != new_size)
14764 : {
14765 0 : Py_XDECREF(resultobj);
14766 0 : resultobj = NULL;
14767 0 : PyErr_Format(PyExc_ValueError,
14768 : "Expected buffer of length %zu, got %zi",
14769 : new_size,
14770 : view4.len);
14771 : }
14772 : }
14773 : }
14774 : }
14775 0 : if (resultobj)
14776 0 : memcpy(view4.buf, new_data, new_size);
14777 : }
14778 :
14779 :
14780 :
14781 : }
14782 :
14783 : /* Free the temporary wrapper, if any. */
14784 5 : if (wrapper4)
14785 3 : gpgme_data_release(wrapper4);
14786 5 : Py_XDECREF (bytesio4);
14787 5 : if (have_view4 && view4.buf)
14788 3 : PyBuffer_Release(&view4);
14789 : }
14790 : {
14791 : /* See whether we need to update the Python buffer. */
14792 5 : if (resultobj && wrapper5 && view5.buf)
14793 : {
14794 : int dirty;
14795 0 : char *new_data = NULL;
14796 : size_t new_size;
14797 :
14798 :
14799 0 : new_data = wrapper5->data.mem.buffer;
14800 0 : new_size = wrapper5->data.mem.length;
14801 0 : dirty = new_data != NULL;
14802 :
14803 :
14804 :
14805 :
14806 :
14807 :
14808 :
14809 0 : if (dirty)
14810 : {
14811 : /* The buffer is dirty. */
14812 0 : if (view5.readonly)
14813 : {
14814 0 : Py_XDECREF(resultobj);
14815 0 : resultobj = NULL;
14816 0 : PyErr_SetString(PyExc_ValueError,
14817 : "cannot update read-only buffer");
14818 : }
14819 :
14820 : /* See if we need to truncate the buffer. */
14821 0 : if (resultobj && view5.len != new_size)
14822 : {
14823 0 : if (bytesio5 == NULL)
14824 : {
14825 0 : Py_XDECREF(resultobj);
14826 0 : resultobj = NULL;
14827 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
14828 : }
14829 : else
14830 : {
14831 : PyObject *retval;
14832 0 : PyBuffer_Release(&view5);
14833 : assert(view5.obj == NULL);
14834 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
14835 : "l", (long) new_size);
14836 0 : if (retval == NULL)
14837 : {
14838 0 : Py_XDECREF(resultobj);
14839 : resultobj = NULL;
14840 : }
14841 : else
14842 : {
14843 0 : Py_DECREF(retval);
14844 :
14845 0 : retval = PyObject_CallMethod(bytesio5,
14846 : "getbuffer", NULL);
14847 0 : if (retval == NULL
14848 0 : || PyObject_GetBuffer(retval, &view5,
14849 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
14850 : {
14851 0 : Py_XDECREF(resultobj);
14852 : resultobj = NULL;
14853 : }
14854 :
14855 0 : Py_XDECREF(retval);
14856 :
14857 0 : if (resultobj && view5.len
14858 0 : != new_size)
14859 : {
14860 0 : Py_XDECREF(resultobj);
14861 0 : resultobj = NULL;
14862 0 : PyErr_Format(PyExc_ValueError,
14863 : "Expected buffer of length %zu, got %zi",
14864 : new_size,
14865 : view5.len);
14866 : }
14867 : }
14868 : }
14869 : }
14870 0 : if (resultobj)
14871 0 : memcpy(view5.buf, new_data, new_size);
14872 : }
14873 :
14874 :
14875 :
14876 : }
14877 :
14878 : /* Free the temporary wrapper, if any. */
14879 5 : if (wrapper5)
14880 0 : gpgme_data_release(wrapper5);
14881 5 : Py_XDECREF (bytesio5);
14882 5 : if (have_view5 && view5.buf)
14883 0 : PyBuffer_Release(&view5);
14884 : }
14885 5 : return resultobj;
14886 : fail:
14887 : {
14888 0 : if (arg2) free(arg2);
14889 : }
14890 : {
14891 : /* See whether we need to update the Python buffer. */
14892 : if (resultobj && wrapper4 && view4.buf)
14893 : {
14894 : int dirty;
14895 : char *new_data = NULL;
14896 : size_t new_size;
14897 :
14898 :
14899 : new_data = wrapper4->data.mem.buffer;
14900 : new_size = wrapper4->data.mem.length;
14901 : dirty = new_data != NULL;
14902 :
14903 :
14904 :
14905 :
14906 :
14907 :
14908 :
14909 : if (dirty)
14910 : {
14911 : /* The buffer is dirty. */
14912 : if (view4.readonly)
14913 : {
14914 : Py_XDECREF(resultobj);
14915 : resultobj = NULL;
14916 : PyErr_SetString(PyExc_ValueError,
14917 : "cannot update read-only buffer");
14918 : }
14919 :
14920 : /* See if we need to truncate the buffer. */
14921 : if (resultobj && view4.len != new_size)
14922 : {
14923 : if (bytesio4 == NULL)
14924 : {
14925 : Py_XDECREF(resultobj);
14926 : resultobj = NULL;
14927 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
14928 : }
14929 : else
14930 : {
14931 : PyObject *retval;
14932 : PyBuffer_Release(&view4);
14933 : assert(view4.obj == NULL);
14934 : retval = PyObject_CallMethod(bytesio4, "truncate",
14935 : "l", (long) new_size);
14936 : if (retval == NULL)
14937 : {
14938 : Py_XDECREF(resultobj);
14939 : resultobj = NULL;
14940 : }
14941 : else
14942 : {
14943 : Py_DECREF(retval);
14944 :
14945 : retval = PyObject_CallMethod(bytesio4,
14946 : "getbuffer", NULL);
14947 : if (retval == NULL
14948 : || PyObject_GetBuffer(retval, &view4,
14949 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
14950 : {
14951 : Py_XDECREF(resultobj);
14952 : resultobj = NULL;
14953 : }
14954 :
14955 : Py_XDECREF(retval);
14956 :
14957 : if (resultobj && view4.len
14958 : != new_size)
14959 : {
14960 : Py_XDECREF(resultobj);
14961 : resultobj = NULL;
14962 : PyErr_Format(PyExc_ValueError,
14963 : "Expected buffer of length %zu, got %zi",
14964 : new_size,
14965 : view4.len);
14966 : }
14967 : }
14968 : }
14969 : }
14970 : if (resultobj)
14971 : memcpy(view4.buf, new_data, new_size);
14972 : }
14973 :
14974 :
14975 :
14976 : }
14977 :
14978 : /* Free the temporary wrapper, if any. */
14979 0 : if (wrapper4)
14980 0 : gpgme_data_release(wrapper4);
14981 0 : Py_XDECREF (bytesio4);
14982 : if (have_view4 && view4.buf)
14983 : PyBuffer_Release(&view4);
14984 : }
14985 : {
14986 : /* See whether we need to update the Python buffer. */
14987 : if (resultobj && wrapper5 && view5.buf)
14988 : {
14989 : int dirty;
14990 : char *new_data = NULL;
14991 : size_t new_size;
14992 :
14993 :
14994 : new_data = wrapper5->data.mem.buffer;
14995 : new_size = wrapper5->data.mem.length;
14996 : dirty = new_data != NULL;
14997 :
14998 :
14999 :
15000 :
15001 :
15002 :
15003 :
15004 : if (dirty)
15005 : {
15006 : /* The buffer is dirty. */
15007 : if (view5.readonly)
15008 : {
15009 : Py_XDECREF(resultobj);
15010 : resultobj = NULL;
15011 : PyErr_SetString(PyExc_ValueError,
15012 : "cannot update read-only buffer");
15013 : }
15014 :
15015 : /* See if we need to truncate the buffer. */
15016 : if (resultobj && view5.len != new_size)
15017 : {
15018 : if (bytesio5 == NULL)
15019 : {
15020 : Py_XDECREF(resultobj);
15021 : resultobj = NULL;
15022 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15023 : }
15024 : else
15025 : {
15026 : PyObject *retval;
15027 : PyBuffer_Release(&view5);
15028 : assert(view5.obj == NULL);
15029 : retval = PyObject_CallMethod(bytesio5, "truncate",
15030 : "l", (long) new_size);
15031 : if (retval == NULL)
15032 : {
15033 : Py_XDECREF(resultobj);
15034 : resultobj = NULL;
15035 : }
15036 : else
15037 : {
15038 : Py_DECREF(retval);
15039 :
15040 : retval = PyObject_CallMethod(bytesio5,
15041 : "getbuffer", NULL);
15042 : if (retval == NULL
15043 : || PyObject_GetBuffer(retval, &view5,
15044 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15045 : {
15046 : Py_XDECREF(resultobj);
15047 : resultobj = NULL;
15048 : }
15049 :
15050 : Py_XDECREF(retval);
15051 :
15052 : if (resultobj && view5.len
15053 : != new_size)
15054 : {
15055 : Py_XDECREF(resultobj);
15056 : resultobj = NULL;
15057 : PyErr_Format(PyExc_ValueError,
15058 : "Expected buffer of length %zu, got %zi",
15059 : new_size,
15060 : view5.len);
15061 : }
15062 : }
15063 : }
15064 : }
15065 : if (resultobj)
15066 : memcpy(view5.buf, new_data, new_size);
15067 : }
15068 :
15069 :
15070 :
15071 : }
15072 :
15073 : /* Free the temporary wrapper, if any. */
15074 0 : if (wrapper5)
15075 0 : gpgme_data_release(wrapper5);
15076 0 : Py_XDECREF (bytesio5);
15077 : if (have_view5 && view5.buf)
15078 : PyBuffer_Release(&view5);
15079 : }
15080 : return NULL;
15081 : }
15082 :
15083 :
15084 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient_keyid_set(PyObject *self, PyObject *args) {
15085 0 : PyObject *resultobj = 0;
15086 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
15087 0 : char *arg2 = (char *) 0 ;
15088 0 : void *argp1 = 0 ;
15089 0 : int res1 = 0 ;
15090 : int res2 ;
15091 0 : char *buf2 = 0 ;
15092 0 : int alloc2 = 0 ;
15093 0 : PyObject * obj1 = 0 ;
15094 :
15095 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient_keyid_set",&obj1)) SWIG_fail;
15096 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
15097 0 : if (!SWIG_IsOK(res1)) {
15098 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_keyid_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
15099 : }
15100 0 : arg1 = (struct _gpgme_recipient *)(argp1);
15101 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
15102 0 : if (!SWIG_IsOK(res2)) {
15103 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_recipient_keyid_set" "', argument " "2"" of type '" "char *""'");
15104 : }
15105 0 : arg2 = (char *)(buf2);
15106 0 : if (arg1->keyid) free((char*)arg1->keyid);
15107 0 : if (arg2) {
15108 0 : size_t size = strlen((const char *)(arg2)) + 1;
15109 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
15110 : } else {
15111 0 : arg1->keyid = 0;
15112 : }
15113 0 : resultobj = SWIG_Py_Void();
15114 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15115 : return resultobj;
15116 : fail:
15117 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15118 : return NULL;
15119 : }
15120 :
15121 :
15122 6 : SWIGINTERN PyObject *_wrap__gpgme_recipient_keyid_get(PyObject *self, PyObject *args) {
15123 6 : PyObject *resultobj = 0;
15124 6 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
15125 6 : void *argp1 = 0 ;
15126 6 : int res1 = 0 ;
15127 6 : char *result = 0 ;
15128 :
15129 6 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15130 6 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
15131 6 : if (!SWIG_IsOK(res1)) {
15132 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_keyid_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
15133 : }
15134 6 : arg1 = (struct _gpgme_recipient *)(argp1);
15135 6 : result = (char *) ((arg1)->keyid);
15136 6 : resultobj = SWIG_FromCharPtr((const char *)result);
15137 6 : return resultobj;
15138 : fail:
15139 : return NULL;
15140 : }
15141 :
15142 :
15143 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient__keyid_set(PyObject *self, PyObject *args) {
15144 0 : PyObject *resultobj = 0;
15145 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
15146 : char *arg2 ;
15147 0 : void *argp1 = 0 ;
15148 0 : int res1 = 0 ;
15149 : char temp2[16+1] ;
15150 : int res2 ;
15151 0 : PyObject * obj1 = 0 ;
15152 :
15153 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient__keyid_set",&obj1)) SWIG_fail;
15154 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
15155 0 : if (!SWIG_IsOK(res1)) {
15156 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient__keyid_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
15157 : }
15158 0 : arg1 = (struct _gpgme_recipient *)(argp1);
15159 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
15160 0 : if (!SWIG_IsOK(res2)) {
15161 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_recipient__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
15162 : }
15163 0 : arg2 = (char *)(temp2);
15164 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
15165 : else memset(arg1->_keyid,0,16+1*sizeof(char));
15166 0 : resultobj = SWIG_Py_Void();
15167 0 : return resultobj;
15168 : fail:
15169 : return NULL;
15170 : }
15171 :
15172 :
15173 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient__keyid_get(PyObject *self, PyObject *args) {
15174 0 : PyObject *resultobj = 0;
15175 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
15176 0 : void *argp1 = 0 ;
15177 0 : int res1 = 0 ;
15178 0 : char *result = 0 ;
15179 :
15180 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15181 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
15182 0 : if (!SWIG_IsOK(res1)) {
15183 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient__keyid_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
15184 : }
15185 0 : arg1 = (struct _gpgme_recipient *)(argp1);
15186 0 : result = (char *)(char *) ((arg1)->_keyid);
15187 : {
15188 0 : size_t size = 16+1;
15189 :
15190 0 : while (size && (result[size - 1] == '\0')) --size;
15191 :
15192 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
15193 : }
15194 0 : return resultobj;
15195 : fail:
15196 : return NULL;
15197 : }
15198 :
15199 :
15200 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient_pubkey_algo_set(PyObject *self, PyObject *args) {
15201 0 : PyObject *resultobj = 0;
15202 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
15203 : gpgme_pubkey_algo_t arg2 ;
15204 0 : void *argp1 = 0 ;
15205 0 : int res1 = 0 ;
15206 : int val2 ;
15207 0 : int ecode2 = 0 ;
15208 0 : PyObject * obj1 = 0 ;
15209 :
15210 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient_pubkey_algo_set",&obj1)) SWIG_fail;
15211 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
15212 0 : if (!SWIG_IsOK(res1)) {
15213 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
15214 : }
15215 0 : arg1 = (struct _gpgme_recipient *)(argp1);
15216 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15217 0 : if (!SWIG_IsOK(ecode2)) {
15218 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_recipient_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
15219 : }
15220 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
15221 0 : if (arg1) (arg1)->pubkey_algo = arg2;
15222 0 : resultobj = SWIG_Py_Void();
15223 0 : return resultobj;
15224 : fail:
15225 : return NULL;
15226 : }
15227 :
15228 :
15229 6 : SWIGINTERN PyObject *_wrap__gpgme_recipient_pubkey_algo_get(PyObject *self, PyObject *args) {
15230 6 : PyObject *resultobj = 0;
15231 6 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
15232 6 : void *argp1 = 0 ;
15233 6 : int res1 = 0 ;
15234 : gpgme_pubkey_algo_t result;
15235 :
15236 6 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15237 6 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
15238 6 : if (!SWIG_IsOK(res1)) {
15239 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
15240 : }
15241 6 : arg1 = (struct _gpgme_recipient *)(argp1);
15242 6 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
15243 12 : resultobj = SWIG_From_int((int)(result));
15244 6 : return resultobj;
15245 : fail:
15246 : return NULL;
15247 : }
15248 :
15249 :
15250 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient_status_set(PyObject *self, PyObject *args) {
15251 0 : PyObject *resultobj = 0;
15252 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
15253 : gpgme_error_t arg2 ;
15254 0 : void *argp1 = 0 ;
15255 0 : int res1 = 0 ;
15256 0 : PyObject * obj1 = 0 ;
15257 :
15258 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient_status_set",&obj1)) SWIG_fail;
15259 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
15260 0 : if (!SWIG_IsOK(res1)) {
15261 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_status_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
15262 : }
15263 0 : arg1 = (struct _gpgme_recipient *)(argp1);
15264 : {
15265 0 : arg2 = PyLong_AsLong(obj1);
15266 : }
15267 0 : if (arg1) (arg1)->status = arg2;
15268 0 : resultobj = SWIG_Py_Void();
15269 0 : return resultobj;
15270 : fail:
15271 : return NULL;
15272 : }
15273 :
15274 :
15275 6 : SWIGINTERN PyObject *_wrap__gpgme_recipient_status_get(PyObject *self, PyObject *args) {
15276 6 : PyObject *resultobj = 0;
15277 6 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
15278 6 : void *argp1 = 0 ;
15279 6 : int res1 = 0 ;
15280 : gpgme_error_t result;
15281 :
15282 6 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15283 6 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
15284 6 : if (!SWIG_IsOK(res1)) {
15285 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_status_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
15286 : }
15287 6 : arg1 = (struct _gpgme_recipient *)(argp1);
15288 6 : result = ((arg1)->status);
15289 : {
15290 6 : resultobj = PyLong_FromLong(result);
15291 : }
15292 6 : return resultobj;
15293 : fail:
15294 : return NULL;
15295 : }
15296 :
15297 :
15298 0 : SWIGINTERN int _wrap_new__gpgme_recipient(PyObject *self, PyObject *args) {
15299 0 : PyObject *resultobj = 0;
15300 0 : struct _gpgme_recipient *result = 0 ;
15301 :
15302 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15303 0 : result = (struct _gpgme_recipient *)calloc(1, sizeof(struct _gpgme_recipient));
15304 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_recipient, SWIG_BUILTIN_INIT | 0 );
15305 0 : return resultobj == Py_None ? -1 : 0;
15306 : fail:
15307 : return -1;
15308 : }
15309 :
15310 :
15311 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_recipient(PyObject *self, PyObject *args) {
15312 0 : PyObject *resultobj = 0;
15313 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
15314 0 : void *argp1 = 0 ;
15315 0 : int res1 = 0 ;
15316 :
15317 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15318 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_recipient, SWIG_POINTER_DISOWN | 0 );
15319 0 : if (!SWIG_IsOK(res1)) {
15320 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_recipient" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
15321 : }
15322 0 : arg1 = (struct _gpgme_recipient *)(argp1);
15323 0 : free((char *) arg1);
15324 0 : resultobj = SWIG_Py_Void();
15325 0 : return resultobj;
15326 : fail:
15327 : return NULL;
15328 : }
15329 :
15330 :
15331 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_unsupported_algorithm_set(PyObject *self, PyObject *args) {
15332 0 : PyObject *resultobj = 0;
15333 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
15334 0 : char *arg2 = (char *) 0 ;
15335 0 : void *argp1 = 0 ;
15336 0 : int res1 = 0 ;
15337 : int res2 ;
15338 0 : char *buf2 = 0 ;
15339 0 : int alloc2 = 0 ;
15340 0 : PyObject * obj1 = 0 ;
15341 :
15342 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_unsupported_algorithm_set",&obj1)) SWIG_fail;
15343 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
15344 0 : if (!SWIG_IsOK(res1)) {
15345 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_unsupported_algorithm_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
15346 : }
15347 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
15348 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
15349 0 : if (!SWIG_IsOK(res2)) {
15350 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_unsupported_algorithm_set" "', argument " "2"" of type '" "char *""'");
15351 : }
15352 0 : arg2 = (char *)(buf2);
15353 0 : if (arg1->unsupported_algorithm) free((char*)arg1->unsupported_algorithm);
15354 0 : if (arg2) {
15355 0 : size_t size = strlen((const char *)(arg2)) + 1;
15356 0 : arg1->unsupported_algorithm = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
15357 : } else {
15358 0 : arg1->unsupported_algorithm = 0;
15359 : }
15360 0 : resultobj = SWIG_Py_Void();
15361 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15362 : return resultobj;
15363 : fail:
15364 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15365 : return NULL;
15366 : }
15367 :
15368 :
15369 8 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_unsupported_algorithm_get(PyObject *self, PyObject *args) {
15370 8 : PyObject *resultobj = 0;
15371 8 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
15372 8 : void *argp1 = 0 ;
15373 8 : int res1 = 0 ;
15374 8 : char *result = 0 ;
15375 :
15376 8 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15377 8 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
15378 8 : if (!SWIG_IsOK(res1)) {
15379 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_unsupported_algorithm_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
15380 : }
15381 8 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
15382 8 : result = (char *) ((arg1)->unsupported_algorithm);
15383 8 : resultobj = SWIG_FromCharPtr((const char *)result);
15384 8 : return resultobj;
15385 : fail:
15386 : return NULL;
15387 : }
15388 :
15389 :
15390 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_wrong_key_usage_set(PyObject *self, PyObject *args) {
15391 0 : PyObject *resultobj = 0;
15392 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
15393 : unsigned int arg2 ;
15394 0 : void *argp1 = 0 ;
15395 0 : int res1 = 0 ;
15396 : unsigned int val2 ;
15397 0 : int ecode2 = 0 ;
15398 0 : PyObject * obj1 = 0 ;
15399 :
15400 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_wrong_key_usage_set",&obj1)) SWIG_fail;
15401 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
15402 0 : if (!SWIG_IsOK(res1)) {
15403 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_wrong_key_usage_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
15404 : }
15405 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
15406 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
15407 0 : if (!SWIG_IsOK(ecode2)) {
15408 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_decrypt_result_wrong_key_usage_set" "', argument " "2"" of type '" "unsigned int""'");
15409 : }
15410 0 : arg2 = (unsigned int)(val2);
15411 0 : if (arg1) (arg1)->wrong_key_usage = arg2;
15412 0 : resultobj = SWIG_Py_Void();
15413 0 : return resultobj;
15414 : fail:
15415 : return NULL;
15416 : }
15417 :
15418 :
15419 16 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_wrong_key_usage_get(PyObject *self, PyObject *args) {
15420 16 : PyObject *resultobj = 0;
15421 16 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
15422 16 : void *argp1 = 0 ;
15423 16 : int res1 = 0 ;
15424 : unsigned int result;
15425 :
15426 16 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15427 16 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
15428 16 : if (!SWIG_IsOK(res1)) {
15429 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_wrong_key_usage_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
15430 : }
15431 16 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
15432 16 : result = (unsigned int) ((arg1)->wrong_key_usage);
15433 16 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
15434 16 : return resultobj;
15435 : fail:
15436 : return NULL;
15437 : }
15438 :
15439 :
15440 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result__unused_set(PyObject *self, PyObject *args) {
15441 0 : PyObject *resultobj = 0;
15442 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
15443 : int arg2 ;
15444 0 : void *argp1 = 0 ;
15445 0 : int res1 = 0 ;
15446 : int val2 ;
15447 0 : int ecode2 = 0 ;
15448 0 : PyObject * obj1 = 0 ;
15449 :
15450 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result__unused_set",&obj1)) SWIG_fail;
15451 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
15452 0 : if (!SWIG_IsOK(res1)) {
15453 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result__unused_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
15454 : }
15455 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
15456 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15457 0 : if (!SWIG_IsOK(ecode2)) {
15458 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_decrypt_result__unused_set" "', argument " "2"" of type '" "int""'");
15459 : }
15460 0 : arg2 = (int)(val2);
15461 0 : if (arg1) (arg1)->_unused = arg2;
15462 0 : resultobj = SWIG_Py_Void();
15463 0 : return resultobj;
15464 : fail:
15465 : return NULL;
15466 : }
15467 :
15468 :
15469 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result__unused_get(PyObject *self, PyObject *args) {
15470 0 : PyObject *resultobj = 0;
15471 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
15472 0 : void *argp1 = 0 ;
15473 0 : int res1 = 0 ;
15474 : int result;
15475 :
15476 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15477 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
15478 0 : if (!SWIG_IsOK(res1)) {
15479 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result__unused_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
15480 : }
15481 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
15482 0 : result = (int) ((arg1)->_unused);
15483 0 : resultobj = SWIG_From_int((int)(result));
15484 0 : return resultobj;
15485 : fail:
15486 : return NULL;
15487 : }
15488 :
15489 :
15490 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_recipients_set(PyObject *self, PyObject *args) {
15491 0 : PyObject *resultobj = 0;
15492 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
15493 0 : gpgme_recipient_t arg2 = (gpgme_recipient_t) 0 ;
15494 0 : void *argp1 = 0 ;
15495 0 : int res1 = 0 ;
15496 0 : void *argp2 = 0 ;
15497 0 : int res2 = 0 ;
15498 0 : PyObject * obj1 = 0 ;
15499 :
15500 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_recipients_set",&obj1)) SWIG_fail;
15501 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
15502 0 : if (!SWIG_IsOK(res1)) {
15503 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_recipients_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
15504 : }
15505 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
15506 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_recipient, SWIG_POINTER_DISOWN | 0 );
15507 0 : if (!SWIG_IsOK(res2)) {
15508 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_recipients_set" "', argument " "2"" of type '" "gpgme_recipient_t""'");
15509 : }
15510 0 : arg2 = (gpgme_recipient_t)(argp2);
15511 0 : if (arg1) (arg1)->recipients = arg2;
15512 0 : resultobj = SWIG_Py_Void();
15513 0 : return resultobj;
15514 : fail:
15515 : return NULL;
15516 : }
15517 :
15518 :
15519 16 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_recipients_get(PyObject *self, PyObject *args) {
15520 16 : PyObject *resultobj = 0;
15521 16 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
15522 16 : void *argp1 = 0 ;
15523 16 : int res1 = 0 ;
15524 : gpgme_recipient_t result;
15525 :
15526 16 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15527 16 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
15528 16 : if (!SWIG_IsOK(res1)) {
15529 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_recipients_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
15530 : }
15531 16 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
15532 16 : result = (gpgme_recipient_t) ((arg1)->recipients);
15533 : {
15534 : int i;
15535 16 : int size = 0;
15536 : gpgme_recipient_t curr;
15537 28 : for (curr = result; curr != NULL; curr = curr->next) {
15538 12 : size++;
15539 : }
15540 16 : resultobj = PyList_New(size);
15541 28 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
15542 12 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_recipient, 0 );
15543 12 : PyList_SetItem(resultobj, i, o);
15544 : }
15545 : }
15546 : return resultobj;
15547 : fail:
15548 : return NULL;
15549 : }
15550 :
15551 :
15552 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_file_name_set(PyObject *self, PyObject *args) {
15553 0 : PyObject *resultobj = 0;
15554 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
15555 0 : char *arg2 = (char *) 0 ;
15556 0 : void *argp1 = 0 ;
15557 0 : int res1 = 0 ;
15558 : int res2 ;
15559 0 : char *buf2 = 0 ;
15560 0 : int alloc2 = 0 ;
15561 0 : PyObject * obj1 = 0 ;
15562 :
15563 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_file_name_set",&obj1)) SWIG_fail;
15564 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
15565 0 : if (!SWIG_IsOK(res1)) {
15566 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_file_name_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
15567 : }
15568 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
15569 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
15570 0 : if (!SWIG_IsOK(res2)) {
15571 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_file_name_set" "', argument " "2"" of type '" "char *""'");
15572 : }
15573 0 : arg2 = (char *)(buf2);
15574 0 : if (arg1->file_name) free((char*)arg1->file_name);
15575 0 : if (arg2) {
15576 0 : size_t size = strlen((const char *)(arg2)) + 1;
15577 0 : arg1->file_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
15578 : } else {
15579 0 : arg1->file_name = 0;
15580 : }
15581 0 : resultobj = SWIG_Py_Void();
15582 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15583 : return resultobj;
15584 : fail:
15585 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15586 : return NULL;
15587 : }
15588 :
15589 :
15590 8 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_file_name_get(PyObject *self, PyObject *args) {
15591 8 : PyObject *resultobj = 0;
15592 8 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
15593 8 : void *argp1 = 0 ;
15594 8 : int res1 = 0 ;
15595 8 : char *result = 0 ;
15596 :
15597 8 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15598 8 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
15599 8 : if (!SWIG_IsOK(res1)) {
15600 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_file_name_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
15601 : }
15602 8 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
15603 8 : result = (char *) ((arg1)->file_name);
15604 8 : resultobj = SWIG_FromCharPtr((const char *)result);
15605 8 : return resultobj;
15606 : fail:
15607 : return NULL;
15608 : }
15609 :
15610 :
15611 0 : SWIGINTERN int _wrap_new__gpgme_op_decrypt_result(PyObject *self, PyObject *args) {
15612 0 : PyObject *resultobj = 0;
15613 0 : struct _gpgme_op_decrypt_result *result = 0 ;
15614 :
15615 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15616 0 : result = (struct _gpgme_op_decrypt_result *)calloc(1, sizeof(struct _gpgme_op_decrypt_result));
15617 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_decrypt_result, SWIG_BUILTIN_INIT | 0 );
15618 0 : return resultobj == Py_None ? -1 : 0;
15619 : fail:
15620 : return -1;
15621 : }
15622 :
15623 :
15624 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_decrypt_result(PyObject *self, PyObject *args) {
15625 0 : PyObject *resultobj = 0;
15626 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
15627 0 : void *argp1 = 0 ;
15628 0 : int res1 = 0 ;
15629 :
15630 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
15631 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, SWIG_POINTER_DISOWN | 0 );
15632 0 : if (!SWIG_IsOK(res1)) {
15633 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_decrypt_result" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
15634 : }
15635 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
15636 0 : free((char *) arg1);
15637 0 : resultobj = SWIG_Py_Void();
15638 0 : return resultobj;
15639 : fail:
15640 : return NULL;
15641 : }
15642 :
15643 :
15644 8 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_result(PyObject *self, PyObject *args) {
15645 8 : PyObject *resultobj = 0;
15646 8 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
15647 8 : void *argp1 = 0 ;
15648 8 : int res1 = 0 ;
15649 8 : PyObject * obj0 = 0 ;
15650 : gpgme_decrypt_result_t result;
15651 :
15652 8 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_decrypt_result",&obj0)) SWIG_fail;
15653 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
15654 8 : if (!SWIG_IsOK(res1)) {
15655 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
15656 : }
15657 8 : arg1 = (gpgme_ctx_t)(argp1);
15658 8 : result = (gpgme_decrypt_result_t)gpgme_op_decrypt_result(arg1);
15659 : {
15660 : PyObject *fragile;
15661 8 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_decrypt_result,
15662 : 0 );
15663 8 : resultobj = _pyme_wrap_result(fragile, "DecryptResult");
15664 8 : Py_DECREF(fragile);
15665 : }
15666 8 : return resultobj;
15667 : fail:
15668 : return NULL;
15669 : }
15670 :
15671 :
15672 0 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_start(PyObject *self, PyObject *args) {
15673 0 : PyObject *resultobj = 0;
15674 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
15675 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
15676 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
15677 0 : void *argp1 = 0 ;
15678 0 : int res1 = 0 ;
15679 0 : gpgme_data_t wrapper2 = NULL ;
15680 0 : PyObject *bytesio2 = NULL ;
15681 : Py_buffer view2 ;
15682 0 : int have_view2 = 0 ;
15683 0 : gpgme_data_t wrapper3 = NULL ;
15684 0 : PyObject *bytesio3 = NULL ;
15685 : Py_buffer view3 ;
15686 0 : int have_view3 = 0 ;
15687 0 : PyObject * obj0 = 0 ;
15688 0 : PyObject * obj1 = 0 ;
15689 0 : PyObject * obj2 = 0 ;
15690 : gpgme_error_t result;
15691 :
15692 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt_start",&obj0,&obj1,&obj2)) SWIG_fail;
15693 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
15694 0 : if (!SWIG_IsOK(res1)) {
15695 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
15696 : }
15697 0 : arg1 = (gpgme_ctx_t)(argp1);
15698 : {
15699 : /* If we create a temporary wrapper2 object, we will store it in
15700 : wrapperN, where N is 2. Here in this fragment, SWIG will
15701 : automatically append 2. */
15702 : memset(&view2, 0, sizeof view2);
15703 0 : if (obj1 == Py_None)
15704 0 : arg2 = NULL;
15705 : else {
15706 : PyObject *pypointer;
15707 0 : pypointer = _pyme_obj2gpgme_data_t(obj1, 2, &wrapper2,
15708 : &bytesio2, &view2);
15709 0 : if (pypointer == NULL)
15710 : return NULL;
15711 0 : have_view2 = !! view2.obj;
15712 :
15713 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
15714 :
15715 : // Following code is from swig's python.swg
15716 :
15717 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
15718 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15719 0 : Py_DECREF(pypointer);
15720 : return NULL;
15721 : }
15722 0 : Py_DECREF(pypointer);
15723 : }
15724 : }
15725 : {
15726 : /* If we create a temporary wrapper3 object, we will store it in
15727 : wrapperN, where N is 3. Here in this fragment, SWIG will
15728 : automatically append 3. */
15729 : memset(&view3, 0, sizeof view3);
15730 0 : if (obj2 == Py_None)
15731 0 : arg3 = NULL;
15732 : else {
15733 : PyObject *pypointer;
15734 0 : pypointer = _pyme_obj2gpgme_data_t(obj2, 3, &wrapper3,
15735 : &bytesio3, &view3);
15736 0 : if (pypointer == NULL)
15737 : return NULL;
15738 0 : have_view3 = !! view3.obj;
15739 :
15740 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
15741 :
15742 : // Following code is from swig's python.swg
15743 :
15744 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
15745 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15746 0 : Py_DECREF(pypointer);
15747 : return NULL;
15748 : }
15749 0 : Py_DECREF(pypointer);
15750 : }
15751 : }
15752 0 : result = gpgme_op_decrypt_start(arg1,arg2,arg3);
15753 : {
15754 0 : resultobj = PyLong_FromLong(result);
15755 : }
15756 : {
15757 : /* See whether we need to update the Python buffer. */
15758 0 : if (resultobj && wrapper2 && view2.buf)
15759 : {
15760 : int dirty;
15761 0 : char *new_data = NULL;
15762 : size_t new_size;
15763 :
15764 :
15765 0 : new_data = wrapper2->data.mem.buffer;
15766 0 : new_size = wrapper2->data.mem.length;
15767 0 : dirty = new_data != NULL;
15768 :
15769 :
15770 :
15771 :
15772 :
15773 :
15774 :
15775 0 : if (dirty)
15776 : {
15777 : /* The buffer is dirty. */
15778 0 : if (view2.readonly)
15779 : {
15780 0 : Py_XDECREF(resultobj);
15781 0 : resultobj = NULL;
15782 0 : PyErr_SetString(PyExc_ValueError,
15783 : "cannot update read-only buffer");
15784 : }
15785 :
15786 : /* See if we need to truncate the buffer. */
15787 0 : if (resultobj && view2.len != new_size)
15788 : {
15789 0 : if (bytesio2 == NULL)
15790 : {
15791 0 : Py_XDECREF(resultobj);
15792 0 : resultobj = NULL;
15793 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15794 : }
15795 : else
15796 : {
15797 : PyObject *retval;
15798 0 : PyBuffer_Release(&view2);
15799 : assert(view2.obj == NULL);
15800 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
15801 : "l", (long) new_size);
15802 0 : if (retval == NULL)
15803 : {
15804 0 : Py_XDECREF(resultobj);
15805 : resultobj = NULL;
15806 : }
15807 : else
15808 : {
15809 0 : Py_DECREF(retval);
15810 :
15811 0 : retval = PyObject_CallMethod(bytesio2,
15812 : "getbuffer", NULL);
15813 0 : if (retval == NULL
15814 0 : || PyObject_GetBuffer(retval, &view2,
15815 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15816 : {
15817 0 : Py_XDECREF(resultobj);
15818 : resultobj = NULL;
15819 : }
15820 :
15821 0 : Py_XDECREF(retval);
15822 :
15823 0 : if (resultobj && view2.len
15824 0 : != new_size)
15825 : {
15826 0 : Py_XDECREF(resultobj);
15827 0 : resultobj = NULL;
15828 0 : PyErr_Format(PyExc_ValueError,
15829 : "Expected buffer of length %zu, got %zi",
15830 : new_size,
15831 : view2.len);
15832 : }
15833 : }
15834 : }
15835 : }
15836 0 : if (resultobj)
15837 0 : memcpy(view2.buf, new_data, new_size);
15838 : }
15839 :
15840 :
15841 :
15842 : }
15843 :
15844 : /* Free the temporary wrapper, if any. */
15845 0 : if (wrapper2)
15846 0 : gpgme_data_release(wrapper2);
15847 0 : Py_XDECREF (bytesio2);
15848 0 : if (have_view2 && view2.buf)
15849 0 : PyBuffer_Release(&view2);
15850 : }
15851 : {
15852 : /* See whether we need to update the Python buffer. */
15853 0 : if (resultobj && wrapper3 && view3.buf)
15854 : {
15855 : int dirty;
15856 0 : char *new_data = NULL;
15857 : size_t new_size;
15858 :
15859 :
15860 0 : new_data = wrapper3->data.mem.buffer;
15861 0 : new_size = wrapper3->data.mem.length;
15862 0 : dirty = new_data != NULL;
15863 :
15864 :
15865 :
15866 :
15867 :
15868 :
15869 :
15870 0 : if (dirty)
15871 : {
15872 : /* The buffer is dirty. */
15873 0 : if (view3.readonly)
15874 : {
15875 0 : Py_XDECREF(resultobj);
15876 0 : resultobj = NULL;
15877 0 : PyErr_SetString(PyExc_ValueError,
15878 : "cannot update read-only buffer");
15879 : }
15880 :
15881 : /* See if we need to truncate the buffer. */
15882 0 : if (resultobj && view3.len != new_size)
15883 : {
15884 0 : if (bytesio3 == NULL)
15885 : {
15886 0 : Py_XDECREF(resultobj);
15887 0 : resultobj = NULL;
15888 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15889 : }
15890 : else
15891 : {
15892 : PyObject *retval;
15893 0 : PyBuffer_Release(&view3);
15894 : assert(view3.obj == NULL);
15895 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
15896 : "l", (long) new_size);
15897 0 : if (retval == NULL)
15898 : {
15899 0 : Py_XDECREF(resultobj);
15900 : resultobj = NULL;
15901 : }
15902 : else
15903 : {
15904 0 : Py_DECREF(retval);
15905 :
15906 0 : retval = PyObject_CallMethod(bytesio3,
15907 : "getbuffer", NULL);
15908 0 : if (retval == NULL
15909 0 : || PyObject_GetBuffer(retval, &view3,
15910 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15911 : {
15912 0 : Py_XDECREF(resultobj);
15913 : resultobj = NULL;
15914 : }
15915 :
15916 0 : Py_XDECREF(retval);
15917 :
15918 0 : if (resultobj && view3.len
15919 0 : != new_size)
15920 : {
15921 0 : Py_XDECREF(resultobj);
15922 0 : resultobj = NULL;
15923 0 : PyErr_Format(PyExc_ValueError,
15924 : "Expected buffer of length %zu, got %zi",
15925 : new_size,
15926 : view3.len);
15927 : }
15928 : }
15929 : }
15930 : }
15931 0 : if (resultobj)
15932 0 : memcpy(view3.buf, new_data, new_size);
15933 : }
15934 :
15935 :
15936 :
15937 : }
15938 :
15939 : /* Free the temporary wrapper, if any. */
15940 0 : if (wrapper3)
15941 0 : gpgme_data_release(wrapper3);
15942 0 : Py_XDECREF (bytesio3);
15943 0 : if (have_view3 && view3.buf)
15944 0 : PyBuffer_Release(&view3);
15945 : }
15946 0 : return resultobj;
15947 : fail:
15948 : {
15949 : /* See whether we need to update the Python buffer. */
15950 : if (resultobj && wrapper2 && view2.buf)
15951 : {
15952 : int dirty;
15953 : char *new_data = NULL;
15954 : size_t new_size;
15955 :
15956 :
15957 : new_data = wrapper2->data.mem.buffer;
15958 : new_size = wrapper2->data.mem.length;
15959 : dirty = new_data != NULL;
15960 :
15961 :
15962 :
15963 :
15964 :
15965 :
15966 :
15967 : if (dirty)
15968 : {
15969 : /* The buffer is dirty. */
15970 : if (view2.readonly)
15971 : {
15972 : Py_XDECREF(resultobj);
15973 : resultobj = NULL;
15974 : PyErr_SetString(PyExc_ValueError,
15975 : "cannot update read-only buffer");
15976 : }
15977 :
15978 : /* See if we need to truncate the buffer. */
15979 : if (resultobj && view2.len != new_size)
15980 : {
15981 : if (bytesio2 == NULL)
15982 : {
15983 : Py_XDECREF(resultobj);
15984 : resultobj = NULL;
15985 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15986 : }
15987 : else
15988 : {
15989 : PyObject *retval;
15990 : PyBuffer_Release(&view2);
15991 : assert(view2.obj == NULL);
15992 : retval = PyObject_CallMethod(bytesio2, "truncate",
15993 : "l", (long) new_size);
15994 : if (retval == NULL)
15995 : {
15996 : Py_XDECREF(resultobj);
15997 : resultobj = NULL;
15998 : }
15999 : else
16000 : {
16001 : Py_DECREF(retval);
16002 :
16003 : retval = PyObject_CallMethod(bytesio2,
16004 : "getbuffer", NULL);
16005 : if (retval == NULL
16006 : || PyObject_GetBuffer(retval, &view2,
16007 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16008 : {
16009 : Py_XDECREF(resultobj);
16010 : resultobj = NULL;
16011 : }
16012 :
16013 : Py_XDECREF(retval);
16014 :
16015 : if (resultobj && view2.len
16016 : != new_size)
16017 : {
16018 : Py_XDECREF(resultobj);
16019 : resultobj = NULL;
16020 : PyErr_Format(PyExc_ValueError,
16021 : "Expected buffer of length %zu, got %zi",
16022 : new_size,
16023 : view2.len);
16024 : }
16025 : }
16026 : }
16027 : }
16028 : if (resultobj)
16029 : memcpy(view2.buf, new_data, new_size);
16030 : }
16031 :
16032 :
16033 :
16034 : }
16035 :
16036 : /* Free the temporary wrapper, if any. */
16037 0 : if (wrapper2)
16038 0 : gpgme_data_release(wrapper2);
16039 0 : Py_XDECREF (bytesio2);
16040 : if (have_view2 && view2.buf)
16041 : PyBuffer_Release(&view2);
16042 : }
16043 : {
16044 : /* See whether we need to update the Python buffer. */
16045 : if (resultobj && wrapper3 && view3.buf)
16046 : {
16047 : int dirty;
16048 : char *new_data = NULL;
16049 : size_t new_size;
16050 :
16051 :
16052 : new_data = wrapper3->data.mem.buffer;
16053 : new_size = wrapper3->data.mem.length;
16054 : dirty = new_data != NULL;
16055 :
16056 :
16057 :
16058 :
16059 :
16060 :
16061 :
16062 : if (dirty)
16063 : {
16064 : /* The buffer is dirty. */
16065 : if (view3.readonly)
16066 : {
16067 : Py_XDECREF(resultobj);
16068 : resultobj = NULL;
16069 : PyErr_SetString(PyExc_ValueError,
16070 : "cannot update read-only buffer");
16071 : }
16072 :
16073 : /* See if we need to truncate the buffer. */
16074 : if (resultobj && view3.len != new_size)
16075 : {
16076 : if (bytesio3 == NULL)
16077 : {
16078 : Py_XDECREF(resultobj);
16079 : resultobj = NULL;
16080 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16081 : }
16082 : else
16083 : {
16084 : PyObject *retval;
16085 : PyBuffer_Release(&view3);
16086 : assert(view3.obj == NULL);
16087 : retval = PyObject_CallMethod(bytesio3, "truncate",
16088 : "l", (long) new_size);
16089 : if (retval == NULL)
16090 : {
16091 : Py_XDECREF(resultobj);
16092 : resultobj = NULL;
16093 : }
16094 : else
16095 : {
16096 : Py_DECREF(retval);
16097 :
16098 : retval = PyObject_CallMethod(bytesio3,
16099 : "getbuffer", NULL);
16100 : if (retval == NULL
16101 : || PyObject_GetBuffer(retval, &view3,
16102 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16103 : {
16104 : Py_XDECREF(resultobj);
16105 : resultobj = NULL;
16106 : }
16107 :
16108 : Py_XDECREF(retval);
16109 :
16110 : if (resultobj && view3.len
16111 : != new_size)
16112 : {
16113 : Py_XDECREF(resultobj);
16114 : resultobj = NULL;
16115 : PyErr_Format(PyExc_ValueError,
16116 : "Expected buffer of length %zu, got %zi",
16117 : new_size,
16118 : view3.len);
16119 : }
16120 : }
16121 : }
16122 : }
16123 : if (resultobj)
16124 : memcpy(view3.buf, new_data, new_size);
16125 : }
16126 :
16127 :
16128 :
16129 : }
16130 :
16131 : /* Free the temporary wrapper, if any. */
16132 0 : if (wrapper3)
16133 0 : gpgme_data_release(wrapper3);
16134 0 : Py_XDECREF (bytesio3);
16135 : if (have_view3 && view3.buf)
16136 : PyBuffer_Release(&view3);
16137 : }
16138 : return NULL;
16139 : }
16140 :
16141 :
16142 4 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt(PyObject *self, PyObject *args) {
16143 4 : PyObject *resultobj = 0;
16144 4 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
16145 4 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
16146 4 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
16147 4 : void *argp1 = 0 ;
16148 4 : int res1 = 0 ;
16149 4 : gpgme_data_t wrapper2 = NULL ;
16150 4 : PyObject *bytesio2 = NULL ;
16151 : Py_buffer view2 ;
16152 4 : int have_view2 = 0 ;
16153 4 : gpgme_data_t wrapper3 = NULL ;
16154 4 : PyObject *bytesio3 = NULL ;
16155 : Py_buffer view3 ;
16156 4 : int have_view3 = 0 ;
16157 4 : PyObject * obj0 = 0 ;
16158 4 : PyObject * obj1 = 0 ;
16159 4 : PyObject * obj2 = 0 ;
16160 : gpgme_error_t result;
16161 :
16162 4 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt",&obj0,&obj1,&obj2)) SWIG_fail;
16163 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
16164 4 : if (!SWIG_IsOK(res1)) {
16165 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt" "', argument " "1"" of type '" "gpgme_ctx_t""'");
16166 : }
16167 4 : arg1 = (gpgme_ctx_t)(argp1);
16168 : {
16169 : /* If we create a temporary wrapper2 object, we will store it in
16170 : wrapperN, where N is 2. Here in this fragment, SWIG will
16171 : automatically append 2. */
16172 : memset(&view2, 0, sizeof view2);
16173 4 : if (obj1 == Py_None)
16174 0 : arg2 = NULL;
16175 : else {
16176 : PyObject *pypointer;
16177 4 : pypointer = _pyme_obj2gpgme_data_t(obj1, 2, &wrapper2,
16178 : &bytesio2, &view2);
16179 4 : if (pypointer == NULL)
16180 : return NULL;
16181 4 : have_view2 = !! view2.obj;
16182 :
16183 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
16184 :
16185 : // Following code is from swig's python.swg
16186 :
16187 4 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
16188 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16189 0 : Py_DECREF(pypointer);
16190 : return NULL;
16191 : }
16192 4 : Py_DECREF(pypointer);
16193 : }
16194 : }
16195 : {
16196 : /* If we create a temporary wrapper3 object, we will store it in
16197 : wrapperN, where N is 3. Here in this fragment, SWIG will
16198 : automatically append 3. */
16199 : memset(&view3, 0, sizeof view3);
16200 4 : if (obj2 == Py_None)
16201 0 : arg3 = NULL;
16202 : else {
16203 : PyObject *pypointer;
16204 4 : pypointer = _pyme_obj2gpgme_data_t(obj2, 3, &wrapper3,
16205 : &bytesio3, &view3);
16206 4 : if (pypointer == NULL)
16207 : return NULL;
16208 4 : have_view3 = !! view3.obj;
16209 :
16210 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
16211 :
16212 : // Following code is from swig's python.swg
16213 :
16214 4 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
16215 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16216 0 : Py_DECREF(pypointer);
16217 : return NULL;
16218 : }
16219 4 : Py_DECREF(pypointer);
16220 : }
16221 : }
16222 4 : result = gpgme_op_decrypt(arg1,arg2,arg3);
16223 : {
16224 4 : resultobj = PyLong_FromLong(result);
16225 : }
16226 : {
16227 : /* See whether we need to update the Python buffer. */
16228 4 : if (resultobj && wrapper2 && view2.buf)
16229 : {
16230 : int dirty;
16231 0 : char *new_data = NULL;
16232 : size_t new_size;
16233 :
16234 :
16235 0 : new_data = wrapper2->data.mem.buffer;
16236 0 : new_size = wrapper2->data.mem.length;
16237 0 : dirty = new_data != NULL;
16238 :
16239 :
16240 :
16241 :
16242 :
16243 :
16244 :
16245 0 : if (dirty)
16246 : {
16247 : /* The buffer is dirty. */
16248 0 : if (view2.readonly)
16249 : {
16250 0 : Py_XDECREF(resultobj);
16251 0 : resultobj = NULL;
16252 0 : PyErr_SetString(PyExc_ValueError,
16253 : "cannot update read-only buffer");
16254 : }
16255 :
16256 : /* See if we need to truncate the buffer. */
16257 0 : if (resultobj && view2.len != new_size)
16258 : {
16259 0 : if (bytesio2 == NULL)
16260 : {
16261 0 : Py_XDECREF(resultobj);
16262 0 : resultobj = NULL;
16263 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16264 : }
16265 : else
16266 : {
16267 : PyObject *retval;
16268 0 : PyBuffer_Release(&view2);
16269 : assert(view2.obj == NULL);
16270 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
16271 : "l", (long) new_size);
16272 0 : if (retval == NULL)
16273 : {
16274 0 : Py_XDECREF(resultobj);
16275 : resultobj = NULL;
16276 : }
16277 : else
16278 : {
16279 0 : Py_DECREF(retval);
16280 :
16281 0 : retval = PyObject_CallMethod(bytesio2,
16282 : "getbuffer", NULL);
16283 0 : if (retval == NULL
16284 0 : || PyObject_GetBuffer(retval, &view2,
16285 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16286 : {
16287 0 : Py_XDECREF(resultobj);
16288 : resultobj = NULL;
16289 : }
16290 :
16291 0 : Py_XDECREF(retval);
16292 :
16293 0 : if (resultobj && view2.len
16294 0 : != new_size)
16295 : {
16296 0 : Py_XDECREF(resultobj);
16297 0 : resultobj = NULL;
16298 0 : PyErr_Format(PyExc_ValueError,
16299 : "Expected buffer of length %zu, got %zi",
16300 : new_size,
16301 : view2.len);
16302 : }
16303 : }
16304 : }
16305 : }
16306 0 : if (resultobj)
16307 0 : memcpy(view2.buf, new_data, new_size);
16308 : }
16309 :
16310 :
16311 :
16312 : }
16313 :
16314 : /* Free the temporary wrapper, if any. */
16315 4 : if (wrapper2)
16316 0 : gpgme_data_release(wrapper2);
16317 4 : Py_XDECREF (bytesio2);
16318 4 : if (have_view2 && view2.buf)
16319 0 : PyBuffer_Release(&view2);
16320 : }
16321 : {
16322 : /* See whether we need to update the Python buffer. */
16323 4 : if (resultobj && wrapper3 && view3.buf)
16324 : {
16325 : int dirty;
16326 0 : char *new_data = NULL;
16327 : size_t new_size;
16328 :
16329 :
16330 0 : new_data = wrapper3->data.mem.buffer;
16331 0 : new_size = wrapper3->data.mem.length;
16332 0 : dirty = new_data != NULL;
16333 :
16334 :
16335 :
16336 :
16337 :
16338 :
16339 :
16340 0 : if (dirty)
16341 : {
16342 : /* The buffer is dirty. */
16343 0 : if (view3.readonly)
16344 : {
16345 0 : Py_XDECREF(resultobj);
16346 0 : resultobj = NULL;
16347 0 : PyErr_SetString(PyExc_ValueError,
16348 : "cannot update read-only buffer");
16349 : }
16350 :
16351 : /* See if we need to truncate the buffer. */
16352 0 : if (resultobj && view3.len != new_size)
16353 : {
16354 0 : if (bytesio3 == NULL)
16355 : {
16356 0 : Py_XDECREF(resultobj);
16357 0 : resultobj = NULL;
16358 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16359 : }
16360 : else
16361 : {
16362 : PyObject *retval;
16363 0 : PyBuffer_Release(&view3);
16364 : assert(view3.obj == NULL);
16365 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
16366 : "l", (long) new_size);
16367 0 : if (retval == NULL)
16368 : {
16369 0 : Py_XDECREF(resultobj);
16370 : resultobj = NULL;
16371 : }
16372 : else
16373 : {
16374 0 : Py_DECREF(retval);
16375 :
16376 0 : retval = PyObject_CallMethod(bytesio3,
16377 : "getbuffer", NULL);
16378 0 : if (retval == NULL
16379 0 : || PyObject_GetBuffer(retval, &view3,
16380 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16381 : {
16382 0 : Py_XDECREF(resultobj);
16383 : resultobj = NULL;
16384 : }
16385 :
16386 0 : Py_XDECREF(retval);
16387 :
16388 0 : if (resultobj && view3.len
16389 0 : != new_size)
16390 : {
16391 0 : Py_XDECREF(resultobj);
16392 0 : resultobj = NULL;
16393 0 : PyErr_Format(PyExc_ValueError,
16394 : "Expected buffer of length %zu, got %zi",
16395 : new_size,
16396 : view3.len);
16397 : }
16398 : }
16399 : }
16400 : }
16401 0 : if (resultobj)
16402 0 : memcpy(view3.buf, new_data, new_size);
16403 : }
16404 :
16405 :
16406 :
16407 : }
16408 :
16409 : /* Free the temporary wrapper, if any. */
16410 4 : if (wrapper3)
16411 0 : gpgme_data_release(wrapper3);
16412 4 : Py_XDECREF (bytesio3);
16413 4 : if (have_view3 && view3.buf)
16414 0 : PyBuffer_Release(&view3);
16415 : }
16416 4 : return resultobj;
16417 : fail:
16418 : {
16419 : /* See whether we need to update the Python buffer. */
16420 : if (resultobj && wrapper2 && view2.buf)
16421 : {
16422 : int dirty;
16423 : char *new_data = NULL;
16424 : size_t new_size;
16425 :
16426 :
16427 : new_data = wrapper2->data.mem.buffer;
16428 : new_size = wrapper2->data.mem.length;
16429 : dirty = new_data != NULL;
16430 :
16431 :
16432 :
16433 :
16434 :
16435 :
16436 :
16437 : if (dirty)
16438 : {
16439 : /* The buffer is dirty. */
16440 : if (view2.readonly)
16441 : {
16442 : Py_XDECREF(resultobj);
16443 : resultobj = NULL;
16444 : PyErr_SetString(PyExc_ValueError,
16445 : "cannot update read-only buffer");
16446 : }
16447 :
16448 : /* See if we need to truncate the buffer. */
16449 : if (resultobj && view2.len != new_size)
16450 : {
16451 : if (bytesio2 == NULL)
16452 : {
16453 : Py_XDECREF(resultobj);
16454 : resultobj = NULL;
16455 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16456 : }
16457 : else
16458 : {
16459 : PyObject *retval;
16460 : PyBuffer_Release(&view2);
16461 : assert(view2.obj == NULL);
16462 : retval = PyObject_CallMethod(bytesio2, "truncate",
16463 : "l", (long) new_size);
16464 : if (retval == NULL)
16465 : {
16466 : Py_XDECREF(resultobj);
16467 : resultobj = NULL;
16468 : }
16469 : else
16470 : {
16471 : Py_DECREF(retval);
16472 :
16473 : retval = PyObject_CallMethod(bytesio2,
16474 : "getbuffer", NULL);
16475 : if (retval == NULL
16476 : || PyObject_GetBuffer(retval, &view2,
16477 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16478 : {
16479 : Py_XDECREF(resultobj);
16480 : resultobj = NULL;
16481 : }
16482 :
16483 : Py_XDECREF(retval);
16484 :
16485 : if (resultobj && view2.len
16486 : != new_size)
16487 : {
16488 : Py_XDECREF(resultobj);
16489 : resultobj = NULL;
16490 : PyErr_Format(PyExc_ValueError,
16491 : "Expected buffer of length %zu, got %zi",
16492 : new_size,
16493 : view2.len);
16494 : }
16495 : }
16496 : }
16497 : }
16498 : if (resultobj)
16499 : memcpy(view2.buf, new_data, new_size);
16500 : }
16501 :
16502 :
16503 :
16504 : }
16505 :
16506 : /* Free the temporary wrapper, if any. */
16507 0 : if (wrapper2)
16508 0 : gpgme_data_release(wrapper2);
16509 0 : Py_XDECREF (bytesio2);
16510 : if (have_view2 && view2.buf)
16511 : PyBuffer_Release(&view2);
16512 : }
16513 : {
16514 : /* See whether we need to update the Python buffer. */
16515 : if (resultobj && wrapper3 && view3.buf)
16516 : {
16517 : int dirty;
16518 : char *new_data = NULL;
16519 : size_t new_size;
16520 :
16521 :
16522 : new_data = wrapper3->data.mem.buffer;
16523 : new_size = wrapper3->data.mem.length;
16524 : dirty = new_data != NULL;
16525 :
16526 :
16527 :
16528 :
16529 :
16530 :
16531 :
16532 : if (dirty)
16533 : {
16534 : /* The buffer is dirty. */
16535 : if (view3.readonly)
16536 : {
16537 : Py_XDECREF(resultobj);
16538 : resultobj = NULL;
16539 : PyErr_SetString(PyExc_ValueError,
16540 : "cannot update read-only buffer");
16541 : }
16542 :
16543 : /* See if we need to truncate the buffer. */
16544 : if (resultobj && view3.len != new_size)
16545 : {
16546 : if (bytesio3 == NULL)
16547 : {
16548 : Py_XDECREF(resultobj);
16549 : resultobj = NULL;
16550 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16551 : }
16552 : else
16553 : {
16554 : PyObject *retval;
16555 : PyBuffer_Release(&view3);
16556 : assert(view3.obj == NULL);
16557 : retval = PyObject_CallMethod(bytesio3, "truncate",
16558 : "l", (long) new_size);
16559 : if (retval == NULL)
16560 : {
16561 : Py_XDECREF(resultobj);
16562 : resultobj = NULL;
16563 : }
16564 : else
16565 : {
16566 : Py_DECREF(retval);
16567 :
16568 : retval = PyObject_CallMethod(bytesio3,
16569 : "getbuffer", NULL);
16570 : if (retval == NULL
16571 : || PyObject_GetBuffer(retval, &view3,
16572 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16573 : {
16574 : Py_XDECREF(resultobj);
16575 : resultobj = NULL;
16576 : }
16577 :
16578 : Py_XDECREF(retval);
16579 :
16580 : if (resultobj && view3.len
16581 : != new_size)
16582 : {
16583 : Py_XDECREF(resultobj);
16584 : resultobj = NULL;
16585 : PyErr_Format(PyExc_ValueError,
16586 : "Expected buffer of length %zu, got %zi",
16587 : new_size,
16588 : view3.len);
16589 : }
16590 : }
16591 : }
16592 : }
16593 : if (resultobj)
16594 : memcpy(view3.buf, new_data, new_size);
16595 : }
16596 :
16597 :
16598 :
16599 : }
16600 :
16601 : /* Free the temporary wrapper, if any. */
16602 0 : if (wrapper3)
16603 0 : gpgme_data_release(wrapper3);
16604 0 : Py_XDECREF (bytesio3);
16605 : if (have_view3 && view3.buf)
16606 : PyBuffer_Release(&view3);
16607 : }
16608 : return NULL;
16609 : }
16610 :
16611 :
16612 0 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_verify_start(PyObject *self, PyObject *args) {
16613 0 : PyObject *resultobj = 0;
16614 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
16615 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
16616 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
16617 0 : void *argp1 = 0 ;
16618 0 : int res1 = 0 ;
16619 0 : gpgme_data_t wrapper2 = NULL ;
16620 0 : PyObject *bytesio2 = NULL ;
16621 : Py_buffer view2 ;
16622 0 : int have_view2 = 0 ;
16623 0 : gpgme_data_t wrapper3 = NULL ;
16624 0 : PyObject *bytesio3 = NULL ;
16625 : Py_buffer view3 ;
16626 0 : int have_view3 = 0 ;
16627 0 : PyObject * obj0 = 0 ;
16628 0 : PyObject * obj1 = 0 ;
16629 0 : PyObject * obj2 = 0 ;
16630 : gpgme_error_t result;
16631 :
16632 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt_verify_start",&obj0,&obj1,&obj2)) SWIG_fail;
16633 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
16634 0 : if (!SWIG_IsOK(res1)) {
16635 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_verify_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
16636 : }
16637 0 : arg1 = (gpgme_ctx_t)(argp1);
16638 : {
16639 : /* If we create a temporary wrapper2 object, we will store it in
16640 : wrapperN, where N is 2. Here in this fragment, SWIG will
16641 : automatically append 2. */
16642 : memset(&view2, 0, sizeof view2);
16643 0 : if (obj1 == Py_None)
16644 0 : arg2 = NULL;
16645 : else {
16646 : PyObject *pypointer;
16647 0 : pypointer = _pyme_obj2gpgme_data_t(obj1, 2, &wrapper2,
16648 : &bytesio2, &view2);
16649 0 : if (pypointer == NULL)
16650 : return NULL;
16651 0 : have_view2 = !! view2.obj;
16652 :
16653 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
16654 :
16655 : // Following code is from swig's python.swg
16656 :
16657 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
16658 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16659 0 : Py_DECREF(pypointer);
16660 : return NULL;
16661 : }
16662 0 : Py_DECREF(pypointer);
16663 : }
16664 : }
16665 : {
16666 : /* If we create a temporary wrapper3 object, we will store it in
16667 : wrapperN, where N is 3. Here in this fragment, SWIG will
16668 : automatically append 3. */
16669 : memset(&view3, 0, sizeof view3);
16670 0 : if (obj2 == Py_None)
16671 0 : arg3 = NULL;
16672 : else {
16673 : PyObject *pypointer;
16674 0 : pypointer = _pyme_obj2gpgme_data_t(obj2, 3, &wrapper3,
16675 : &bytesio3, &view3);
16676 0 : if (pypointer == NULL)
16677 : return NULL;
16678 0 : have_view3 = !! view3.obj;
16679 :
16680 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
16681 :
16682 : // Following code is from swig's python.swg
16683 :
16684 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
16685 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16686 0 : Py_DECREF(pypointer);
16687 : return NULL;
16688 : }
16689 0 : Py_DECREF(pypointer);
16690 : }
16691 : }
16692 0 : result = gpgme_op_decrypt_verify_start(arg1,arg2,arg3);
16693 : {
16694 0 : resultobj = PyLong_FromLong(result);
16695 : }
16696 : {
16697 : /* See whether we need to update the Python buffer. */
16698 0 : if (resultobj && wrapper2 && view2.buf)
16699 : {
16700 : int dirty;
16701 0 : char *new_data = NULL;
16702 : size_t new_size;
16703 :
16704 :
16705 0 : new_data = wrapper2->data.mem.buffer;
16706 0 : new_size = wrapper2->data.mem.length;
16707 0 : dirty = new_data != NULL;
16708 :
16709 :
16710 :
16711 :
16712 :
16713 :
16714 :
16715 0 : if (dirty)
16716 : {
16717 : /* The buffer is dirty. */
16718 0 : if (view2.readonly)
16719 : {
16720 0 : Py_XDECREF(resultobj);
16721 0 : resultobj = NULL;
16722 0 : PyErr_SetString(PyExc_ValueError,
16723 : "cannot update read-only buffer");
16724 : }
16725 :
16726 : /* See if we need to truncate the buffer. */
16727 0 : if (resultobj && view2.len != new_size)
16728 : {
16729 0 : if (bytesio2 == NULL)
16730 : {
16731 0 : Py_XDECREF(resultobj);
16732 0 : resultobj = NULL;
16733 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16734 : }
16735 : else
16736 : {
16737 : PyObject *retval;
16738 0 : PyBuffer_Release(&view2);
16739 : assert(view2.obj == NULL);
16740 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
16741 : "l", (long) new_size);
16742 0 : if (retval == NULL)
16743 : {
16744 0 : Py_XDECREF(resultobj);
16745 : resultobj = NULL;
16746 : }
16747 : else
16748 : {
16749 0 : Py_DECREF(retval);
16750 :
16751 0 : retval = PyObject_CallMethod(bytesio2,
16752 : "getbuffer", NULL);
16753 0 : if (retval == NULL
16754 0 : || PyObject_GetBuffer(retval, &view2,
16755 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16756 : {
16757 0 : Py_XDECREF(resultobj);
16758 : resultobj = NULL;
16759 : }
16760 :
16761 0 : Py_XDECREF(retval);
16762 :
16763 0 : if (resultobj && view2.len
16764 0 : != new_size)
16765 : {
16766 0 : Py_XDECREF(resultobj);
16767 0 : resultobj = NULL;
16768 0 : PyErr_Format(PyExc_ValueError,
16769 : "Expected buffer of length %zu, got %zi",
16770 : new_size,
16771 : view2.len);
16772 : }
16773 : }
16774 : }
16775 : }
16776 0 : if (resultobj)
16777 0 : memcpy(view2.buf, new_data, new_size);
16778 : }
16779 :
16780 :
16781 :
16782 : }
16783 :
16784 : /* Free the temporary wrapper, if any. */
16785 0 : if (wrapper2)
16786 0 : gpgme_data_release(wrapper2);
16787 0 : Py_XDECREF (bytesio2);
16788 0 : if (have_view2 && view2.buf)
16789 0 : PyBuffer_Release(&view2);
16790 : }
16791 : {
16792 : /* See whether we need to update the Python buffer. */
16793 0 : if (resultobj && wrapper3 && view3.buf)
16794 : {
16795 : int dirty;
16796 0 : char *new_data = NULL;
16797 : size_t new_size;
16798 :
16799 :
16800 0 : new_data = wrapper3->data.mem.buffer;
16801 0 : new_size = wrapper3->data.mem.length;
16802 0 : dirty = new_data != NULL;
16803 :
16804 :
16805 :
16806 :
16807 :
16808 :
16809 :
16810 0 : if (dirty)
16811 : {
16812 : /* The buffer is dirty. */
16813 0 : if (view3.readonly)
16814 : {
16815 0 : Py_XDECREF(resultobj);
16816 0 : resultobj = NULL;
16817 0 : PyErr_SetString(PyExc_ValueError,
16818 : "cannot update read-only buffer");
16819 : }
16820 :
16821 : /* See if we need to truncate the buffer. */
16822 0 : if (resultobj && view3.len != new_size)
16823 : {
16824 0 : if (bytesio3 == NULL)
16825 : {
16826 0 : Py_XDECREF(resultobj);
16827 0 : resultobj = NULL;
16828 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16829 : }
16830 : else
16831 : {
16832 : PyObject *retval;
16833 0 : PyBuffer_Release(&view3);
16834 : assert(view3.obj == NULL);
16835 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
16836 : "l", (long) new_size);
16837 0 : if (retval == NULL)
16838 : {
16839 0 : Py_XDECREF(resultobj);
16840 : resultobj = NULL;
16841 : }
16842 : else
16843 : {
16844 0 : Py_DECREF(retval);
16845 :
16846 0 : retval = PyObject_CallMethod(bytesio3,
16847 : "getbuffer", NULL);
16848 0 : if (retval == NULL
16849 0 : || PyObject_GetBuffer(retval, &view3,
16850 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16851 : {
16852 0 : Py_XDECREF(resultobj);
16853 : resultobj = NULL;
16854 : }
16855 :
16856 0 : Py_XDECREF(retval);
16857 :
16858 0 : if (resultobj && view3.len
16859 0 : != new_size)
16860 : {
16861 0 : Py_XDECREF(resultobj);
16862 0 : resultobj = NULL;
16863 0 : PyErr_Format(PyExc_ValueError,
16864 : "Expected buffer of length %zu, got %zi",
16865 : new_size,
16866 : view3.len);
16867 : }
16868 : }
16869 : }
16870 : }
16871 0 : if (resultobj)
16872 0 : memcpy(view3.buf, new_data, new_size);
16873 : }
16874 :
16875 :
16876 :
16877 : }
16878 :
16879 : /* Free the temporary wrapper, if any. */
16880 0 : if (wrapper3)
16881 0 : gpgme_data_release(wrapper3);
16882 0 : Py_XDECREF (bytesio3);
16883 0 : if (have_view3 && view3.buf)
16884 0 : PyBuffer_Release(&view3);
16885 : }
16886 0 : return resultobj;
16887 : fail:
16888 : {
16889 : /* See whether we need to update the Python buffer. */
16890 : if (resultobj && wrapper2 && view2.buf)
16891 : {
16892 : int dirty;
16893 : char *new_data = NULL;
16894 : size_t new_size;
16895 :
16896 :
16897 : new_data = wrapper2->data.mem.buffer;
16898 : new_size = wrapper2->data.mem.length;
16899 : dirty = new_data != NULL;
16900 :
16901 :
16902 :
16903 :
16904 :
16905 :
16906 :
16907 : if (dirty)
16908 : {
16909 : /* The buffer is dirty. */
16910 : if (view2.readonly)
16911 : {
16912 : Py_XDECREF(resultobj);
16913 : resultobj = NULL;
16914 : PyErr_SetString(PyExc_ValueError,
16915 : "cannot update read-only buffer");
16916 : }
16917 :
16918 : /* See if we need to truncate the buffer. */
16919 : if (resultobj && view2.len != new_size)
16920 : {
16921 : if (bytesio2 == NULL)
16922 : {
16923 : Py_XDECREF(resultobj);
16924 : resultobj = NULL;
16925 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16926 : }
16927 : else
16928 : {
16929 : PyObject *retval;
16930 : PyBuffer_Release(&view2);
16931 : assert(view2.obj == NULL);
16932 : retval = PyObject_CallMethod(bytesio2, "truncate",
16933 : "l", (long) new_size);
16934 : if (retval == NULL)
16935 : {
16936 : Py_XDECREF(resultobj);
16937 : resultobj = NULL;
16938 : }
16939 : else
16940 : {
16941 : Py_DECREF(retval);
16942 :
16943 : retval = PyObject_CallMethod(bytesio2,
16944 : "getbuffer", NULL);
16945 : if (retval == NULL
16946 : || PyObject_GetBuffer(retval, &view2,
16947 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16948 : {
16949 : Py_XDECREF(resultobj);
16950 : resultobj = NULL;
16951 : }
16952 :
16953 : Py_XDECREF(retval);
16954 :
16955 : if (resultobj && view2.len
16956 : != new_size)
16957 : {
16958 : Py_XDECREF(resultobj);
16959 : resultobj = NULL;
16960 : PyErr_Format(PyExc_ValueError,
16961 : "Expected buffer of length %zu, got %zi",
16962 : new_size,
16963 : view2.len);
16964 : }
16965 : }
16966 : }
16967 : }
16968 : if (resultobj)
16969 : memcpy(view2.buf, new_data, new_size);
16970 : }
16971 :
16972 :
16973 :
16974 : }
16975 :
16976 : /* Free the temporary wrapper, if any. */
16977 0 : if (wrapper2)
16978 0 : gpgme_data_release(wrapper2);
16979 0 : Py_XDECREF (bytesio2);
16980 : if (have_view2 && view2.buf)
16981 : PyBuffer_Release(&view2);
16982 : }
16983 : {
16984 : /* See whether we need to update the Python buffer. */
16985 : if (resultobj && wrapper3 && view3.buf)
16986 : {
16987 : int dirty;
16988 : char *new_data = NULL;
16989 : size_t new_size;
16990 :
16991 :
16992 : new_data = wrapper3->data.mem.buffer;
16993 : new_size = wrapper3->data.mem.length;
16994 : dirty = new_data != NULL;
16995 :
16996 :
16997 :
16998 :
16999 :
17000 :
17001 :
17002 : if (dirty)
17003 : {
17004 : /* The buffer is dirty. */
17005 : if (view3.readonly)
17006 : {
17007 : Py_XDECREF(resultobj);
17008 : resultobj = NULL;
17009 : PyErr_SetString(PyExc_ValueError,
17010 : "cannot update read-only buffer");
17011 : }
17012 :
17013 : /* See if we need to truncate the buffer. */
17014 : if (resultobj && view3.len != new_size)
17015 : {
17016 : if (bytesio3 == NULL)
17017 : {
17018 : Py_XDECREF(resultobj);
17019 : resultobj = NULL;
17020 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17021 : }
17022 : else
17023 : {
17024 : PyObject *retval;
17025 : PyBuffer_Release(&view3);
17026 : assert(view3.obj == NULL);
17027 : retval = PyObject_CallMethod(bytesio3, "truncate",
17028 : "l", (long) new_size);
17029 : if (retval == NULL)
17030 : {
17031 : Py_XDECREF(resultobj);
17032 : resultobj = NULL;
17033 : }
17034 : else
17035 : {
17036 : Py_DECREF(retval);
17037 :
17038 : retval = PyObject_CallMethod(bytesio3,
17039 : "getbuffer", NULL);
17040 : if (retval == NULL
17041 : || PyObject_GetBuffer(retval, &view3,
17042 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17043 : {
17044 : Py_XDECREF(resultobj);
17045 : resultobj = NULL;
17046 : }
17047 :
17048 : Py_XDECREF(retval);
17049 :
17050 : if (resultobj && view3.len
17051 : != new_size)
17052 : {
17053 : Py_XDECREF(resultobj);
17054 : resultobj = NULL;
17055 : PyErr_Format(PyExc_ValueError,
17056 : "Expected buffer of length %zu, got %zi",
17057 : new_size,
17058 : view3.len);
17059 : }
17060 : }
17061 : }
17062 : }
17063 : if (resultobj)
17064 : memcpy(view3.buf, new_data, new_size);
17065 : }
17066 :
17067 :
17068 :
17069 : }
17070 :
17071 : /* Free the temporary wrapper, if any. */
17072 0 : if (wrapper3)
17073 0 : gpgme_data_release(wrapper3);
17074 0 : Py_XDECREF (bytesio3);
17075 : if (have_view3 && view3.buf)
17076 : PyBuffer_Release(&view3);
17077 : }
17078 : return NULL;
17079 : }
17080 :
17081 :
17082 6 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_verify(PyObject *self, PyObject *args) {
17083 6 : PyObject *resultobj = 0;
17084 6 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
17085 6 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
17086 6 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
17087 6 : void *argp1 = 0 ;
17088 6 : int res1 = 0 ;
17089 6 : gpgme_data_t wrapper2 = NULL ;
17090 6 : PyObject *bytesio2 = NULL ;
17091 : Py_buffer view2 ;
17092 6 : int have_view2 = 0 ;
17093 6 : gpgme_data_t wrapper3 = NULL ;
17094 6 : PyObject *bytesio3 = NULL ;
17095 : Py_buffer view3 ;
17096 6 : int have_view3 = 0 ;
17097 6 : PyObject * obj0 = 0 ;
17098 6 : PyObject * obj1 = 0 ;
17099 6 : PyObject * obj2 = 0 ;
17100 : gpgme_error_t result;
17101 :
17102 6 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt_verify",&obj0,&obj1,&obj2)) SWIG_fail;
17103 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
17104 6 : if (!SWIG_IsOK(res1)) {
17105 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_verify" "', argument " "1"" of type '" "gpgme_ctx_t""'");
17106 : }
17107 6 : arg1 = (gpgme_ctx_t)(argp1);
17108 : {
17109 : /* If we create a temporary wrapper2 object, we will store it in
17110 : wrapperN, where N is 2. Here in this fragment, SWIG will
17111 : automatically append 2. */
17112 : memset(&view2, 0, sizeof view2);
17113 6 : if (obj1 == Py_None)
17114 0 : arg2 = NULL;
17115 : else {
17116 : PyObject *pypointer;
17117 6 : pypointer = _pyme_obj2gpgme_data_t(obj1, 2, &wrapper2,
17118 : &bytesio2, &view2);
17119 6 : if (pypointer == NULL)
17120 : return NULL;
17121 6 : have_view2 = !! view2.obj;
17122 :
17123 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
17124 :
17125 : // Following code is from swig's python.swg
17126 :
17127 6 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
17128 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
17129 0 : Py_DECREF(pypointer);
17130 : return NULL;
17131 : }
17132 6 : Py_DECREF(pypointer);
17133 : }
17134 : }
17135 : {
17136 : /* If we create a temporary wrapper3 object, we will store it in
17137 : wrapperN, where N is 3. Here in this fragment, SWIG will
17138 : automatically append 3. */
17139 : memset(&view3, 0, sizeof view3);
17140 6 : if (obj2 == Py_None)
17141 0 : arg3 = NULL;
17142 : else {
17143 : PyObject *pypointer;
17144 6 : pypointer = _pyme_obj2gpgme_data_t(obj2, 3, &wrapper3,
17145 : &bytesio3, &view3);
17146 6 : if (pypointer == NULL)
17147 : return NULL;
17148 6 : have_view3 = !! view3.obj;
17149 :
17150 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
17151 :
17152 : // Following code is from swig's python.swg
17153 :
17154 6 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
17155 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
17156 0 : Py_DECREF(pypointer);
17157 : return NULL;
17158 : }
17159 6 : Py_DECREF(pypointer);
17160 : }
17161 : }
17162 6 : result = gpgme_op_decrypt_verify(arg1,arg2,arg3);
17163 : {
17164 6 : resultobj = PyLong_FromLong(result);
17165 : }
17166 : {
17167 : /* See whether we need to update the Python buffer. */
17168 6 : if (resultobj && wrapper2 && view2.buf)
17169 : {
17170 : int dirty;
17171 2 : char *new_data = NULL;
17172 : size_t new_size;
17173 :
17174 :
17175 2 : new_data = wrapper2->data.mem.buffer;
17176 2 : new_size = wrapper2->data.mem.length;
17177 2 : dirty = new_data != NULL;
17178 :
17179 :
17180 :
17181 :
17182 :
17183 :
17184 :
17185 2 : if (dirty)
17186 : {
17187 : /* The buffer is dirty. */
17188 0 : if (view2.readonly)
17189 : {
17190 0 : Py_XDECREF(resultobj);
17191 0 : resultobj = NULL;
17192 0 : PyErr_SetString(PyExc_ValueError,
17193 : "cannot update read-only buffer");
17194 : }
17195 :
17196 : /* See if we need to truncate the buffer. */
17197 0 : if (resultobj && view2.len != new_size)
17198 : {
17199 0 : if (bytesio2 == NULL)
17200 : {
17201 0 : Py_XDECREF(resultobj);
17202 0 : resultobj = NULL;
17203 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17204 : }
17205 : else
17206 : {
17207 : PyObject *retval;
17208 0 : PyBuffer_Release(&view2);
17209 : assert(view2.obj == NULL);
17210 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
17211 : "l", (long) new_size);
17212 0 : if (retval == NULL)
17213 : {
17214 0 : Py_XDECREF(resultobj);
17215 : resultobj = NULL;
17216 : }
17217 : else
17218 : {
17219 0 : Py_DECREF(retval);
17220 :
17221 0 : retval = PyObject_CallMethod(bytesio2,
17222 : "getbuffer", NULL);
17223 0 : if (retval == NULL
17224 0 : || PyObject_GetBuffer(retval, &view2,
17225 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17226 : {
17227 0 : Py_XDECREF(resultobj);
17228 : resultobj = NULL;
17229 : }
17230 :
17231 0 : Py_XDECREF(retval);
17232 :
17233 0 : if (resultobj && view2.len
17234 0 : != new_size)
17235 : {
17236 0 : Py_XDECREF(resultobj);
17237 0 : resultobj = NULL;
17238 0 : PyErr_Format(PyExc_ValueError,
17239 : "Expected buffer of length %zu, got %zi",
17240 : new_size,
17241 : view2.len);
17242 : }
17243 : }
17244 : }
17245 : }
17246 0 : if (resultobj)
17247 0 : memcpy(view2.buf, new_data, new_size);
17248 : }
17249 :
17250 :
17251 :
17252 : }
17253 :
17254 : /* Free the temporary wrapper, if any. */
17255 6 : if (wrapper2)
17256 5 : gpgme_data_release(wrapper2);
17257 6 : Py_XDECREF (bytesio2);
17258 6 : if (have_view2 && view2.buf)
17259 2 : PyBuffer_Release(&view2);
17260 : }
17261 : {
17262 : /* See whether we need to update the Python buffer. */
17263 6 : if (resultobj && wrapper3 && view3.buf)
17264 : {
17265 : int dirty;
17266 0 : char *new_data = NULL;
17267 : size_t new_size;
17268 :
17269 :
17270 0 : new_data = wrapper3->data.mem.buffer;
17271 0 : new_size = wrapper3->data.mem.length;
17272 0 : dirty = new_data != NULL;
17273 :
17274 :
17275 :
17276 :
17277 :
17278 :
17279 :
17280 0 : if (dirty)
17281 : {
17282 : /* The buffer is dirty. */
17283 0 : if (view3.readonly)
17284 : {
17285 0 : Py_XDECREF(resultobj);
17286 0 : resultobj = NULL;
17287 0 : PyErr_SetString(PyExc_ValueError,
17288 : "cannot update read-only buffer");
17289 : }
17290 :
17291 : /* See if we need to truncate the buffer. */
17292 0 : if (resultobj && view3.len != new_size)
17293 : {
17294 0 : if (bytesio3 == NULL)
17295 : {
17296 0 : Py_XDECREF(resultobj);
17297 0 : resultobj = NULL;
17298 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17299 : }
17300 : else
17301 : {
17302 : PyObject *retval;
17303 0 : PyBuffer_Release(&view3);
17304 : assert(view3.obj == NULL);
17305 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
17306 : "l", (long) new_size);
17307 0 : if (retval == NULL)
17308 : {
17309 0 : Py_XDECREF(resultobj);
17310 : resultobj = NULL;
17311 : }
17312 : else
17313 : {
17314 0 : Py_DECREF(retval);
17315 :
17316 0 : retval = PyObject_CallMethod(bytesio3,
17317 : "getbuffer", NULL);
17318 0 : if (retval == NULL
17319 0 : || PyObject_GetBuffer(retval, &view3,
17320 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17321 : {
17322 0 : Py_XDECREF(resultobj);
17323 : resultobj = NULL;
17324 : }
17325 :
17326 0 : Py_XDECREF(retval);
17327 :
17328 0 : if (resultobj && view3.len
17329 0 : != new_size)
17330 : {
17331 0 : Py_XDECREF(resultobj);
17332 0 : resultobj = NULL;
17333 0 : PyErr_Format(PyExc_ValueError,
17334 : "Expected buffer of length %zu, got %zi",
17335 : new_size,
17336 : view3.len);
17337 : }
17338 : }
17339 : }
17340 : }
17341 0 : if (resultobj)
17342 0 : memcpy(view3.buf, new_data, new_size);
17343 : }
17344 :
17345 :
17346 :
17347 : }
17348 :
17349 : /* Free the temporary wrapper, if any. */
17350 6 : if (wrapper3)
17351 0 : gpgme_data_release(wrapper3);
17352 6 : Py_XDECREF (bytesio3);
17353 6 : if (have_view3 && view3.buf)
17354 0 : PyBuffer_Release(&view3);
17355 : }
17356 6 : return resultobj;
17357 : fail:
17358 : {
17359 : /* See whether we need to update the Python buffer. */
17360 : if (resultobj && wrapper2 && view2.buf)
17361 : {
17362 : int dirty;
17363 : char *new_data = NULL;
17364 : size_t new_size;
17365 :
17366 :
17367 : new_data = wrapper2->data.mem.buffer;
17368 : new_size = wrapper2->data.mem.length;
17369 : dirty = new_data != NULL;
17370 :
17371 :
17372 :
17373 :
17374 :
17375 :
17376 :
17377 : if (dirty)
17378 : {
17379 : /* The buffer is dirty. */
17380 : if (view2.readonly)
17381 : {
17382 : Py_XDECREF(resultobj);
17383 : resultobj = NULL;
17384 : PyErr_SetString(PyExc_ValueError,
17385 : "cannot update read-only buffer");
17386 : }
17387 :
17388 : /* See if we need to truncate the buffer. */
17389 : if (resultobj && view2.len != new_size)
17390 : {
17391 : if (bytesio2 == NULL)
17392 : {
17393 : Py_XDECREF(resultobj);
17394 : resultobj = NULL;
17395 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17396 : }
17397 : else
17398 : {
17399 : PyObject *retval;
17400 : PyBuffer_Release(&view2);
17401 : assert(view2.obj == NULL);
17402 : retval = PyObject_CallMethod(bytesio2, "truncate",
17403 : "l", (long) new_size);
17404 : if (retval == NULL)
17405 : {
17406 : Py_XDECREF(resultobj);
17407 : resultobj = NULL;
17408 : }
17409 : else
17410 : {
17411 : Py_DECREF(retval);
17412 :
17413 : retval = PyObject_CallMethod(bytesio2,
17414 : "getbuffer", NULL);
17415 : if (retval == NULL
17416 : || PyObject_GetBuffer(retval, &view2,
17417 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17418 : {
17419 : Py_XDECREF(resultobj);
17420 : resultobj = NULL;
17421 : }
17422 :
17423 : Py_XDECREF(retval);
17424 :
17425 : if (resultobj && view2.len
17426 : != new_size)
17427 : {
17428 : Py_XDECREF(resultobj);
17429 : resultobj = NULL;
17430 : PyErr_Format(PyExc_ValueError,
17431 : "Expected buffer of length %zu, got %zi",
17432 : new_size,
17433 : view2.len);
17434 : }
17435 : }
17436 : }
17437 : }
17438 : if (resultobj)
17439 : memcpy(view2.buf, new_data, new_size);
17440 : }
17441 :
17442 :
17443 :
17444 : }
17445 :
17446 : /* Free the temporary wrapper, if any. */
17447 0 : if (wrapper2)
17448 0 : gpgme_data_release(wrapper2);
17449 0 : Py_XDECREF (bytesio2);
17450 : if (have_view2 && view2.buf)
17451 : PyBuffer_Release(&view2);
17452 : }
17453 : {
17454 : /* See whether we need to update the Python buffer. */
17455 : if (resultobj && wrapper3 && view3.buf)
17456 : {
17457 : int dirty;
17458 : char *new_data = NULL;
17459 : size_t new_size;
17460 :
17461 :
17462 : new_data = wrapper3->data.mem.buffer;
17463 : new_size = wrapper3->data.mem.length;
17464 : dirty = new_data != NULL;
17465 :
17466 :
17467 :
17468 :
17469 :
17470 :
17471 :
17472 : if (dirty)
17473 : {
17474 : /* The buffer is dirty. */
17475 : if (view3.readonly)
17476 : {
17477 : Py_XDECREF(resultobj);
17478 : resultobj = NULL;
17479 : PyErr_SetString(PyExc_ValueError,
17480 : "cannot update read-only buffer");
17481 : }
17482 :
17483 : /* See if we need to truncate the buffer. */
17484 : if (resultobj && view3.len != new_size)
17485 : {
17486 : if (bytesio3 == NULL)
17487 : {
17488 : Py_XDECREF(resultobj);
17489 : resultobj = NULL;
17490 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17491 : }
17492 : else
17493 : {
17494 : PyObject *retval;
17495 : PyBuffer_Release(&view3);
17496 : assert(view3.obj == NULL);
17497 : retval = PyObject_CallMethod(bytesio3, "truncate",
17498 : "l", (long) new_size);
17499 : if (retval == NULL)
17500 : {
17501 : Py_XDECREF(resultobj);
17502 : resultobj = NULL;
17503 : }
17504 : else
17505 : {
17506 : Py_DECREF(retval);
17507 :
17508 : retval = PyObject_CallMethod(bytesio3,
17509 : "getbuffer", NULL);
17510 : if (retval == NULL
17511 : || PyObject_GetBuffer(retval, &view3,
17512 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17513 : {
17514 : Py_XDECREF(resultobj);
17515 : resultobj = NULL;
17516 : }
17517 :
17518 : Py_XDECREF(retval);
17519 :
17520 : if (resultobj && view3.len
17521 : != new_size)
17522 : {
17523 : Py_XDECREF(resultobj);
17524 : resultobj = NULL;
17525 : PyErr_Format(PyExc_ValueError,
17526 : "Expected buffer of length %zu, got %zi",
17527 : new_size,
17528 : view3.len);
17529 : }
17530 : }
17531 : }
17532 : }
17533 : if (resultobj)
17534 : memcpy(view3.buf, new_data, new_size);
17535 : }
17536 :
17537 :
17538 :
17539 : }
17540 :
17541 : /* Free the temporary wrapper, if any. */
17542 0 : if (wrapper3)
17543 0 : gpgme_data_release(wrapper3);
17544 0 : Py_XDECREF (bytesio3);
17545 : if (have_view3 && view3.buf)
17546 : PyBuffer_Release(&view3);
17547 : }
17548 : return NULL;
17549 : }
17550 :
17551 :
17552 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_type_set(PyObject *self, PyObject *args) {
17553 0 : PyObject *resultobj = 0;
17554 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17555 : gpgme_sig_mode_t arg2 ;
17556 0 : void *argp1 = 0 ;
17557 0 : int res1 = 0 ;
17558 : int val2 ;
17559 0 : int ecode2 = 0 ;
17560 0 : PyObject * obj1 = 0 ;
17561 :
17562 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_type_set",&obj1)) SWIG_fail;
17563 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17564 0 : if (!SWIG_IsOK(res1)) {
17565 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_type_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17566 : }
17567 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
17568 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
17569 0 : if (!SWIG_IsOK(ecode2)) {
17570 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_type_set" "', argument " "2"" of type '" "gpgme_sig_mode_t""'");
17571 : }
17572 0 : arg2 = (gpgme_sig_mode_t)(val2);
17573 0 : if (arg1) (arg1)->type = arg2;
17574 0 : resultobj = SWIG_Py_Void();
17575 0 : return resultobj;
17576 : fail:
17577 : return NULL;
17578 : }
17579 :
17580 :
17581 23 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_type_get(PyObject *self, PyObject *args) {
17582 23 : PyObject *resultobj = 0;
17583 23 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17584 23 : void *argp1 = 0 ;
17585 23 : int res1 = 0 ;
17586 : gpgme_sig_mode_t result;
17587 :
17588 23 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
17589 23 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17590 23 : if (!SWIG_IsOK(res1)) {
17591 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_type_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17592 : }
17593 23 : arg1 = (struct _gpgme_new_signature *)(argp1);
17594 23 : result = (gpgme_sig_mode_t) ((arg1)->type);
17595 46 : resultobj = SWIG_From_int((int)(result));
17596 23 : return resultobj;
17597 : fail:
17598 : return NULL;
17599 : }
17600 :
17601 :
17602 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_pubkey_algo_set(PyObject *self, PyObject *args) {
17603 0 : PyObject *resultobj = 0;
17604 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17605 : gpgme_pubkey_algo_t arg2 ;
17606 0 : void *argp1 = 0 ;
17607 0 : int res1 = 0 ;
17608 : int val2 ;
17609 0 : int ecode2 = 0 ;
17610 0 : PyObject * obj1 = 0 ;
17611 :
17612 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_pubkey_algo_set",&obj1)) SWIG_fail;
17613 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17614 0 : if (!SWIG_IsOK(res1)) {
17615 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17616 : }
17617 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
17618 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
17619 0 : if (!SWIG_IsOK(ecode2)) {
17620 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
17621 : }
17622 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
17623 0 : if (arg1) (arg1)->pubkey_algo = arg2;
17624 0 : resultobj = SWIG_Py_Void();
17625 0 : return resultobj;
17626 : fail:
17627 : return NULL;
17628 : }
17629 :
17630 :
17631 23 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_pubkey_algo_get(PyObject *self, PyObject *args) {
17632 23 : PyObject *resultobj = 0;
17633 23 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17634 23 : void *argp1 = 0 ;
17635 23 : int res1 = 0 ;
17636 : gpgme_pubkey_algo_t result;
17637 :
17638 23 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
17639 23 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17640 23 : if (!SWIG_IsOK(res1)) {
17641 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17642 : }
17643 23 : arg1 = (struct _gpgme_new_signature *)(argp1);
17644 23 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
17645 46 : resultobj = SWIG_From_int((int)(result));
17646 23 : return resultobj;
17647 : fail:
17648 : return NULL;
17649 : }
17650 :
17651 :
17652 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_hash_algo_set(PyObject *self, PyObject *args) {
17653 0 : PyObject *resultobj = 0;
17654 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17655 : gpgme_hash_algo_t arg2 ;
17656 0 : void *argp1 = 0 ;
17657 0 : int res1 = 0 ;
17658 : int val2 ;
17659 0 : int ecode2 = 0 ;
17660 0 : PyObject * obj1 = 0 ;
17661 :
17662 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_hash_algo_set",&obj1)) SWIG_fail;
17663 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17664 0 : if (!SWIG_IsOK(res1)) {
17665 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_hash_algo_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17666 : }
17667 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
17668 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
17669 0 : if (!SWIG_IsOK(ecode2)) {
17670 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_hash_algo_set" "', argument " "2"" of type '" "gpgme_hash_algo_t""'");
17671 : }
17672 0 : arg2 = (gpgme_hash_algo_t)(val2);
17673 0 : if (arg1) (arg1)->hash_algo = arg2;
17674 0 : resultobj = SWIG_Py_Void();
17675 0 : return resultobj;
17676 : fail:
17677 : return NULL;
17678 : }
17679 :
17680 :
17681 23 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_hash_algo_get(PyObject *self, PyObject *args) {
17682 23 : PyObject *resultobj = 0;
17683 23 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17684 23 : void *argp1 = 0 ;
17685 23 : int res1 = 0 ;
17686 : gpgme_hash_algo_t result;
17687 :
17688 23 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
17689 23 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17690 23 : if (!SWIG_IsOK(res1)) {
17691 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_hash_algo_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17692 : }
17693 23 : arg1 = (struct _gpgme_new_signature *)(argp1);
17694 23 : result = (gpgme_hash_algo_t) ((arg1)->hash_algo);
17695 46 : resultobj = SWIG_From_int((int)(result));
17696 23 : return resultobj;
17697 : fail:
17698 : return NULL;
17699 : }
17700 :
17701 :
17702 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature__obsolete_class_set(PyObject *self, PyObject *args) {
17703 0 : PyObject *resultobj = 0;
17704 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17705 : unsigned long arg2 ;
17706 0 : void *argp1 = 0 ;
17707 0 : int res1 = 0 ;
17708 : unsigned long val2 ;
17709 0 : int ecode2 = 0 ;
17710 0 : PyObject * obj1 = 0 ;
17711 :
17712 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature__obsolete_class_set",&obj1)) SWIG_fail;
17713 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17714 0 : if (!SWIG_IsOK(res1)) {
17715 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature__obsolete_class_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17716 : }
17717 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
17718 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17719 0 : if (!SWIG_IsOK(ecode2)) {
17720 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature__obsolete_class_set" "', argument " "2"" of type '" "unsigned long""'");
17721 : }
17722 0 : arg2 = (unsigned long)(val2);
17723 0 : if (arg1) (arg1)->_obsolete_class = arg2;
17724 0 : resultobj = SWIG_Py_Void();
17725 0 : return resultobj;
17726 : fail:
17727 : return NULL;
17728 : }
17729 :
17730 :
17731 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature__obsolete_class_get(PyObject *self, PyObject *args) {
17732 0 : PyObject *resultobj = 0;
17733 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17734 0 : void *argp1 = 0 ;
17735 0 : int res1 = 0 ;
17736 : unsigned long result;
17737 :
17738 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
17739 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17740 0 : if (!SWIG_IsOK(res1)) {
17741 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature__obsolete_class_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17742 : }
17743 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
17744 0 : result = (unsigned long) ((arg1)->_obsolete_class);
17745 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17746 0 : return resultobj;
17747 : fail:
17748 : return NULL;
17749 : }
17750 :
17751 :
17752 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_timestamp_set(PyObject *self, PyObject *args) {
17753 0 : PyObject *resultobj = 0;
17754 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17755 : long arg2 ;
17756 0 : void *argp1 = 0 ;
17757 0 : int res1 = 0 ;
17758 : long val2 ;
17759 0 : int ecode2 = 0 ;
17760 0 : PyObject * obj1 = 0 ;
17761 :
17762 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_timestamp_set",&obj1)) SWIG_fail;
17763 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17764 0 : if (!SWIG_IsOK(res1)) {
17765 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17766 : }
17767 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
17768 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
17769 0 : if (!SWIG_IsOK(ecode2)) {
17770 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_timestamp_set" "', argument " "2"" of type '" "long""'");
17771 : }
17772 0 : arg2 = (long)(val2);
17773 0 : if (arg1) (arg1)->timestamp = arg2;
17774 0 : resultobj = SWIG_Py_Void();
17775 0 : return resultobj;
17776 : fail:
17777 : return NULL;
17778 : }
17779 :
17780 :
17781 23 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_timestamp_get(PyObject *self, PyObject *args) {
17782 23 : PyObject *resultobj = 0;
17783 23 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17784 23 : void *argp1 = 0 ;
17785 23 : int res1 = 0 ;
17786 : long result;
17787 :
17788 23 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
17789 23 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17790 23 : if (!SWIG_IsOK(res1)) {
17791 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17792 : }
17793 23 : arg1 = (struct _gpgme_new_signature *)(argp1);
17794 23 : result = (long) ((arg1)->timestamp);
17795 23 : resultobj = SWIG_From_long((long)(result));
17796 23 : return resultobj;
17797 : fail:
17798 : return NULL;
17799 : }
17800 :
17801 :
17802 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_fpr_set(PyObject *self, PyObject *args) {
17803 0 : PyObject *resultobj = 0;
17804 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17805 0 : char *arg2 = (char *) 0 ;
17806 0 : void *argp1 = 0 ;
17807 0 : int res1 = 0 ;
17808 : int res2 ;
17809 0 : char *buf2 = 0 ;
17810 0 : int alloc2 = 0 ;
17811 0 : PyObject * obj1 = 0 ;
17812 :
17813 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_fpr_set",&obj1)) SWIG_fail;
17814 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17815 0 : if (!SWIG_IsOK(res1)) {
17816 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_fpr_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17817 : }
17818 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
17819 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17820 0 : if (!SWIG_IsOK(res2)) {
17821 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_new_signature_fpr_set" "', argument " "2"" of type '" "char *""'");
17822 : }
17823 0 : arg2 = (char *)(buf2);
17824 0 : if (arg1->fpr) free((char*)arg1->fpr);
17825 0 : if (arg2) {
17826 0 : size_t size = strlen((const char *)(arg2)) + 1;
17827 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
17828 : } else {
17829 0 : arg1->fpr = 0;
17830 : }
17831 0 : resultobj = SWIG_Py_Void();
17832 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17833 : return resultobj;
17834 : fail:
17835 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17836 : return NULL;
17837 : }
17838 :
17839 :
17840 23 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_fpr_get(PyObject *self, PyObject *args) {
17841 23 : PyObject *resultobj = 0;
17842 23 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17843 23 : void *argp1 = 0 ;
17844 23 : int res1 = 0 ;
17845 23 : char *result = 0 ;
17846 :
17847 23 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
17848 23 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17849 23 : if (!SWIG_IsOK(res1)) {
17850 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_fpr_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17851 : }
17852 23 : arg1 = (struct _gpgme_new_signature *)(argp1);
17853 23 : result = (char *) ((arg1)->fpr);
17854 23 : resultobj = SWIG_FromCharPtr((const char *)result);
17855 23 : return resultobj;
17856 : fail:
17857 : return NULL;
17858 : }
17859 :
17860 :
17861 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_sig_class_set(PyObject *self, PyObject *args) {
17862 0 : PyObject *resultobj = 0;
17863 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17864 : unsigned int arg2 ;
17865 0 : void *argp1 = 0 ;
17866 0 : int res1 = 0 ;
17867 : unsigned int val2 ;
17868 0 : int ecode2 = 0 ;
17869 0 : PyObject * obj1 = 0 ;
17870 :
17871 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_sig_class_set",&obj1)) SWIG_fail;
17872 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17873 0 : if (!SWIG_IsOK(res1)) {
17874 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_sig_class_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17875 : }
17876 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
17877 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17878 0 : if (!SWIG_IsOK(ecode2)) {
17879 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_sig_class_set" "', argument " "2"" of type '" "unsigned int""'");
17880 : }
17881 0 : arg2 = (unsigned int)(val2);
17882 0 : if (arg1) (arg1)->sig_class = arg2;
17883 0 : resultobj = SWIG_Py_Void();
17884 0 : return resultobj;
17885 : fail:
17886 : return NULL;
17887 : }
17888 :
17889 :
17890 23 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_sig_class_get(PyObject *self, PyObject *args) {
17891 23 : PyObject *resultobj = 0;
17892 23 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17893 23 : void *argp1 = 0 ;
17894 23 : int res1 = 0 ;
17895 : unsigned int result;
17896 :
17897 23 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
17898 23 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
17899 23 : if (!SWIG_IsOK(res1)) {
17900 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_sig_class_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17901 : }
17902 23 : arg1 = (struct _gpgme_new_signature *)(argp1);
17903 23 : result = (unsigned int) ((arg1)->sig_class);
17904 23 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17905 23 : return resultobj;
17906 : fail:
17907 : return NULL;
17908 : }
17909 :
17910 :
17911 0 : SWIGINTERN int _wrap_new__gpgme_new_signature(PyObject *self, PyObject *args) {
17912 0 : PyObject *resultobj = 0;
17913 0 : struct _gpgme_new_signature *result = 0 ;
17914 :
17915 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
17916 0 : result = (struct _gpgme_new_signature *)calloc(1, sizeof(struct _gpgme_new_signature));
17917 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_new_signature, SWIG_BUILTIN_INIT | 0 );
17918 0 : return resultobj == Py_None ? -1 : 0;
17919 : fail:
17920 : return -1;
17921 : }
17922 :
17923 :
17924 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_new_signature(PyObject *self, PyObject *args) {
17925 0 : PyObject *resultobj = 0;
17926 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
17927 0 : void *argp1 = 0 ;
17928 0 : int res1 = 0 ;
17929 :
17930 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
17931 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_new_signature, SWIG_POINTER_DISOWN | 0 );
17932 0 : if (!SWIG_IsOK(res1)) {
17933 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_new_signature" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
17934 : }
17935 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
17936 0 : free((char *) arg1);
17937 0 : resultobj = SWIG_Py_Void();
17938 0 : return resultobj;
17939 : fail:
17940 : return NULL;
17941 : }
17942 :
17943 :
17944 0 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_invalid_signers_set(PyObject *self, PyObject *args) {
17945 0 : PyObject *resultobj = 0;
17946 0 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
17947 0 : gpgme_invalid_key_t arg2 = (gpgme_invalid_key_t) 0 ;
17948 0 : void *argp1 = 0 ;
17949 0 : int res1 = 0 ;
17950 0 : void *argp2 = 0 ;
17951 0 : int res2 = 0 ;
17952 0 : PyObject * obj1 = 0 ;
17953 :
17954 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_sign_result_invalid_signers_set",&obj1)) SWIG_fail;
17955 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
17956 0 : if (!SWIG_IsOK(res1)) {
17957 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_sign_result_invalid_signers_set" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
17958 : }
17959 0 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
17960 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_invalid_key, SWIG_POINTER_DISOWN | 0 );
17961 0 : if (!SWIG_IsOK(res2)) {
17962 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_sign_result_invalid_signers_set" "', argument " "2"" of type '" "gpgme_invalid_key_t""'");
17963 : }
17964 0 : arg2 = (gpgme_invalid_key_t)(argp2);
17965 0 : if (arg1) (arg1)->invalid_signers = arg2;
17966 0 : resultobj = SWIG_Py_Void();
17967 0 : return resultobj;
17968 : fail:
17969 : return NULL;
17970 : }
17971 :
17972 :
17973 38 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_invalid_signers_get(PyObject *self, PyObject *args) {
17974 38 : PyObject *resultobj = 0;
17975 38 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
17976 38 : void *argp1 = 0 ;
17977 38 : int res1 = 0 ;
17978 : gpgme_invalid_key_t result;
17979 :
17980 38 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
17981 38 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
17982 38 : if (!SWIG_IsOK(res1)) {
17983 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_sign_result_invalid_signers_get" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
17984 : }
17985 38 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
17986 38 : result = (gpgme_invalid_key_t) ((arg1)->invalid_signers);
17987 : {
17988 : int i;
17989 38 : int size = 0;
17990 : gpgme_invalid_key_t curr;
17991 42 : for (curr = result; curr != NULL; curr = curr->next) {
17992 4 : size++;
17993 : }
17994 38 : resultobj = PyList_New(size);
17995 42 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
17996 4 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_invalid_key, 0 );
17997 4 : PyList_SetItem(resultobj, i, o);
17998 : }
17999 : }
18000 : return resultobj;
18001 : fail:
18002 : return NULL;
18003 : }
18004 :
18005 :
18006 0 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_signatures_set(PyObject *self, PyObject *args) {
18007 0 : PyObject *resultobj = 0;
18008 0 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
18009 0 : gpgme_new_signature_t arg2 = (gpgme_new_signature_t) 0 ;
18010 0 : void *argp1 = 0 ;
18011 0 : int res1 = 0 ;
18012 0 : void *argp2 = 0 ;
18013 0 : int res2 = 0 ;
18014 0 : PyObject * obj1 = 0 ;
18015 :
18016 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_sign_result_signatures_set",&obj1)) SWIG_fail;
18017 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
18018 0 : if (!SWIG_IsOK(res1)) {
18019 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_sign_result_signatures_set" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
18020 : }
18021 0 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
18022 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_new_signature, SWIG_POINTER_DISOWN | 0 );
18023 0 : if (!SWIG_IsOK(res2)) {
18024 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_sign_result_signatures_set" "', argument " "2"" of type '" "gpgme_new_signature_t""'");
18025 : }
18026 0 : arg2 = (gpgme_new_signature_t)(argp2);
18027 0 : if (arg1) (arg1)->signatures = arg2;
18028 0 : resultobj = SWIG_Py_Void();
18029 0 : return resultobj;
18030 : fail:
18031 : return NULL;
18032 : }
18033 :
18034 :
18035 38 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_signatures_get(PyObject *self, PyObject *args) {
18036 38 : PyObject *resultobj = 0;
18037 38 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
18038 38 : void *argp1 = 0 ;
18039 38 : int res1 = 0 ;
18040 : gpgme_new_signature_t result;
18041 :
18042 38 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
18043 38 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
18044 38 : if (!SWIG_IsOK(res1)) {
18045 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_sign_result_signatures_get" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
18046 : }
18047 38 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
18048 38 : result = (gpgme_new_signature_t) ((arg1)->signatures);
18049 : {
18050 : int i;
18051 38 : int size = 0;
18052 : gpgme_new_signature_t curr;
18053 84 : for (curr = result; curr != NULL; curr = curr->next) {
18054 46 : size++;
18055 : }
18056 38 : resultobj = PyList_New(size);
18057 84 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
18058 46 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_new_signature, 0 );
18059 46 : PyList_SetItem(resultobj, i, o);
18060 : }
18061 : }
18062 : return resultobj;
18063 : fail:
18064 : return NULL;
18065 : }
18066 :
18067 :
18068 0 : SWIGINTERN int _wrap_new__gpgme_op_sign_result(PyObject *self, PyObject *args) {
18069 0 : PyObject *resultobj = 0;
18070 0 : struct _gpgme_op_sign_result *result = 0 ;
18071 :
18072 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
18073 0 : result = (struct _gpgme_op_sign_result *)calloc(1, sizeof(struct _gpgme_op_sign_result));
18074 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_sign_result, SWIG_BUILTIN_INIT | 0 );
18075 0 : return resultobj == Py_None ? -1 : 0;
18076 : fail:
18077 : return -1;
18078 : }
18079 :
18080 :
18081 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_sign_result(PyObject *self, PyObject *args) {
18082 0 : PyObject *resultobj = 0;
18083 0 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
18084 0 : void *argp1 = 0 ;
18085 0 : int res1 = 0 ;
18086 :
18087 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
18088 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_sign_result, SWIG_POINTER_DISOWN | 0 );
18089 0 : if (!SWIG_IsOK(res1)) {
18090 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_sign_result" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
18091 : }
18092 0 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
18093 0 : free((char *) arg1);
18094 0 : resultobj = SWIG_Py_Void();
18095 0 : return resultobj;
18096 : fail:
18097 : return NULL;
18098 : }
18099 :
18100 :
18101 19 : SWIGINTERN PyObject *_wrap_gpgme_op_sign_result(PyObject *self, PyObject *args) {
18102 19 : PyObject *resultobj = 0;
18103 19 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
18104 19 : void *argp1 = 0 ;
18105 19 : int res1 = 0 ;
18106 19 : PyObject * obj0 = 0 ;
18107 : gpgme_sign_result_t result;
18108 :
18109 19 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_sign_result",&obj0)) SWIG_fail;
18110 19 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
18111 19 : if (!SWIG_IsOK(res1)) {
18112 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_sign_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
18113 : }
18114 19 : arg1 = (gpgme_ctx_t)(argp1);
18115 19 : result = (gpgme_sign_result_t)gpgme_op_sign_result(arg1);
18116 : {
18117 : PyObject *fragile;
18118 19 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_sign_result,
18119 : 0 );
18120 19 : resultobj = _pyme_wrap_result(fragile, "SignResult");
18121 19 : Py_DECREF(fragile);
18122 : }
18123 19 : return resultobj;
18124 : fail:
18125 : return NULL;
18126 : }
18127 :
18128 :
18129 0 : SWIGINTERN PyObject *_wrap_gpgme_op_sign_start(PyObject *self, PyObject *args) {
18130 0 : PyObject *resultobj = 0;
18131 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
18132 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
18133 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
18134 : gpgme_sig_mode_t arg4 ;
18135 0 : void *argp1 = 0 ;
18136 0 : int res1 = 0 ;
18137 0 : gpgme_data_t wrapper2 = NULL ;
18138 0 : PyObject *bytesio2 = NULL ;
18139 : Py_buffer view2 ;
18140 0 : int have_view2 = 0 ;
18141 0 : gpgme_data_t wrapper3 = NULL ;
18142 0 : PyObject *bytesio3 = NULL ;
18143 : Py_buffer view3 ;
18144 0 : int have_view3 = 0 ;
18145 : int val4 ;
18146 0 : int ecode4 = 0 ;
18147 0 : PyObject * obj0 = 0 ;
18148 0 : PyObject * obj1 = 0 ;
18149 0 : PyObject * obj2 = 0 ;
18150 0 : PyObject * obj3 = 0 ;
18151 : gpgme_error_t result;
18152 :
18153 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_sign_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18154 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
18155 0 : if (!SWIG_IsOK(res1)) {
18156 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_sign_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
18157 : }
18158 0 : arg1 = (gpgme_ctx_t)(argp1);
18159 : {
18160 : /* If we create a temporary wrapper2 object, we will store it in
18161 : wrapperN, where N is 2. Here in this fragment, SWIG will
18162 : automatically append 2. */
18163 : memset(&view2, 0, sizeof view2);
18164 0 : if (obj1 == Py_None)
18165 0 : arg2 = NULL;
18166 : else {
18167 : PyObject *pypointer;
18168 0 : pypointer = _pyme_obj2gpgme_data_t(obj1, 2, &wrapper2,
18169 : &bytesio2, &view2);
18170 0 : if (pypointer == NULL)
18171 : return NULL;
18172 0 : have_view2 = !! view2.obj;
18173 :
18174 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
18175 :
18176 : // Following code is from swig's python.swg
18177 :
18178 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
18179 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18180 0 : Py_DECREF(pypointer);
18181 : return NULL;
18182 : }
18183 0 : Py_DECREF(pypointer);
18184 : }
18185 : }
18186 : {
18187 : /* If we create a temporary wrapper3 object, we will store it in
18188 : wrapperN, where N is 3. Here in this fragment, SWIG will
18189 : automatically append 3. */
18190 : memset(&view3, 0, sizeof view3);
18191 0 : if (obj2 == Py_None)
18192 0 : arg3 = NULL;
18193 : else {
18194 : PyObject *pypointer;
18195 0 : pypointer = _pyme_obj2gpgme_data_t(obj2, 3, &wrapper3,
18196 : &bytesio3, &view3);
18197 0 : if (pypointer == NULL)
18198 : return NULL;
18199 0 : have_view3 = !! view3.obj;
18200 :
18201 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
18202 :
18203 : // Following code is from swig's python.swg
18204 :
18205 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
18206 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18207 0 : Py_DECREF(pypointer);
18208 : return NULL;
18209 : }
18210 0 : Py_DECREF(pypointer);
18211 : }
18212 : }
18213 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
18214 0 : if (!SWIG_IsOK(ecode4)) {
18215 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_sign_start" "', argument " "4"" of type '" "gpgme_sig_mode_t""'");
18216 : }
18217 0 : arg4 = (gpgme_sig_mode_t)(val4);
18218 0 : result = gpgme_op_sign_start(arg1,arg2,arg3,arg4);
18219 : {
18220 0 : resultobj = PyLong_FromLong(result);
18221 : }
18222 : {
18223 : /* See whether we need to update the Python buffer. */
18224 0 : if (resultobj && wrapper2 && view2.buf)
18225 : {
18226 : int dirty;
18227 0 : char *new_data = NULL;
18228 : size_t new_size;
18229 :
18230 :
18231 0 : new_data = wrapper2->data.mem.buffer;
18232 0 : new_size = wrapper2->data.mem.length;
18233 0 : dirty = new_data != NULL;
18234 :
18235 :
18236 :
18237 :
18238 :
18239 :
18240 :
18241 0 : if (dirty)
18242 : {
18243 : /* The buffer is dirty. */
18244 0 : if (view2.readonly)
18245 : {
18246 0 : Py_XDECREF(resultobj);
18247 0 : resultobj = NULL;
18248 0 : PyErr_SetString(PyExc_ValueError,
18249 : "cannot update read-only buffer");
18250 : }
18251 :
18252 : /* See if we need to truncate the buffer. */
18253 0 : if (resultobj && view2.len != new_size)
18254 : {
18255 0 : if (bytesio2 == NULL)
18256 : {
18257 0 : Py_XDECREF(resultobj);
18258 0 : resultobj = NULL;
18259 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18260 : }
18261 : else
18262 : {
18263 : PyObject *retval;
18264 0 : PyBuffer_Release(&view2);
18265 : assert(view2.obj == NULL);
18266 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
18267 : "l", (long) new_size);
18268 0 : if (retval == NULL)
18269 : {
18270 0 : Py_XDECREF(resultobj);
18271 : resultobj = NULL;
18272 : }
18273 : else
18274 : {
18275 0 : Py_DECREF(retval);
18276 :
18277 0 : retval = PyObject_CallMethod(bytesio2,
18278 : "getbuffer", NULL);
18279 0 : if (retval == NULL
18280 0 : || PyObject_GetBuffer(retval, &view2,
18281 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18282 : {
18283 0 : Py_XDECREF(resultobj);
18284 : resultobj = NULL;
18285 : }
18286 :
18287 0 : Py_XDECREF(retval);
18288 :
18289 0 : if (resultobj && view2.len
18290 0 : != new_size)
18291 : {
18292 0 : Py_XDECREF(resultobj);
18293 0 : resultobj = NULL;
18294 0 : PyErr_Format(PyExc_ValueError,
18295 : "Expected buffer of length %zu, got %zi",
18296 : new_size,
18297 : view2.len);
18298 : }
18299 : }
18300 : }
18301 : }
18302 0 : if (resultobj)
18303 0 : memcpy(view2.buf, new_data, new_size);
18304 : }
18305 :
18306 :
18307 :
18308 : }
18309 :
18310 : /* Free the temporary wrapper, if any. */
18311 0 : if (wrapper2)
18312 0 : gpgme_data_release(wrapper2);
18313 0 : Py_XDECREF (bytesio2);
18314 0 : if (have_view2 && view2.buf)
18315 0 : PyBuffer_Release(&view2);
18316 : }
18317 : {
18318 : /* See whether we need to update the Python buffer. */
18319 0 : if (resultobj && wrapper3 && view3.buf)
18320 : {
18321 : int dirty;
18322 0 : char *new_data = NULL;
18323 : size_t new_size;
18324 :
18325 :
18326 0 : new_data = wrapper3->data.mem.buffer;
18327 0 : new_size = wrapper3->data.mem.length;
18328 0 : dirty = new_data != NULL;
18329 :
18330 :
18331 :
18332 :
18333 :
18334 :
18335 :
18336 0 : if (dirty)
18337 : {
18338 : /* The buffer is dirty. */
18339 0 : if (view3.readonly)
18340 : {
18341 0 : Py_XDECREF(resultobj);
18342 0 : resultobj = NULL;
18343 0 : PyErr_SetString(PyExc_ValueError,
18344 : "cannot update read-only buffer");
18345 : }
18346 :
18347 : /* See if we need to truncate the buffer. */
18348 0 : if (resultobj && view3.len != new_size)
18349 : {
18350 0 : if (bytesio3 == NULL)
18351 : {
18352 0 : Py_XDECREF(resultobj);
18353 0 : resultobj = NULL;
18354 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18355 : }
18356 : else
18357 : {
18358 : PyObject *retval;
18359 0 : PyBuffer_Release(&view3);
18360 : assert(view3.obj == NULL);
18361 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
18362 : "l", (long) new_size);
18363 0 : if (retval == NULL)
18364 : {
18365 0 : Py_XDECREF(resultobj);
18366 : resultobj = NULL;
18367 : }
18368 : else
18369 : {
18370 0 : Py_DECREF(retval);
18371 :
18372 0 : retval = PyObject_CallMethod(bytesio3,
18373 : "getbuffer", NULL);
18374 0 : if (retval == NULL
18375 0 : || PyObject_GetBuffer(retval, &view3,
18376 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18377 : {
18378 0 : Py_XDECREF(resultobj);
18379 : resultobj = NULL;
18380 : }
18381 :
18382 0 : Py_XDECREF(retval);
18383 :
18384 0 : if (resultobj && view3.len
18385 0 : != new_size)
18386 : {
18387 0 : Py_XDECREF(resultobj);
18388 0 : resultobj = NULL;
18389 0 : PyErr_Format(PyExc_ValueError,
18390 : "Expected buffer of length %zu, got %zi",
18391 : new_size,
18392 : view3.len);
18393 : }
18394 : }
18395 : }
18396 : }
18397 0 : if (resultobj)
18398 0 : memcpy(view3.buf, new_data, new_size);
18399 : }
18400 :
18401 :
18402 :
18403 : }
18404 :
18405 : /* Free the temporary wrapper, if any. */
18406 0 : if (wrapper3)
18407 0 : gpgme_data_release(wrapper3);
18408 0 : Py_XDECREF (bytesio3);
18409 0 : if (have_view3 && view3.buf)
18410 0 : PyBuffer_Release(&view3);
18411 : }
18412 0 : return resultobj;
18413 : fail:
18414 : {
18415 : /* See whether we need to update the Python buffer. */
18416 : if (resultobj && wrapper2 && view2.buf)
18417 : {
18418 : int dirty;
18419 : char *new_data = NULL;
18420 : size_t new_size;
18421 :
18422 :
18423 : new_data = wrapper2->data.mem.buffer;
18424 : new_size = wrapper2->data.mem.length;
18425 : dirty = new_data != NULL;
18426 :
18427 :
18428 :
18429 :
18430 :
18431 :
18432 :
18433 : if (dirty)
18434 : {
18435 : /* The buffer is dirty. */
18436 : if (view2.readonly)
18437 : {
18438 : Py_XDECREF(resultobj);
18439 : resultobj = NULL;
18440 : PyErr_SetString(PyExc_ValueError,
18441 : "cannot update read-only buffer");
18442 : }
18443 :
18444 : /* See if we need to truncate the buffer. */
18445 : if (resultobj && view2.len != new_size)
18446 : {
18447 : if (bytesio2 == NULL)
18448 : {
18449 : Py_XDECREF(resultobj);
18450 : resultobj = NULL;
18451 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18452 : }
18453 : else
18454 : {
18455 : PyObject *retval;
18456 : PyBuffer_Release(&view2);
18457 : assert(view2.obj == NULL);
18458 : retval = PyObject_CallMethod(bytesio2, "truncate",
18459 : "l", (long) new_size);
18460 : if (retval == NULL)
18461 : {
18462 : Py_XDECREF(resultobj);
18463 : resultobj = NULL;
18464 : }
18465 : else
18466 : {
18467 : Py_DECREF(retval);
18468 :
18469 : retval = PyObject_CallMethod(bytesio2,
18470 : "getbuffer", NULL);
18471 : if (retval == NULL
18472 : || PyObject_GetBuffer(retval, &view2,
18473 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18474 : {
18475 : Py_XDECREF(resultobj);
18476 : resultobj = NULL;
18477 : }
18478 :
18479 : Py_XDECREF(retval);
18480 :
18481 : if (resultobj && view2.len
18482 : != new_size)
18483 : {
18484 : Py_XDECREF(resultobj);
18485 : resultobj = NULL;
18486 : PyErr_Format(PyExc_ValueError,
18487 : "Expected buffer of length %zu, got %zi",
18488 : new_size,
18489 : view2.len);
18490 : }
18491 : }
18492 : }
18493 : }
18494 : if (resultobj)
18495 : memcpy(view2.buf, new_data, new_size);
18496 : }
18497 :
18498 :
18499 :
18500 : }
18501 :
18502 : /* Free the temporary wrapper, if any. */
18503 0 : if (wrapper2)
18504 0 : gpgme_data_release(wrapper2);
18505 0 : Py_XDECREF (bytesio2);
18506 0 : if (have_view2 && view2.buf)
18507 0 : PyBuffer_Release(&view2);
18508 : }
18509 : {
18510 : /* See whether we need to update the Python buffer. */
18511 : if (resultobj && wrapper3 && view3.buf)
18512 : {
18513 : int dirty;
18514 : char *new_data = NULL;
18515 : size_t new_size;
18516 :
18517 :
18518 : new_data = wrapper3->data.mem.buffer;
18519 : new_size = wrapper3->data.mem.length;
18520 : dirty = new_data != NULL;
18521 :
18522 :
18523 :
18524 :
18525 :
18526 :
18527 :
18528 : if (dirty)
18529 : {
18530 : /* The buffer is dirty. */
18531 : if (view3.readonly)
18532 : {
18533 : Py_XDECREF(resultobj);
18534 : resultobj = NULL;
18535 : PyErr_SetString(PyExc_ValueError,
18536 : "cannot update read-only buffer");
18537 : }
18538 :
18539 : /* See if we need to truncate the buffer. */
18540 : if (resultobj && view3.len != new_size)
18541 : {
18542 : if (bytesio3 == NULL)
18543 : {
18544 : Py_XDECREF(resultobj);
18545 : resultobj = NULL;
18546 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18547 : }
18548 : else
18549 : {
18550 : PyObject *retval;
18551 : PyBuffer_Release(&view3);
18552 : assert(view3.obj == NULL);
18553 : retval = PyObject_CallMethod(bytesio3, "truncate",
18554 : "l", (long) new_size);
18555 : if (retval == NULL)
18556 : {
18557 : Py_XDECREF(resultobj);
18558 : resultobj = NULL;
18559 : }
18560 : else
18561 : {
18562 : Py_DECREF(retval);
18563 :
18564 : retval = PyObject_CallMethod(bytesio3,
18565 : "getbuffer", NULL);
18566 : if (retval == NULL
18567 : || PyObject_GetBuffer(retval, &view3,
18568 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18569 : {
18570 : Py_XDECREF(resultobj);
18571 : resultobj = NULL;
18572 : }
18573 :
18574 : Py_XDECREF(retval);
18575 :
18576 : if (resultobj && view3.len
18577 : != new_size)
18578 : {
18579 : Py_XDECREF(resultobj);
18580 : resultobj = NULL;
18581 : PyErr_Format(PyExc_ValueError,
18582 : "Expected buffer of length %zu, got %zi",
18583 : new_size,
18584 : view3.len);
18585 : }
18586 : }
18587 : }
18588 : }
18589 : if (resultobj)
18590 : memcpy(view3.buf, new_data, new_size);
18591 : }
18592 :
18593 :
18594 :
18595 : }
18596 :
18597 : /* Free the temporary wrapper, if any. */
18598 0 : if (wrapper3)
18599 0 : gpgme_data_release(wrapper3);
18600 0 : Py_XDECREF (bytesio3);
18601 0 : if (have_view3 && view3.buf)
18602 0 : PyBuffer_Release(&view3);
18603 : }
18604 : return NULL;
18605 : }
18606 :
18607 :
18608 17 : SWIGINTERN PyObject *_wrap_gpgme_op_sign(PyObject *self, PyObject *args) {
18609 17 : PyObject *resultobj = 0;
18610 17 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
18611 17 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
18612 17 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
18613 : gpgme_sig_mode_t arg4 ;
18614 17 : void *argp1 = 0 ;
18615 17 : int res1 = 0 ;
18616 17 : gpgme_data_t wrapper2 = NULL ;
18617 17 : PyObject *bytesio2 = NULL ;
18618 : Py_buffer view2 ;
18619 17 : int have_view2 = 0 ;
18620 17 : gpgme_data_t wrapper3 = NULL ;
18621 17 : PyObject *bytesio3 = NULL ;
18622 : Py_buffer view3 ;
18623 17 : int have_view3 = 0 ;
18624 : int val4 ;
18625 17 : int ecode4 = 0 ;
18626 17 : PyObject * obj0 = 0 ;
18627 17 : PyObject * obj1 = 0 ;
18628 17 : PyObject * obj2 = 0 ;
18629 17 : PyObject * obj3 = 0 ;
18630 : gpgme_error_t result;
18631 :
18632 17 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_sign",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18633 17 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
18634 17 : if (!SWIG_IsOK(res1)) {
18635 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_sign" "', argument " "1"" of type '" "gpgme_ctx_t""'");
18636 : }
18637 17 : arg1 = (gpgme_ctx_t)(argp1);
18638 : {
18639 : /* If we create a temporary wrapper2 object, we will store it in
18640 : wrapperN, where N is 2. Here in this fragment, SWIG will
18641 : automatically append 2. */
18642 : memset(&view2, 0, sizeof view2);
18643 17 : if (obj1 == Py_None)
18644 0 : arg2 = NULL;
18645 : else {
18646 : PyObject *pypointer;
18647 17 : pypointer = _pyme_obj2gpgme_data_t(obj1, 2, &wrapper2,
18648 : &bytesio2, &view2);
18649 17 : if (pypointer == NULL)
18650 : return NULL;
18651 17 : have_view2 = !! view2.obj;
18652 :
18653 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
18654 :
18655 : // Following code is from swig's python.swg
18656 :
18657 17 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
18658 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18659 0 : Py_DECREF(pypointer);
18660 : return NULL;
18661 : }
18662 17 : Py_DECREF(pypointer);
18663 : }
18664 : }
18665 : {
18666 : /* If we create a temporary wrapper3 object, we will store it in
18667 : wrapperN, where N is 3. Here in this fragment, SWIG will
18668 : automatically append 3. */
18669 : memset(&view3, 0, sizeof view3);
18670 17 : if (obj2 == Py_None)
18671 0 : arg3 = NULL;
18672 : else {
18673 : PyObject *pypointer;
18674 17 : pypointer = _pyme_obj2gpgme_data_t(obj2, 3, &wrapper3,
18675 : &bytesio3, &view3);
18676 17 : if (pypointer == NULL)
18677 : return NULL;
18678 17 : have_view3 = !! view3.obj;
18679 :
18680 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
18681 :
18682 : // Following code is from swig's python.swg
18683 :
18684 17 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
18685 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18686 0 : Py_DECREF(pypointer);
18687 : return NULL;
18688 : }
18689 17 : Py_DECREF(pypointer);
18690 : }
18691 : }
18692 17 : ecode4 = SWIG_AsVal_int(obj3, &val4);
18693 17 : if (!SWIG_IsOK(ecode4)) {
18694 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_sign" "', argument " "4"" of type '" "gpgme_sig_mode_t""'");
18695 : }
18696 17 : arg4 = (gpgme_sig_mode_t)(val4);
18697 17 : result = gpgme_op_sign(arg1,arg2,arg3,arg4);
18698 : {
18699 17 : resultobj = PyLong_FromLong(result);
18700 : }
18701 : {
18702 : /* See whether we need to update the Python buffer. */
18703 17 : if (resultobj && wrapper2 && view2.buf)
18704 : {
18705 : int dirty;
18706 9 : char *new_data = NULL;
18707 : size_t new_size;
18708 :
18709 :
18710 9 : new_data = wrapper2->data.mem.buffer;
18711 9 : new_size = wrapper2->data.mem.length;
18712 9 : dirty = new_data != NULL;
18713 :
18714 :
18715 :
18716 :
18717 :
18718 :
18719 :
18720 9 : if (dirty)
18721 : {
18722 : /* The buffer is dirty. */
18723 0 : if (view2.readonly)
18724 : {
18725 0 : Py_XDECREF(resultobj);
18726 0 : resultobj = NULL;
18727 0 : PyErr_SetString(PyExc_ValueError,
18728 : "cannot update read-only buffer");
18729 : }
18730 :
18731 : /* See if we need to truncate the buffer. */
18732 0 : if (resultobj && view2.len != new_size)
18733 : {
18734 0 : if (bytesio2 == NULL)
18735 : {
18736 0 : Py_XDECREF(resultobj);
18737 0 : resultobj = NULL;
18738 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18739 : }
18740 : else
18741 : {
18742 : PyObject *retval;
18743 0 : PyBuffer_Release(&view2);
18744 : assert(view2.obj == NULL);
18745 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
18746 : "l", (long) new_size);
18747 0 : if (retval == NULL)
18748 : {
18749 0 : Py_XDECREF(resultobj);
18750 : resultobj = NULL;
18751 : }
18752 : else
18753 : {
18754 0 : Py_DECREF(retval);
18755 :
18756 0 : retval = PyObject_CallMethod(bytesio2,
18757 : "getbuffer", NULL);
18758 0 : if (retval == NULL
18759 0 : || PyObject_GetBuffer(retval, &view2,
18760 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18761 : {
18762 0 : Py_XDECREF(resultobj);
18763 : resultobj = NULL;
18764 : }
18765 :
18766 0 : Py_XDECREF(retval);
18767 :
18768 0 : if (resultobj && view2.len
18769 0 : != new_size)
18770 : {
18771 0 : Py_XDECREF(resultobj);
18772 0 : resultobj = NULL;
18773 0 : PyErr_Format(PyExc_ValueError,
18774 : "Expected buffer of length %zu, got %zi",
18775 : new_size,
18776 : view2.len);
18777 : }
18778 : }
18779 : }
18780 : }
18781 0 : if (resultobj)
18782 0 : memcpy(view2.buf, new_data, new_size);
18783 : }
18784 :
18785 :
18786 :
18787 : }
18788 :
18789 : /* Free the temporary wrapper, if any. */
18790 17 : if (wrapper2)
18791 10 : gpgme_data_release(wrapper2);
18792 17 : Py_XDECREF (bytesio2);
18793 17 : if (have_view2 && view2.buf)
18794 9 : PyBuffer_Release(&view2);
18795 : }
18796 : {
18797 : /* See whether we need to update the Python buffer. */
18798 17 : if (resultobj && wrapper3 && view3.buf)
18799 : {
18800 : int dirty;
18801 1 : char *new_data = NULL;
18802 : size_t new_size;
18803 :
18804 :
18805 1 : new_data = wrapper3->data.mem.buffer;
18806 1 : new_size = wrapper3->data.mem.length;
18807 1 : dirty = new_data != NULL;
18808 :
18809 :
18810 :
18811 :
18812 :
18813 :
18814 :
18815 1 : if (dirty)
18816 : {
18817 : /* The buffer is dirty. */
18818 1 : if (view3.readonly)
18819 : {
18820 0 : Py_XDECREF(resultobj);
18821 0 : resultobj = NULL;
18822 0 : PyErr_SetString(PyExc_ValueError,
18823 : "cannot update read-only buffer");
18824 : }
18825 :
18826 : /* See if we need to truncate the buffer. */
18827 1 : if (resultobj && view3.len != new_size)
18828 : {
18829 0 : if (bytesio3 == NULL)
18830 : {
18831 0 : Py_XDECREF(resultobj);
18832 0 : resultobj = NULL;
18833 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18834 : }
18835 : else
18836 : {
18837 : PyObject *retval;
18838 0 : PyBuffer_Release(&view3);
18839 : assert(view3.obj == NULL);
18840 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
18841 : "l", (long) new_size);
18842 0 : if (retval == NULL)
18843 : {
18844 0 : Py_XDECREF(resultobj);
18845 : resultobj = NULL;
18846 : }
18847 : else
18848 : {
18849 0 : Py_DECREF(retval);
18850 :
18851 0 : retval = PyObject_CallMethod(bytesio3,
18852 : "getbuffer", NULL);
18853 0 : if (retval == NULL
18854 0 : || PyObject_GetBuffer(retval, &view3,
18855 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18856 : {
18857 0 : Py_XDECREF(resultobj);
18858 : resultobj = NULL;
18859 : }
18860 :
18861 0 : Py_XDECREF(retval);
18862 :
18863 0 : if (resultobj && view3.len
18864 0 : != new_size)
18865 : {
18866 0 : Py_XDECREF(resultobj);
18867 0 : resultobj = NULL;
18868 0 : PyErr_Format(PyExc_ValueError,
18869 : "Expected buffer of length %zu, got %zi",
18870 : new_size,
18871 : view3.len);
18872 : }
18873 : }
18874 : }
18875 : }
18876 1 : if (resultobj)
18877 1 : memcpy(view3.buf, new_data, new_size);
18878 : }
18879 :
18880 :
18881 :
18882 : }
18883 :
18884 : /* Free the temporary wrapper, if any. */
18885 17 : if (wrapper3)
18886 2 : gpgme_data_release(wrapper3);
18887 17 : Py_XDECREF (bytesio3);
18888 17 : if (have_view3 && view3.buf)
18889 1 : PyBuffer_Release(&view3);
18890 : }
18891 17 : return resultobj;
18892 : fail:
18893 : {
18894 : /* See whether we need to update the Python buffer. */
18895 : if (resultobj && wrapper2 && view2.buf)
18896 : {
18897 : int dirty;
18898 : char *new_data = NULL;
18899 : size_t new_size;
18900 :
18901 :
18902 : new_data = wrapper2->data.mem.buffer;
18903 : new_size = wrapper2->data.mem.length;
18904 : dirty = new_data != NULL;
18905 :
18906 :
18907 :
18908 :
18909 :
18910 :
18911 :
18912 : if (dirty)
18913 : {
18914 : /* The buffer is dirty. */
18915 : if (view2.readonly)
18916 : {
18917 : Py_XDECREF(resultobj);
18918 : resultobj = NULL;
18919 : PyErr_SetString(PyExc_ValueError,
18920 : "cannot update read-only buffer");
18921 : }
18922 :
18923 : /* See if we need to truncate the buffer. */
18924 : if (resultobj && view2.len != new_size)
18925 : {
18926 : if (bytesio2 == NULL)
18927 : {
18928 : Py_XDECREF(resultobj);
18929 : resultobj = NULL;
18930 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18931 : }
18932 : else
18933 : {
18934 : PyObject *retval;
18935 : PyBuffer_Release(&view2);
18936 : assert(view2.obj == NULL);
18937 : retval = PyObject_CallMethod(bytesio2, "truncate",
18938 : "l", (long) new_size);
18939 : if (retval == NULL)
18940 : {
18941 : Py_XDECREF(resultobj);
18942 : resultobj = NULL;
18943 : }
18944 : else
18945 : {
18946 : Py_DECREF(retval);
18947 :
18948 : retval = PyObject_CallMethod(bytesio2,
18949 : "getbuffer", NULL);
18950 : if (retval == NULL
18951 : || PyObject_GetBuffer(retval, &view2,
18952 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18953 : {
18954 : Py_XDECREF(resultobj);
18955 : resultobj = NULL;
18956 : }
18957 :
18958 : Py_XDECREF(retval);
18959 :
18960 : if (resultobj && view2.len
18961 : != new_size)
18962 : {
18963 : Py_XDECREF(resultobj);
18964 : resultobj = NULL;
18965 : PyErr_Format(PyExc_ValueError,
18966 : "Expected buffer of length %zu, got %zi",
18967 : new_size,
18968 : view2.len);
18969 : }
18970 : }
18971 : }
18972 : }
18973 : if (resultobj)
18974 : memcpy(view2.buf, new_data, new_size);
18975 : }
18976 :
18977 :
18978 :
18979 : }
18980 :
18981 : /* Free the temporary wrapper, if any. */
18982 0 : if (wrapper2)
18983 0 : gpgme_data_release(wrapper2);
18984 0 : Py_XDECREF (bytesio2);
18985 0 : if (have_view2 && view2.buf)
18986 0 : PyBuffer_Release(&view2);
18987 : }
18988 : {
18989 : /* See whether we need to update the Python buffer. */
18990 : if (resultobj && wrapper3 && view3.buf)
18991 : {
18992 : int dirty;
18993 : char *new_data = NULL;
18994 : size_t new_size;
18995 :
18996 :
18997 : new_data = wrapper3->data.mem.buffer;
18998 : new_size = wrapper3->data.mem.length;
18999 : dirty = new_data != NULL;
19000 :
19001 :
19002 :
19003 :
19004 :
19005 :
19006 :
19007 : if (dirty)
19008 : {
19009 : /* The buffer is dirty. */
19010 : if (view3.readonly)
19011 : {
19012 : Py_XDECREF(resultobj);
19013 : resultobj = NULL;
19014 : PyErr_SetString(PyExc_ValueError,
19015 : "cannot update read-only buffer");
19016 : }
19017 :
19018 : /* See if we need to truncate the buffer. */
19019 : if (resultobj && view3.len != new_size)
19020 : {
19021 : if (bytesio3 == NULL)
19022 : {
19023 : Py_XDECREF(resultobj);
19024 : resultobj = NULL;
19025 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19026 : }
19027 : else
19028 : {
19029 : PyObject *retval;
19030 : PyBuffer_Release(&view3);
19031 : assert(view3.obj == NULL);
19032 : retval = PyObject_CallMethod(bytesio3, "truncate",
19033 : "l", (long) new_size);
19034 : if (retval == NULL)
19035 : {
19036 : Py_XDECREF(resultobj);
19037 : resultobj = NULL;
19038 : }
19039 : else
19040 : {
19041 : Py_DECREF(retval);
19042 :
19043 : retval = PyObject_CallMethod(bytesio3,
19044 : "getbuffer", NULL);
19045 : if (retval == NULL
19046 : || PyObject_GetBuffer(retval, &view3,
19047 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19048 : {
19049 : Py_XDECREF(resultobj);
19050 : resultobj = NULL;
19051 : }
19052 :
19053 : Py_XDECREF(retval);
19054 :
19055 : if (resultobj && view3.len
19056 : != new_size)
19057 : {
19058 : Py_XDECREF(resultobj);
19059 : resultobj = NULL;
19060 : PyErr_Format(PyExc_ValueError,
19061 : "Expected buffer of length %zu, got %zi",
19062 : new_size,
19063 : view3.len);
19064 : }
19065 : }
19066 : }
19067 : }
19068 : if (resultobj)
19069 : memcpy(view3.buf, new_data, new_size);
19070 : }
19071 :
19072 :
19073 :
19074 : }
19075 :
19076 : /* Free the temporary wrapper, if any. */
19077 0 : if (wrapper3)
19078 0 : gpgme_data_release(wrapper3);
19079 0 : Py_XDECREF (bytesio3);
19080 0 : if (have_view3 && view3.buf)
19081 0 : PyBuffer_Release(&view3);
19082 : }
19083 : return NULL;
19084 : }
19085 :
19086 :
19087 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_summary_set(PyObject *self, PyObject *args) {
19088 0 : PyObject *resultobj = 0;
19089 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19090 : gpgme_sigsum_t arg2 ;
19091 0 : void *argp1 = 0 ;
19092 0 : int res1 = 0 ;
19093 : int val2 ;
19094 0 : int ecode2 = 0 ;
19095 0 : PyObject * obj1 = 0 ;
19096 :
19097 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_summary_set",&obj1)) SWIG_fail;
19098 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19099 0 : if (!SWIG_IsOK(res1)) {
19100 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_summary_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19101 : }
19102 0 : arg1 = (struct _gpgme_signature *)(argp1);
19103 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
19104 0 : if (!SWIG_IsOK(ecode2)) {
19105 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_summary_set" "', argument " "2"" of type '" "gpgme_sigsum_t""'");
19106 : }
19107 0 : arg2 = (gpgme_sigsum_t)(val2);
19108 0 : if (arg1) (arg1)->summary = arg2;
19109 0 : resultobj = SWIG_Py_Void();
19110 0 : return resultobj;
19111 : fail:
19112 : return NULL;
19113 : }
19114 :
19115 :
19116 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_summary_get(PyObject *self, PyObject *args) {
19117 14 : PyObject *resultobj = 0;
19118 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19119 14 : void *argp1 = 0 ;
19120 14 : int res1 = 0 ;
19121 : gpgme_sigsum_t result;
19122 :
19123 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19124 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19125 14 : if (!SWIG_IsOK(res1)) {
19126 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_summary_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19127 : }
19128 14 : arg1 = (struct _gpgme_signature *)(argp1);
19129 14 : result = (gpgme_sigsum_t) ((arg1)->summary);
19130 28 : resultobj = SWIG_From_int((int)(result));
19131 14 : return resultobj;
19132 : fail:
19133 : return NULL;
19134 : }
19135 :
19136 :
19137 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_fpr_set(PyObject *self, PyObject *args) {
19138 0 : PyObject *resultobj = 0;
19139 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19140 0 : char *arg2 = (char *) 0 ;
19141 0 : void *argp1 = 0 ;
19142 0 : int res1 = 0 ;
19143 : int res2 ;
19144 0 : char *buf2 = 0 ;
19145 0 : int alloc2 = 0 ;
19146 0 : PyObject * obj1 = 0 ;
19147 :
19148 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_fpr_set",&obj1)) SWIG_fail;
19149 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19150 0 : if (!SWIG_IsOK(res1)) {
19151 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_fpr_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19152 : }
19153 0 : arg1 = (struct _gpgme_signature *)(argp1);
19154 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
19155 0 : if (!SWIG_IsOK(res2)) {
19156 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_fpr_set" "', argument " "2"" of type '" "char *""'");
19157 : }
19158 0 : arg2 = (char *)(buf2);
19159 0 : if (arg1->fpr) free((char*)arg1->fpr);
19160 0 : if (arg2) {
19161 0 : size_t size = strlen((const char *)(arg2)) + 1;
19162 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
19163 : } else {
19164 0 : arg1->fpr = 0;
19165 : }
19166 0 : resultobj = SWIG_Py_Void();
19167 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
19168 : return resultobj;
19169 : fail:
19170 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
19171 : return NULL;
19172 : }
19173 :
19174 :
19175 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_fpr_get(PyObject *self, PyObject *args) {
19176 14 : PyObject *resultobj = 0;
19177 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19178 14 : void *argp1 = 0 ;
19179 14 : int res1 = 0 ;
19180 14 : char *result = 0 ;
19181 :
19182 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19183 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19184 14 : if (!SWIG_IsOK(res1)) {
19185 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_fpr_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19186 : }
19187 14 : arg1 = (struct _gpgme_signature *)(argp1);
19188 14 : result = (char *) ((arg1)->fpr);
19189 14 : resultobj = SWIG_FromCharPtr((const char *)result);
19190 14 : return resultobj;
19191 : fail:
19192 : return NULL;
19193 : }
19194 :
19195 :
19196 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_status_set(PyObject *self, PyObject *args) {
19197 0 : PyObject *resultobj = 0;
19198 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19199 : gpgme_error_t arg2 ;
19200 0 : void *argp1 = 0 ;
19201 0 : int res1 = 0 ;
19202 0 : PyObject * obj1 = 0 ;
19203 :
19204 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_status_set",&obj1)) SWIG_fail;
19205 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19206 0 : if (!SWIG_IsOK(res1)) {
19207 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_status_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19208 : }
19209 0 : arg1 = (struct _gpgme_signature *)(argp1);
19210 : {
19211 0 : arg2 = PyLong_AsLong(obj1);
19212 : }
19213 0 : if (arg1) (arg1)->status = arg2;
19214 0 : resultobj = SWIG_Py_Void();
19215 0 : return resultobj;
19216 : fail:
19217 : return NULL;
19218 : }
19219 :
19220 :
19221 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_status_get(PyObject *self, PyObject *args) {
19222 14 : PyObject *resultobj = 0;
19223 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19224 14 : void *argp1 = 0 ;
19225 14 : int res1 = 0 ;
19226 : gpgme_error_t result;
19227 :
19228 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19229 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19230 14 : if (!SWIG_IsOK(res1)) {
19231 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_status_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19232 : }
19233 14 : arg1 = (struct _gpgme_signature *)(argp1);
19234 14 : result = ((arg1)->status);
19235 : {
19236 14 : resultobj = PyLong_FromLong(result);
19237 : }
19238 14 : return resultobj;
19239 : fail:
19240 : return NULL;
19241 : }
19242 :
19243 :
19244 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_notations_set(PyObject *self, PyObject *args) {
19245 0 : PyObject *resultobj = 0;
19246 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19247 0 : gpgme_sig_notation_t arg2 = (gpgme_sig_notation_t) 0 ;
19248 0 : void *argp1 = 0 ;
19249 0 : int res1 = 0 ;
19250 0 : void *argp2 = 0 ;
19251 0 : int res2 = 0 ;
19252 0 : PyObject * obj1 = 0 ;
19253 :
19254 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_notations_set",&obj1)) SWIG_fail;
19255 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19256 0 : if (!SWIG_IsOK(res1)) {
19257 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_notations_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19258 : }
19259 0 : arg1 = (struct _gpgme_signature *)(argp1);
19260 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
19261 0 : if (!SWIG_IsOK(res2)) {
19262 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_notations_set" "', argument " "2"" of type '" "gpgme_sig_notation_t""'");
19263 : }
19264 0 : arg2 = (gpgme_sig_notation_t)(argp2);
19265 0 : if (arg1) (arg1)->notations = arg2;
19266 0 : resultobj = SWIG_Py_Void();
19267 0 : return resultobj;
19268 : fail:
19269 : return NULL;
19270 : }
19271 :
19272 :
19273 28 : SWIGINTERN PyObject *_wrap__gpgme_signature_notations_get(PyObject *self, PyObject *args) {
19274 28 : PyObject *resultobj = 0;
19275 28 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19276 28 : void *argp1 = 0 ;
19277 28 : int res1 = 0 ;
19278 : gpgme_sig_notation_t result;
19279 :
19280 28 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19281 28 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19282 28 : if (!SWIG_IsOK(res1)) {
19283 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_notations_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19284 : }
19285 28 : arg1 = (struct _gpgme_signature *)(argp1);
19286 28 : result = (gpgme_sig_notation_t) ((arg1)->notations);
19287 : {
19288 : int i;
19289 28 : int size = 0;
19290 : gpgme_sig_notation_t curr;
19291 58 : for (curr = result; curr != NULL; curr = curr->next) {
19292 30 : size++;
19293 : }
19294 28 : resultobj = PyList_New(size);
19295 58 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
19296 30 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
19297 30 : PyList_SetItem(resultobj, i, o);
19298 : }
19299 : }
19300 : return resultobj;
19301 : fail:
19302 : return NULL;
19303 : }
19304 :
19305 :
19306 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_timestamp_set(PyObject *self, PyObject *args) {
19307 0 : PyObject *resultobj = 0;
19308 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19309 : unsigned long arg2 ;
19310 0 : void *argp1 = 0 ;
19311 0 : int res1 = 0 ;
19312 : unsigned long val2 ;
19313 0 : int ecode2 = 0 ;
19314 0 : PyObject * obj1 = 0 ;
19315 :
19316 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_timestamp_set",&obj1)) SWIG_fail;
19317 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19318 0 : if (!SWIG_IsOK(res1)) {
19319 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19320 : }
19321 0 : arg1 = (struct _gpgme_signature *)(argp1);
19322 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19323 0 : if (!SWIG_IsOK(ecode2)) {
19324 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_timestamp_set" "', argument " "2"" of type '" "unsigned long""'");
19325 : }
19326 0 : arg2 = (unsigned long)(val2);
19327 0 : if (arg1) (arg1)->timestamp = arg2;
19328 0 : resultobj = SWIG_Py_Void();
19329 0 : return resultobj;
19330 : fail:
19331 : return NULL;
19332 : }
19333 :
19334 :
19335 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_timestamp_get(PyObject *self, PyObject *args) {
19336 14 : PyObject *resultobj = 0;
19337 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19338 14 : void *argp1 = 0 ;
19339 14 : int res1 = 0 ;
19340 : unsigned long result;
19341 :
19342 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19343 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19344 14 : if (!SWIG_IsOK(res1)) {
19345 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19346 : }
19347 14 : arg1 = (struct _gpgme_signature *)(argp1);
19348 14 : result = (unsigned long) ((arg1)->timestamp);
19349 14 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
19350 14 : return resultobj;
19351 : fail:
19352 : return NULL;
19353 : }
19354 :
19355 :
19356 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_exp_timestamp_set(PyObject *self, PyObject *args) {
19357 0 : PyObject *resultobj = 0;
19358 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19359 : unsigned long arg2 ;
19360 0 : void *argp1 = 0 ;
19361 0 : int res1 = 0 ;
19362 : unsigned long val2 ;
19363 0 : int ecode2 = 0 ;
19364 0 : PyObject * obj1 = 0 ;
19365 :
19366 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_exp_timestamp_set",&obj1)) SWIG_fail;
19367 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19368 0 : if (!SWIG_IsOK(res1)) {
19369 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_exp_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19370 : }
19371 0 : arg1 = (struct _gpgme_signature *)(argp1);
19372 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19373 0 : if (!SWIG_IsOK(ecode2)) {
19374 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_exp_timestamp_set" "', argument " "2"" of type '" "unsigned long""'");
19375 : }
19376 0 : arg2 = (unsigned long)(val2);
19377 0 : if (arg1) (arg1)->exp_timestamp = arg2;
19378 0 : resultobj = SWIG_Py_Void();
19379 0 : return resultobj;
19380 : fail:
19381 : return NULL;
19382 : }
19383 :
19384 :
19385 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_exp_timestamp_get(PyObject *self, PyObject *args) {
19386 14 : PyObject *resultobj = 0;
19387 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19388 14 : void *argp1 = 0 ;
19389 14 : int res1 = 0 ;
19390 : unsigned long result;
19391 :
19392 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19393 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19394 14 : if (!SWIG_IsOK(res1)) {
19395 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_exp_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19396 : }
19397 14 : arg1 = (struct _gpgme_signature *)(argp1);
19398 14 : result = (unsigned long) ((arg1)->exp_timestamp);
19399 14 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
19400 14 : return resultobj;
19401 : fail:
19402 : return NULL;
19403 : }
19404 :
19405 :
19406 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_wrong_key_usage_set(PyObject *self, PyObject *args) {
19407 0 : PyObject *resultobj = 0;
19408 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19409 : unsigned int arg2 ;
19410 0 : void *argp1 = 0 ;
19411 0 : int res1 = 0 ;
19412 : unsigned int val2 ;
19413 0 : int ecode2 = 0 ;
19414 0 : PyObject * obj1 = 0 ;
19415 :
19416 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_wrong_key_usage_set",&obj1)) SWIG_fail;
19417 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19418 0 : if (!SWIG_IsOK(res1)) {
19419 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_wrong_key_usage_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19420 : }
19421 0 : arg1 = (struct _gpgme_signature *)(argp1);
19422 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
19423 0 : if (!SWIG_IsOK(ecode2)) {
19424 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_wrong_key_usage_set" "', argument " "2"" of type '" "unsigned int""'");
19425 : }
19426 0 : arg2 = (unsigned int)(val2);
19427 0 : if (arg1) (arg1)->wrong_key_usage = arg2;
19428 0 : resultobj = SWIG_Py_Void();
19429 0 : return resultobj;
19430 : fail:
19431 : return NULL;
19432 : }
19433 :
19434 :
19435 28 : SWIGINTERN PyObject *_wrap__gpgme_signature_wrong_key_usage_get(PyObject *self, PyObject *args) {
19436 28 : PyObject *resultobj = 0;
19437 28 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19438 28 : void *argp1 = 0 ;
19439 28 : int res1 = 0 ;
19440 : unsigned int result;
19441 :
19442 28 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19443 28 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19444 28 : if (!SWIG_IsOK(res1)) {
19445 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_wrong_key_usage_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19446 : }
19447 28 : arg1 = (struct _gpgme_signature *)(argp1);
19448 28 : result = (unsigned int) ((arg1)->wrong_key_usage);
19449 28 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19450 28 : return resultobj;
19451 : fail:
19452 : return NULL;
19453 : }
19454 :
19455 :
19456 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_trust_set(PyObject *self, PyObject *args) {
19457 0 : PyObject *resultobj = 0;
19458 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19459 : unsigned int arg2 ;
19460 0 : void *argp1 = 0 ;
19461 0 : int res1 = 0 ;
19462 : unsigned int val2 ;
19463 0 : int ecode2 = 0 ;
19464 0 : PyObject * obj1 = 0 ;
19465 :
19466 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_pka_trust_set",&obj1)) SWIG_fail;
19467 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19468 0 : if (!SWIG_IsOK(res1)) {
19469 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_trust_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19470 : }
19471 0 : arg1 = (struct _gpgme_signature *)(argp1);
19472 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
19473 0 : if (!SWIG_IsOK(ecode2)) {
19474 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_pka_trust_set" "', argument " "2"" of type '" "unsigned int""'");
19475 : }
19476 0 : arg2 = (unsigned int)(val2);
19477 0 : if (arg1) (arg1)->pka_trust = arg2;
19478 0 : resultobj = SWIG_Py_Void();
19479 0 : return resultobj;
19480 : fail:
19481 : return NULL;
19482 : }
19483 :
19484 :
19485 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_trust_get(PyObject *self, PyObject *args) {
19486 14 : PyObject *resultobj = 0;
19487 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19488 14 : void *argp1 = 0 ;
19489 14 : int res1 = 0 ;
19490 : unsigned int result;
19491 :
19492 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19493 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19494 14 : if (!SWIG_IsOK(res1)) {
19495 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_trust_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19496 : }
19497 14 : arg1 = (struct _gpgme_signature *)(argp1);
19498 14 : result = (unsigned int) ((arg1)->pka_trust);
19499 14 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19500 14 : return resultobj;
19501 : fail:
19502 : return NULL;
19503 : }
19504 :
19505 :
19506 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_chain_model_set(PyObject *self, PyObject *args) {
19507 0 : PyObject *resultobj = 0;
19508 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19509 : unsigned int arg2 ;
19510 0 : void *argp1 = 0 ;
19511 0 : int res1 = 0 ;
19512 : unsigned int val2 ;
19513 0 : int ecode2 = 0 ;
19514 0 : PyObject * obj1 = 0 ;
19515 :
19516 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_chain_model_set",&obj1)) SWIG_fail;
19517 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19518 0 : if (!SWIG_IsOK(res1)) {
19519 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_chain_model_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19520 : }
19521 0 : arg1 = (struct _gpgme_signature *)(argp1);
19522 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
19523 0 : if (!SWIG_IsOK(ecode2)) {
19524 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_chain_model_set" "', argument " "2"" of type '" "unsigned int""'");
19525 : }
19526 0 : arg2 = (unsigned int)(val2);
19527 0 : if (arg1) (arg1)->chain_model = arg2;
19528 0 : resultobj = SWIG_Py_Void();
19529 0 : return resultobj;
19530 : fail:
19531 : return NULL;
19532 : }
19533 :
19534 :
19535 28 : SWIGINTERN PyObject *_wrap__gpgme_signature_chain_model_get(PyObject *self, PyObject *args) {
19536 28 : PyObject *resultobj = 0;
19537 28 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19538 28 : void *argp1 = 0 ;
19539 28 : int res1 = 0 ;
19540 : unsigned int result;
19541 :
19542 28 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19543 28 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19544 28 : if (!SWIG_IsOK(res1)) {
19545 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_chain_model_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19546 : }
19547 28 : arg1 = (struct _gpgme_signature *)(argp1);
19548 28 : result = (unsigned int) ((arg1)->chain_model);
19549 28 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19550 28 : return resultobj;
19551 : fail:
19552 : return NULL;
19553 : }
19554 :
19555 :
19556 0 : SWIGINTERN PyObject *_wrap__gpgme_signature__unused_set(PyObject *self, PyObject *args) {
19557 0 : PyObject *resultobj = 0;
19558 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19559 : int arg2 ;
19560 0 : void *argp1 = 0 ;
19561 0 : int res1 = 0 ;
19562 : int val2 ;
19563 0 : int ecode2 = 0 ;
19564 0 : PyObject * obj1 = 0 ;
19565 :
19566 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature__unused_set",&obj1)) SWIG_fail;
19567 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19568 0 : if (!SWIG_IsOK(res1)) {
19569 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature__unused_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19570 : }
19571 0 : arg1 = (struct _gpgme_signature *)(argp1);
19572 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
19573 0 : if (!SWIG_IsOK(ecode2)) {
19574 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature__unused_set" "', argument " "2"" of type '" "int""'");
19575 : }
19576 0 : arg2 = (int)(val2);
19577 0 : if (arg1) (arg1)->_unused = arg2;
19578 0 : resultobj = SWIG_Py_Void();
19579 0 : return resultobj;
19580 : fail:
19581 : return NULL;
19582 : }
19583 :
19584 :
19585 0 : SWIGINTERN PyObject *_wrap__gpgme_signature__unused_get(PyObject *self, PyObject *args) {
19586 0 : PyObject *resultobj = 0;
19587 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19588 0 : void *argp1 = 0 ;
19589 0 : int res1 = 0 ;
19590 : int result;
19591 :
19592 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19593 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19594 0 : if (!SWIG_IsOK(res1)) {
19595 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature__unused_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19596 : }
19597 0 : arg1 = (struct _gpgme_signature *)(argp1);
19598 0 : result = (int) ((arg1)->_unused);
19599 0 : resultobj = SWIG_From_int((int)(result));
19600 0 : return resultobj;
19601 : fail:
19602 : return NULL;
19603 : }
19604 :
19605 :
19606 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_set(PyObject *self, PyObject *args) {
19607 0 : PyObject *resultobj = 0;
19608 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19609 : gpgme_validity_t arg2 ;
19610 0 : void *argp1 = 0 ;
19611 0 : int res1 = 0 ;
19612 : int val2 ;
19613 0 : int ecode2 = 0 ;
19614 0 : PyObject * obj1 = 0 ;
19615 :
19616 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_validity_set",&obj1)) SWIG_fail;
19617 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19618 0 : if (!SWIG_IsOK(res1)) {
19619 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19620 : }
19621 0 : arg1 = (struct _gpgme_signature *)(argp1);
19622 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
19623 0 : if (!SWIG_IsOK(ecode2)) {
19624 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_validity_set" "', argument " "2"" of type '" "gpgme_validity_t""'");
19625 : }
19626 0 : arg2 = (gpgme_validity_t)(val2);
19627 0 : if (arg1) (arg1)->validity = arg2;
19628 0 : resultobj = SWIG_Py_Void();
19629 0 : return resultobj;
19630 : fail:
19631 : return NULL;
19632 : }
19633 :
19634 :
19635 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_get(PyObject *self, PyObject *args) {
19636 14 : PyObject *resultobj = 0;
19637 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19638 14 : void *argp1 = 0 ;
19639 14 : int res1 = 0 ;
19640 : gpgme_validity_t result;
19641 :
19642 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19643 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19644 14 : if (!SWIG_IsOK(res1)) {
19645 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19646 : }
19647 14 : arg1 = (struct _gpgme_signature *)(argp1);
19648 14 : result = (gpgme_validity_t) ((arg1)->validity);
19649 28 : resultobj = SWIG_From_int((int)(result));
19650 14 : return resultobj;
19651 : fail:
19652 : return NULL;
19653 : }
19654 :
19655 :
19656 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_reason_set(PyObject *self, PyObject *args) {
19657 0 : PyObject *resultobj = 0;
19658 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19659 : gpgme_error_t arg2 ;
19660 0 : void *argp1 = 0 ;
19661 0 : int res1 = 0 ;
19662 0 : PyObject * obj1 = 0 ;
19663 :
19664 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_validity_reason_set",&obj1)) SWIG_fail;
19665 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19666 0 : if (!SWIG_IsOK(res1)) {
19667 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_reason_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19668 : }
19669 0 : arg1 = (struct _gpgme_signature *)(argp1);
19670 : {
19671 0 : arg2 = PyLong_AsLong(obj1);
19672 : }
19673 0 : if (arg1) (arg1)->validity_reason = arg2;
19674 0 : resultobj = SWIG_Py_Void();
19675 0 : return resultobj;
19676 : fail:
19677 : return NULL;
19678 : }
19679 :
19680 :
19681 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_reason_get(PyObject *self, PyObject *args) {
19682 14 : PyObject *resultobj = 0;
19683 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19684 14 : void *argp1 = 0 ;
19685 14 : int res1 = 0 ;
19686 : gpgme_error_t result;
19687 :
19688 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19689 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19690 14 : if (!SWIG_IsOK(res1)) {
19691 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_reason_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19692 : }
19693 14 : arg1 = (struct _gpgme_signature *)(argp1);
19694 14 : result = ((arg1)->validity_reason);
19695 : {
19696 14 : resultobj = PyLong_FromLong(result);
19697 : }
19698 14 : return resultobj;
19699 : fail:
19700 : return NULL;
19701 : }
19702 :
19703 :
19704 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_pubkey_algo_set(PyObject *self, PyObject *args) {
19705 0 : PyObject *resultobj = 0;
19706 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19707 : gpgme_pubkey_algo_t arg2 ;
19708 0 : void *argp1 = 0 ;
19709 0 : int res1 = 0 ;
19710 : int val2 ;
19711 0 : int ecode2 = 0 ;
19712 0 : PyObject * obj1 = 0 ;
19713 :
19714 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_pubkey_algo_set",&obj1)) SWIG_fail;
19715 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19716 0 : if (!SWIG_IsOK(res1)) {
19717 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19718 : }
19719 0 : arg1 = (struct _gpgme_signature *)(argp1);
19720 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
19721 0 : if (!SWIG_IsOK(ecode2)) {
19722 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
19723 : }
19724 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
19725 0 : if (arg1) (arg1)->pubkey_algo = arg2;
19726 0 : resultobj = SWIG_Py_Void();
19727 0 : return resultobj;
19728 : fail:
19729 : return NULL;
19730 : }
19731 :
19732 :
19733 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_pubkey_algo_get(PyObject *self, PyObject *args) {
19734 14 : PyObject *resultobj = 0;
19735 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19736 14 : void *argp1 = 0 ;
19737 14 : int res1 = 0 ;
19738 : gpgme_pubkey_algo_t result;
19739 :
19740 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19741 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19742 14 : if (!SWIG_IsOK(res1)) {
19743 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19744 : }
19745 14 : arg1 = (struct _gpgme_signature *)(argp1);
19746 14 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
19747 28 : resultobj = SWIG_From_int((int)(result));
19748 14 : return resultobj;
19749 : fail:
19750 : return NULL;
19751 : }
19752 :
19753 :
19754 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_hash_algo_set(PyObject *self, PyObject *args) {
19755 0 : PyObject *resultobj = 0;
19756 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19757 : gpgme_hash_algo_t arg2 ;
19758 0 : void *argp1 = 0 ;
19759 0 : int res1 = 0 ;
19760 : int val2 ;
19761 0 : int ecode2 = 0 ;
19762 0 : PyObject * obj1 = 0 ;
19763 :
19764 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_hash_algo_set",&obj1)) SWIG_fail;
19765 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19766 0 : if (!SWIG_IsOK(res1)) {
19767 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_hash_algo_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19768 : }
19769 0 : arg1 = (struct _gpgme_signature *)(argp1);
19770 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
19771 0 : if (!SWIG_IsOK(ecode2)) {
19772 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_hash_algo_set" "', argument " "2"" of type '" "gpgme_hash_algo_t""'");
19773 : }
19774 0 : arg2 = (gpgme_hash_algo_t)(val2);
19775 0 : if (arg1) (arg1)->hash_algo = arg2;
19776 0 : resultobj = SWIG_Py_Void();
19777 0 : return resultobj;
19778 : fail:
19779 : return NULL;
19780 : }
19781 :
19782 :
19783 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_hash_algo_get(PyObject *self, PyObject *args) {
19784 14 : PyObject *resultobj = 0;
19785 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19786 14 : void *argp1 = 0 ;
19787 14 : int res1 = 0 ;
19788 : gpgme_hash_algo_t result;
19789 :
19790 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19791 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19792 14 : if (!SWIG_IsOK(res1)) {
19793 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_hash_algo_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19794 : }
19795 14 : arg1 = (struct _gpgme_signature *)(argp1);
19796 14 : result = (gpgme_hash_algo_t) ((arg1)->hash_algo);
19797 28 : resultobj = SWIG_From_int((int)(result));
19798 14 : return resultobj;
19799 : fail:
19800 : return NULL;
19801 : }
19802 :
19803 :
19804 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_address_set(PyObject *self, PyObject *args) {
19805 0 : PyObject *resultobj = 0;
19806 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19807 0 : char *arg2 = (char *) 0 ;
19808 0 : void *argp1 = 0 ;
19809 0 : int res1 = 0 ;
19810 : int res2 ;
19811 0 : char *buf2 = 0 ;
19812 0 : int alloc2 = 0 ;
19813 0 : PyObject * obj1 = 0 ;
19814 :
19815 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_pka_address_set",&obj1)) SWIG_fail;
19816 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19817 0 : if (!SWIG_IsOK(res1)) {
19818 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_address_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19819 : }
19820 0 : arg1 = (struct _gpgme_signature *)(argp1);
19821 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
19822 0 : if (!SWIG_IsOK(res2)) {
19823 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_pka_address_set" "', argument " "2"" of type '" "char *""'");
19824 : }
19825 0 : arg2 = (char *)(buf2);
19826 0 : if (arg1->pka_address) free((char*)arg1->pka_address);
19827 0 : if (arg2) {
19828 0 : size_t size = strlen((const char *)(arg2)) + 1;
19829 0 : arg1->pka_address = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
19830 : } else {
19831 0 : arg1->pka_address = 0;
19832 : }
19833 0 : resultobj = SWIG_Py_Void();
19834 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
19835 : return resultobj;
19836 : fail:
19837 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
19838 : return NULL;
19839 : }
19840 :
19841 :
19842 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_address_get(PyObject *self, PyObject *args) {
19843 14 : PyObject *resultobj = 0;
19844 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19845 14 : void *argp1 = 0 ;
19846 14 : int res1 = 0 ;
19847 14 : char *result = 0 ;
19848 :
19849 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19850 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19851 14 : if (!SWIG_IsOK(res1)) {
19852 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_address_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19853 : }
19854 14 : arg1 = (struct _gpgme_signature *)(argp1);
19855 14 : result = (char *) ((arg1)->pka_address);
19856 14 : resultobj = SWIG_FromCharPtr((const char *)result);
19857 14 : return resultobj;
19858 : fail:
19859 : return NULL;
19860 : }
19861 :
19862 :
19863 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_key_set(PyObject *self, PyObject *args) {
19864 0 : PyObject *resultobj = 0;
19865 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19866 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
19867 0 : void *argp1 = 0 ;
19868 0 : int res1 = 0 ;
19869 0 : void *argp2 = 0 ;
19870 0 : int res2 = 0 ;
19871 0 : PyObject * obj1 = 0 ;
19872 :
19873 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_key_set",&obj1)) SWIG_fail;
19874 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19875 0 : if (!SWIG_IsOK(res1)) {
19876 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_key_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19877 : }
19878 0 : arg1 = (struct _gpgme_signature *)(argp1);
19879 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, SWIG_POINTER_DISOWN | 0 );
19880 0 : if (!SWIG_IsOK(res2)) {
19881 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_key_set" "', argument " "2"" of type '" "gpgme_key_t""'");
19882 : }
19883 0 : arg2 = (gpgme_key_t)(argp2);
19884 0 : if (arg1) (arg1)->key = arg2;
19885 0 : resultobj = SWIG_Py_Void();
19886 0 : return resultobj;
19887 : fail:
19888 : return NULL;
19889 : }
19890 :
19891 :
19892 14 : SWIGINTERN PyObject *_wrap__gpgme_signature_key_get(PyObject *self, PyObject *args) {
19893 14 : PyObject *resultobj = 0;
19894 14 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19895 14 : void *argp1 = 0 ;
19896 14 : int res1 = 0 ;
19897 : gpgme_key_t result;
19898 :
19899 14 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19900 14 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
19901 14 : if (!SWIG_IsOK(res1)) {
19902 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_key_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19903 : }
19904 14 : arg1 = (struct _gpgme_signature *)(argp1);
19905 14 : result = (gpgme_key_t) ((arg1)->key);
19906 14 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, 0 | 0 );
19907 14 : return resultobj;
19908 : fail:
19909 : return NULL;
19910 : }
19911 :
19912 :
19913 0 : SWIGINTERN int _wrap_new__gpgme_signature(PyObject *self, PyObject *args) {
19914 0 : PyObject *resultobj = 0;
19915 0 : struct _gpgme_signature *result = 0 ;
19916 :
19917 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19918 0 : result = (struct _gpgme_signature *)calloc(1, sizeof(struct _gpgme_signature));
19919 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_signature, SWIG_BUILTIN_INIT | 0 );
19920 0 : return resultobj == Py_None ? -1 : 0;
19921 : fail:
19922 : return -1;
19923 : }
19924 :
19925 :
19926 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_signature(PyObject *self, PyObject *args) {
19927 0 : PyObject *resultobj = 0;
19928 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
19929 0 : void *argp1 = 0 ;
19930 0 : int res1 = 0 ;
19931 :
19932 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19933 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_signature, SWIG_POINTER_DISOWN | 0 );
19934 0 : if (!SWIG_IsOK(res1)) {
19935 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_signature" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
19936 : }
19937 0 : arg1 = (struct _gpgme_signature *)(argp1);
19938 0 : free((char *) arg1);
19939 0 : resultobj = SWIG_Py_Void();
19940 0 : return resultobj;
19941 : fail:
19942 : return NULL;
19943 : }
19944 :
19945 :
19946 0 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_signatures_set(PyObject *self, PyObject *args) {
19947 0 : PyObject *resultobj = 0;
19948 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
19949 0 : gpgme_signature_t arg2 = (gpgme_signature_t) 0 ;
19950 0 : void *argp1 = 0 ;
19951 0 : int res1 = 0 ;
19952 0 : void *argp2 = 0 ;
19953 0 : int res2 = 0 ;
19954 0 : PyObject * obj1 = 0 ;
19955 :
19956 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_verify_result_signatures_set",&obj1)) SWIG_fail;
19957 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
19958 0 : if (!SWIG_IsOK(res1)) {
19959 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_signatures_set" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
19960 : }
19961 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
19962 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_signature, SWIG_POINTER_DISOWN | 0 );
19963 0 : if (!SWIG_IsOK(res2)) {
19964 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_verify_result_signatures_set" "', argument " "2"" of type '" "gpgme_signature_t""'");
19965 : }
19966 0 : arg2 = (gpgme_signature_t)(argp2);
19967 0 : if (arg1) (arg1)->signatures = arg2;
19968 0 : resultobj = SWIG_Py_Void();
19969 0 : return resultobj;
19970 : fail:
19971 : return NULL;
19972 : }
19973 :
19974 :
19975 34 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_signatures_get(PyObject *self, PyObject *args) {
19976 34 : PyObject *resultobj = 0;
19977 34 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
19978 34 : void *argp1 = 0 ;
19979 34 : int res1 = 0 ;
19980 : gpgme_signature_t result;
19981 :
19982 34 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
19983 34 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
19984 34 : if (!SWIG_IsOK(res1)) {
19985 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_signatures_get" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
19986 : }
19987 34 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
19988 34 : result = (gpgme_signature_t) ((arg1)->signatures);
19989 : {
19990 : int i;
19991 34 : int size = 0;
19992 : gpgme_signature_t curr;
19993 62 : for (curr = result; curr != NULL; curr = curr->next) {
19994 28 : size++;
19995 : }
19996 34 : resultobj = PyList_New(size);
19997 62 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
19998 28 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_signature, 0 );
19999 28 : PyList_SetItem(resultobj, i, o);
20000 : }
20001 : }
20002 : return resultobj;
20003 : fail:
20004 : return NULL;
20005 : }
20006 :
20007 :
20008 0 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_file_name_set(PyObject *self, PyObject *args) {
20009 0 : PyObject *resultobj = 0;
20010 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
20011 0 : char *arg2 = (char *) 0 ;
20012 0 : void *argp1 = 0 ;
20013 0 : int res1 = 0 ;
20014 : int res2 ;
20015 0 : char *buf2 = 0 ;
20016 0 : int alloc2 = 0 ;
20017 0 : PyObject * obj1 = 0 ;
20018 :
20019 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_verify_result_file_name_set",&obj1)) SWIG_fail;
20020 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
20021 0 : if (!SWIG_IsOK(res1)) {
20022 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_file_name_set" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
20023 : }
20024 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
20025 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20026 0 : if (!SWIG_IsOK(res2)) {
20027 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_verify_result_file_name_set" "', argument " "2"" of type '" "char *""'");
20028 : }
20029 0 : arg2 = (char *)(buf2);
20030 0 : if (arg1->file_name) free((char*)arg1->file_name);
20031 0 : if (arg2) {
20032 0 : size_t size = strlen((const char *)(arg2)) + 1;
20033 0 : arg1->file_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
20034 : } else {
20035 0 : arg1->file_name = 0;
20036 : }
20037 0 : resultobj = SWIG_Py_Void();
20038 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20039 : return resultobj;
20040 : fail:
20041 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20042 : return NULL;
20043 : }
20044 :
20045 :
20046 17 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_file_name_get(PyObject *self, PyObject *args) {
20047 17 : PyObject *resultobj = 0;
20048 17 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
20049 17 : void *argp1 = 0 ;
20050 17 : int res1 = 0 ;
20051 17 : char *result = 0 ;
20052 :
20053 17 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
20054 17 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
20055 17 : if (!SWIG_IsOK(res1)) {
20056 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_file_name_get" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
20057 : }
20058 17 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
20059 17 : result = (char *) ((arg1)->file_name);
20060 17 : resultobj = SWIG_FromCharPtr((const char *)result);
20061 17 : return resultobj;
20062 : fail:
20063 : return NULL;
20064 : }
20065 :
20066 :
20067 0 : SWIGINTERN int _wrap_new__gpgme_op_verify_result(PyObject *self, PyObject *args) {
20068 0 : PyObject *resultobj = 0;
20069 0 : struct _gpgme_op_verify_result *result = 0 ;
20070 :
20071 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
20072 0 : result = (struct _gpgme_op_verify_result *)calloc(1, sizeof(struct _gpgme_op_verify_result));
20073 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_verify_result, SWIG_BUILTIN_INIT | 0 );
20074 0 : return resultobj == Py_None ? -1 : 0;
20075 : fail:
20076 : return -1;
20077 : }
20078 :
20079 :
20080 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_verify_result(PyObject *self, PyObject *args) {
20081 0 : PyObject *resultobj = 0;
20082 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
20083 0 : void *argp1 = 0 ;
20084 0 : int res1 = 0 ;
20085 :
20086 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
20087 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_verify_result, SWIG_POINTER_DISOWN | 0 );
20088 0 : if (!SWIG_IsOK(res1)) {
20089 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_verify_result" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
20090 : }
20091 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
20092 0 : free((char *) arg1);
20093 0 : resultobj = SWIG_Py_Void();
20094 0 : return resultobj;
20095 : fail:
20096 : return NULL;
20097 : }
20098 :
20099 :
20100 17 : SWIGINTERN PyObject *_wrap_gpgme_op_verify_result(PyObject *self, PyObject *args) {
20101 17 : PyObject *resultobj = 0;
20102 17 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
20103 17 : void *argp1 = 0 ;
20104 17 : int res1 = 0 ;
20105 17 : PyObject * obj0 = 0 ;
20106 : gpgme_verify_result_t result;
20107 :
20108 17 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_verify_result",&obj0)) SWIG_fail;
20109 17 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
20110 17 : if (!SWIG_IsOK(res1)) {
20111 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_verify_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
20112 : }
20113 17 : arg1 = (gpgme_ctx_t)(argp1);
20114 17 : result = (gpgme_verify_result_t)gpgme_op_verify_result(arg1);
20115 : {
20116 : PyObject *fragile;
20117 17 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_verify_result,
20118 : 0 );
20119 17 : resultobj = _pyme_wrap_result(fragile, "VerifyResult");
20120 17 : Py_DECREF(fragile);
20121 : }
20122 17 : return resultobj;
20123 : fail:
20124 : return NULL;
20125 : }
20126 :
20127 :
20128 1 : SWIGINTERN PyObject *_wrap_gpgme_op_verify_start(PyObject *self, PyObject *args) {
20129 1 : PyObject *resultobj = 0;
20130 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
20131 1 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
20132 1 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
20133 1 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
20134 1 : void *argp1 = 0 ;
20135 1 : int res1 = 0 ;
20136 1 : gpgme_data_t wrapper2 = NULL ;
20137 1 : PyObject *bytesio2 = NULL ;
20138 : Py_buffer view2 ;
20139 1 : int have_view2 = 0 ;
20140 1 : gpgme_data_t wrapper3 = NULL ;
20141 1 : PyObject *bytesio3 = NULL ;
20142 : Py_buffer view3 ;
20143 1 : int have_view3 = 0 ;
20144 1 : gpgme_data_t wrapper4 = NULL ;
20145 1 : PyObject *bytesio4 = NULL ;
20146 : Py_buffer view4 ;
20147 1 : int have_view4 = 0 ;
20148 1 : PyObject * obj0 = 0 ;
20149 1 : PyObject * obj1 = 0 ;
20150 1 : PyObject * obj2 = 0 ;
20151 1 : PyObject * obj3 = 0 ;
20152 : gpgme_error_t result;
20153 :
20154 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_verify_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20155 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
20156 1 : if (!SWIG_IsOK(res1)) {
20157 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_verify_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
20158 : }
20159 1 : arg1 = (gpgme_ctx_t)(argp1);
20160 : {
20161 : /* If we create a temporary wrapper2 object, we will store it in
20162 : wrapperN, where N is 2. Here in this fragment, SWIG will
20163 : automatically append 2. */
20164 : memset(&view2, 0, sizeof view2);
20165 1 : if (obj1 == Py_None)
20166 0 : arg2 = NULL;
20167 : else {
20168 : PyObject *pypointer;
20169 1 : pypointer = _pyme_obj2gpgme_data_t(obj1, 2, &wrapper2,
20170 : &bytesio2, &view2);
20171 1 : if (pypointer == NULL)
20172 : return NULL;
20173 1 : have_view2 = !! view2.obj;
20174 :
20175 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
20176 :
20177 : // Following code is from swig's python.swg
20178 :
20179 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
20180 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20181 0 : Py_DECREF(pypointer);
20182 : return NULL;
20183 : }
20184 1 : Py_DECREF(pypointer);
20185 : }
20186 : }
20187 : {
20188 : /* If we create a temporary wrapper3 object, we will store it in
20189 : wrapperN, where N is 3. Here in this fragment, SWIG will
20190 : automatically append 3. */
20191 : memset(&view3, 0, sizeof view3);
20192 1 : if (obj2 == Py_None)
20193 1 : arg3 = NULL;
20194 : else {
20195 : PyObject *pypointer;
20196 0 : pypointer = _pyme_obj2gpgme_data_t(obj2, 3, &wrapper3,
20197 : &bytesio3, &view3);
20198 0 : if (pypointer == NULL)
20199 : return NULL;
20200 0 : have_view3 = !! view3.obj;
20201 :
20202 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
20203 :
20204 : // Following code is from swig's python.swg
20205 :
20206 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
20207 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20208 0 : Py_DECREF(pypointer);
20209 : return NULL;
20210 : }
20211 0 : Py_DECREF(pypointer);
20212 : }
20213 : }
20214 : {
20215 : /* If we create a temporary wrapper4 object, we will store it in
20216 : wrapperN, where N is 4. Here in this fragment, SWIG will
20217 : automatically append 4. */
20218 : memset(&view4, 0, sizeof view4);
20219 1 : if (obj3 == Py_None)
20220 0 : arg4 = NULL;
20221 : else {
20222 : PyObject *pypointer;
20223 1 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
20224 : &bytesio4, &view4);
20225 1 : if (pypointer == NULL)
20226 : return NULL;
20227 1 : have_view4 = !! view4.obj;
20228 :
20229 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
20230 :
20231 : // Following code is from swig's python.swg
20232 :
20233 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
20234 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20235 0 : Py_DECREF(pypointer);
20236 : return NULL;
20237 : }
20238 1 : Py_DECREF(pypointer);
20239 : }
20240 : }
20241 1 : result = gpgme_op_verify_start(arg1,arg2,arg3,arg4);
20242 : {
20243 1 : resultobj = PyLong_FromLong(result);
20244 : }
20245 : {
20246 : /* See whether we need to update the Python buffer. */
20247 1 : if (resultobj && wrapper2 && view2.buf)
20248 : {
20249 : int dirty;
20250 0 : char *new_data = NULL;
20251 : size_t new_size;
20252 :
20253 :
20254 0 : new_data = wrapper2->data.mem.buffer;
20255 0 : new_size = wrapper2->data.mem.length;
20256 0 : dirty = new_data != NULL;
20257 :
20258 :
20259 :
20260 :
20261 :
20262 :
20263 :
20264 0 : if (dirty)
20265 : {
20266 : /* The buffer is dirty. */
20267 0 : if (view2.readonly)
20268 : {
20269 0 : Py_XDECREF(resultobj);
20270 0 : resultobj = NULL;
20271 0 : PyErr_SetString(PyExc_ValueError,
20272 : "cannot update read-only buffer");
20273 : }
20274 :
20275 : /* See if we need to truncate the buffer. */
20276 0 : if (resultobj && view2.len != new_size)
20277 : {
20278 0 : if (bytesio2 == NULL)
20279 : {
20280 0 : Py_XDECREF(resultobj);
20281 0 : resultobj = NULL;
20282 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20283 : }
20284 : else
20285 : {
20286 : PyObject *retval;
20287 0 : PyBuffer_Release(&view2);
20288 : assert(view2.obj == NULL);
20289 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
20290 : "l", (long) new_size);
20291 0 : if (retval == NULL)
20292 : {
20293 0 : Py_XDECREF(resultobj);
20294 : resultobj = NULL;
20295 : }
20296 : else
20297 : {
20298 0 : Py_DECREF(retval);
20299 :
20300 0 : retval = PyObject_CallMethod(bytesio2,
20301 : "getbuffer", NULL);
20302 0 : if (retval == NULL
20303 0 : || PyObject_GetBuffer(retval, &view2,
20304 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20305 : {
20306 0 : Py_XDECREF(resultobj);
20307 : resultobj = NULL;
20308 : }
20309 :
20310 0 : Py_XDECREF(retval);
20311 :
20312 0 : if (resultobj && view2.len
20313 0 : != new_size)
20314 : {
20315 0 : Py_XDECREF(resultobj);
20316 0 : resultobj = NULL;
20317 0 : PyErr_Format(PyExc_ValueError,
20318 : "Expected buffer of length %zu, got %zi",
20319 : new_size,
20320 : view2.len);
20321 : }
20322 : }
20323 : }
20324 : }
20325 0 : if (resultobj)
20326 0 : memcpy(view2.buf, new_data, new_size);
20327 : }
20328 :
20329 :
20330 :
20331 : }
20332 :
20333 : /* Free the temporary wrapper, if any. */
20334 1 : if (wrapper2)
20335 0 : gpgme_data_release(wrapper2);
20336 1 : Py_XDECREF (bytesio2);
20337 1 : if (have_view2 && view2.buf)
20338 0 : PyBuffer_Release(&view2);
20339 : }
20340 : {
20341 : /* See whether we need to update the Python buffer. */
20342 1 : if (resultobj && wrapper3 && view3.buf)
20343 : {
20344 : int dirty;
20345 0 : char *new_data = NULL;
20346 : size_t new_size;
20347 :
20348 :
20349 0 : new_data = wrapper3->data.mem.buffer;
20350 0 : new_size = wrapper3->data.mem.length;
20351 0 : dirty = new_data != NULL;
20352 :
20353 :
20354 :
20355 :
20356 :
20357 :
20358 :
20359 0 : if (dirty)
20360 : {
20361 : /* The buffer is dirty. */
20362 0 : if (view3.readonly)
20363 : {
20364 0 : Py_XDECREF(resultobj);
20365 0 : resultobj = NULL;
20366 0 : PyErr_SetString(PyExc_ValueError,
20367 : "cannot update read-only buffer");
20368 : }
20369 :
20370 : /* See if we need to truncate the buffer. */
20371 0 : if (resultobj && view3.len != new_size)
20372 : {
20373 0 : if (bytesio3 == NULL)
20374 : {
20375 0 : Py_XDECREF(resultobj);
20376 0 : resultobj = NULL;
20377 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20378 : }
20379 : else
20380 : {
20381 : PyObject *retval;
20382 0 : PyBuffer_Release(&view3);
20383 : assert(view3.obj == NULL);
20384 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
20385 : "l", (long) new_size);
20386 0 : if (retval == NULL)
20387 : {
20388 0 : Py_XDECREF(resultobj);
20389 : resultobj = NULL;
20390 : }
20391 : else
20392 : {
20393 0 : Py_DECREF(retval);
20394 :
20395 0 : retval = PyObject_CallMethod(bytesio3,
20396 : "getbuffer", NULL);
20397 0 : if (retval == NULL
20398 0 : || PyObject_GetBuffer(retval, &view3,
20399 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20400 : {
20401 0 : Py_XDECREF(resultobj);
20402 : resultobj = NULL;
20403 : }
20404 :
20405 0 : Py_XDECREF(retval);
20406 :
20407 0 : if (resultobj && view3.len
20408 0 : != new_size)
20409 : {
20410 0 : Py_XDECREF(resultobj);
20411 0 : resultobj = NULL;
20412 0 : PyErr_Format(PyExc_ValueError,
20413 : "Expected buffer of length %zu, got %zi",
20414 : new_size,
20415 : view3.len);
20416 : }
20417 : }
20418 : }
20419 : }
20420 0 : if (resultobj)
20421 0 : memcpy(view3.buf, new_data, new_size);
20422 : }
20423 :
20424 :
20425 :
20426 : }
20427 :
20428 : /* Free the temporary wrapper, if any. */
20429 1 : if (wrapper3)
20430 0 : gpgme_data_release(wrapper3);
20431 1 : Py_XDECREF (bytesio3);
20432 1 : if (have_view3 && view3.buf)
20433 0 : PyBuffer_Release(&view3);
20434 : }
20435 : {
20436 : /* See whether we need to update the Python buffer. */
20437 1 : if (resultobj && wrapper4 && view4.buf)
20438 : {
20439 : int dirty;
20440 0 : char *new_data = NULL;
20441 : size_t new_size;
20442 :
20443 :
20444 0 : new_data = wrapper4->data.mem.buffer;
20445 0 : new_size = wrapper4->data.mem.length;
20446 0 : dirty = new_data != NULL;
20447 :
20448 :
20449 :
20450 :
20451 :
20452 :
20453 :
20454 0 : if (dirty)
20455 : {
20456 : /* The buffer is dirty. */
20457 0 : if (view4.readonly)
20458 : {
20459 0 : Py_XDECREF(resultobj);
20460 0 : resultobj = NULL;
20461 0 : PyErr_SetString(PyExc_ValueError,
20462 : "cannot update read-only buffer");
20463 : }
20464 :
20465 : /* See if we need to truncate the buffer. */
20466 0 : if (resultobj && view4.len != new_size)
20467 : {
20468 0 : if (bytesio4 == NULL)
20469 : {
20470 0 : Py_XDECREF(resultobj);
20471 0 : resultobj = NULL;
20472 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20473 : }
20474 : else
20475 : {
20476 : PyObject *retval;
20477 0 : PyBuffer_Release(&view4);
20478 : assert(view4.obj == NULL);
20479 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
20480 : "l", (long) new_size);
20481 0 : if (retval == NULL)
20482 : {
20483 0 : Py_XDECREF(resultobj);
20484 : resultobj = NULL;
20485 : }
20486 : else
20487 : {
20488 0 : Py_DECREF(retval);
20489 :
20490 0 : retval = PyObject_CallMethod(bytesio4,
20491 : "getbuffer", NULL);
20492 0 : if (retval == NULL
20493 0 : || PyObject_GetBuffer(retval, &view4,
20494 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20495 : {
20496 0 : Py_XDECREF(resultobj);
20497 : resultobj = NULL;
20498 : }
20499 :
20500 0 : Py_XDECREF(retval);
20501 :
20502 0 : if (resultobj && view4.len
20503 0 : != new_size)
20504 : {
20505 0 : Py_XDECREF(resultobj);
20506 0 : resultobj = NULL;
20507 0 : PyErr_Format(PyExc_ValueError,
20508 : "Expected buffer of length %zu, got %zi",
20509 : new_size,
20510 : view4.len);
20511 : }
20512 : }
20513 : }
20514 : }
20515 0 : if (resultobj)
20516 0 : memcpy(view4.buf, new_data, new_size);
20517 : }
20518 :
20519 :
20520 :
20521 : }
20522 :
20523 : /* Free the temporary wrapper, if any. */
20524 1 : if (wrapper4)
20525 0 : gpgme_data_release(wrapper4);
20526 1 : Py_XDECREF (bytesio4);
20527 1 : if (have_view4 && view4.buf)
20528 0 : PyBuffer_Release(&view4);
20529 : }
20530 1 : return resultobj;
20531 : fail:
20532 : {
20533 : /* See whether we need to update the Python buffer. */
20534 : if (resultobj && wrapper2 && view2.buf)
20535 : {
20536 : int dirty;
20537 : char *new_data = NULL;
20538 : size_t new_size;
20539 :
20540 :
20541 : new_data = wrapper2->data.mem.buffer;
20542 : new_size = wrapper2->data.mem.length;
20543 : dirty = new_data != NULL;
20544 :
20545 :
20546 :
20547 :
20548 :
20549 :
20550 :
20551 : if (dirty)
20552 : {
20553 : /* The buffer is dirty. */
20554 : if (view2.readonly)
20555 : {
20556 : Py_XDECREF(resultobj);
20557 : resultobj = NULL;
20558 : PyErr_SetString(PyExc_ValueError,
20559 : "cannot update read-only buffer");
20560 : }
20561 :
20562 : /* See if we need to truncate the buffer. */
20563 : if (resultobj && view2.len != new_size)
20564 : {
20565 : if (bytesio2 == NULL)
20566 : {
20567 : Py_XDECREF(resultobj);
20568 : resultobj = NULL;
20569 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20570 : }
20571 : else
20572 : {
20573 : PyObject *retval;
20574 : PyBuffer_Release(&view2);
20575 : assert(view2.obj == NULL);
20576 : retval = PyObject_CallMethod(bytesio2, "truncate",
20577 : "l", (long) new_size);
20578 : if (retval == NULL)
20579 : {
20580 : Py_XDECREF(resultobj);
20581 : resultobj = NULL;
20582 : }
20583 : else
20584 : {
20585 : Py_DECREF(retval);
20586 :
20587 : retval = PyObject_CallMethod(bytesio2,
20588 : "getbuffer", NULL);
20589 : if (retval == NULL
20590 : || PyObject_GetBuffer(retval, &view2,
20591 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20592 : {
20593 : Py_XDECREF(resultobj);
20594 : resultobj = NULL;
20595 : }
20596 :
20597 : Py_XDECREF(retval);
20598 :
20599 : if (resultobj && view2.len
20600 : != new_size)
20601 : {
20602 : Py_XDECREF(resultobj);
20603 : resultobj = NULL;
20604 : PyErr_Format(PyExc_ValueError,
20605 : "Expected buffer of length %zu, got %zi",
20606 : new_size,
20607 : view2.len);
20608 : }
20609 : }
20610 : }
20611 : }
20612 : if (resultobj)
20613 : memcpy(view2.buf, new_data, new_size);
20614 : }
20615 :
20616 :
20617 :
20618 : }
20619 :
20620 : /* Free the temporary wrapper, if any. */
20621 0 : if (wrapper2)
20622 0 : gpgme_data_release(wrapper2);
20623 0 : Py_XDECREF (bytesio2);
20624 : if (have_view2 && view2.buf)
20625 : PyBuffer_Release(&view2);
20626 : }
20627 : {
20628 : /* See whether we need to update the Python buffer. */
20629 : if (resultobj && wrapper3 && view3.buf)
20630 : {
20631 : int dirty;
20632 : char *new_data = NULL;
20633 : size_t new_size;
20634 :
20635 :
20636 : new_data = wrapper3->data.mem.buffer;
20637 : new_size = wrapper3->data.mem.length;
20638 : dirty = new_data != NULL;
20639 :
20640 :
20641 :
20642 :
20643 :
20644 :
20645 :
20646 : if (dirty)
20647 : {
20648 : /* The buffer is dirty. */
20649 : if (view3.readonly)
20650 : {
20651 : Py_XDECREF(resultobj);
20652 : resultobj = NULL;
20653 : PyErr_SetString(PyExc_ValueError,
20654 : "cannot update read-only buffer");
20655 : }
20656 :
20657 : /* See if we need to truncate the buffer. */
20658 : if (resultobj && view3.len != new_size)
20659 : {
20660 : if (bytesio3 == NULL)
20661 : {
20662 : Py_XDECREF(resultobj);
20663 : resultobj = NULL;
20664 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20665 : }
20666 : else
20667 : {
20668 : PyObject *retval;
20669 : PyBuffer_Release(&view3);
20670 : assert(view3.obj == NULL);
20671 : retval = PyObject_CallMethod(bytesio3, "truncate",
20672 : "l", (long) new_size);
20673 : if (retval == NULL)
20674 : {
20675 : Py_XDECREF(resultobj);
20676 : resultobj = NULL;
20677 : }
20678 : else
20679 : {
20680 : Py_DECREF(retval);
20681 :
20682 : retval = PyObject_CallMethod(bytesio3,
20683 : "getbuffer", NULL);
20684 : if (retval == NULL
20685 : || PyObject_GetBuffer(retval, &view3,
20686 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20687 : {
20688 : Py_XDECREF(resultobj);
20689 : resultobj = NULL;
20690 : }
20691 :
20692 : Py_XDECREF(retval);
20693 :
20694 : if (resultobj && view3.len
20695 : != new_size)
20696 : {
20697 : Py_XDECREF(resultobj);
20698 : resultobj = NULL;
20699 : PyErr_Format(PyExc_ValueError,
20700 : "Expected buffer of length %zu, got %zi",
20701 : new_size,
20702 : view3.len);
20703 : }
20704 : }
20705 : }
20706 : }
20707 : if (resultobj)
20708 : memcpy(view3.buf, new_data, new_size);
20709 : }
20710 :
20711 :
20712 :
20713 : }
20714 :
20715 : /* Free the temporary wrapper, if any. */
20716 0 : if (wrapper3)
20717 0 : gpgme_data_release(wrapper3);
20718 0 : Py_XDECREF (bytesio3);
20719 : if (have_view3 && view3.buf)
20720 : PyBuffer_Release(&view3);
20721 : }
20722 : {
20723 : /* See whether we need to update the Python buffer. */
20724 : if (resultobj && wrapper4 && view4.buf)
20725 : {
20726 : int dirty;
20727 : char *new_data = NULL;
20728 : size_t new_size;
20729 :
20730 :
20731 : new_data = wrapper4->data.mem.buffer;
20732 : new_size = wrapper4->data.mem.length;
20733 : dirty = new_data != NULL;
20734 :
20735 :
20736 :
20737 :
20738 :
20739 :
20740 :
20741 : if (dirty)
20742 : {
20743 : /* The buffer is dirty. */
20744 : if (view4.readonly)
20745 : {
20746 : Py_XDECREF(resultobj);
20747 : resultobj = NULL;
20748 : PyErr_SetString(PyExc_ValueError,
20749 : "cannot update read-only buffer");
20750 : }
20751 :
20752 : /* See if we need to truncate the buffer. */
20753 : if (resultobj && view4.len != new_size)
20754 : {
20755 : if (bytesio4 == NULL)
20756 : {
20757 : Py_XDECREF(resultobj);
20758 : resultobj = NULL;
20759 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20760 : }
20761 : else
20762 : {
20763 : PyObject *retval;
20764 : PyBuffer_Release(&view4);
20765 : assert(view4.obj == NULL);
20766 : retval = PyObject_CallMethod(bytesio4, "truncate",
20767 : "l", (long) new_size);
20768 : if (retval == NULL)
20769 : {
20770 : Py_XDECREF(resultobj);
20771 : resultobj = NULL;
20772 : }
20773 : else
20774 : {
20775 : Py_DECREF(retval);
20776 :
20777 : retval = PyObject_CallMethod(bytesio4,
20778 : "getbuffer", NULL);
20779 : if (retval == NULL
20780 : || PyObject_GetBuffer(retval, &view4,
20781 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20782 : {
20783 : Py_XDECREF(resultobj);
20784 : resultobj = NULL;
20785 : }
20786 :
20787 : Py_XDECREF(retval);
20788 :
20789 : if (resultobj && view4.len
20790 : != new_size)
20791 : {
20792 : Py_XDECREF(resultobj);
20793 : resultobj = NULL;
20794 : PyErr_Format(PyExc_ValueError,
20795 : "Expected buffer of length %zu, got %zi",
20796 : new_size,
20797 : view4.len);
20798 : }
20799 : }
20800 : }
20801 : }
20802 : if (resultobj)
20803 : memcpy(view4.buf, new_data, new_size);
20804 : }
20805 :
20806 :
20807 :
20808 : }
20809 :
20810 : /* Free the temporary wrapper, if any. */
20811 0 : if (wrapper4)
20812 0 : gpgme_data_release(wrapper4);
20813 0 : Py_XDECREF (bytesio4);
20814 : if (have_view4 && view4.buf)
20815 : PyBuffer_Release(&view4);
20816 : }
20817 : return NULL;
20818 : }
20819 :
20820 :
20821 13 : SWIGINTERN PyObject *_wrap_gpgme_op_verify(PyObject *self, PyObject *args) {
20822 13 : PyObject *resultobj = 0;
20823 13 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
20824 13 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
20825 13 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
20826 13 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
20827 13 : void *argp1 = 0 ;
20828 13 : int res1 = 0 ;
20829 13 : gpgme_data_t wrapper2 = NULL ;
20830 13 : PyObject *bytesio2 = NULL ;
20831 : Py_buffer view2 ;
20832 13 : int have_view2 = 0 ;
20833 13 : gpgme_data_t wrapper3 = NULL ;
20834 13 : PyObject *bytesio3 = NULL ;
20835 : Py_buffer view3 ;
20836 13 : int have_view3 = 0 ;
20837 13 : gpgme_data_t wrapper4 = NULL ;
20838 13 : PyObject *bytesio4 = NULL ;
20839 : Py_buffer view4 ;
20840 13 : int have_view4 = 0 ;
20841 13 : PyObject * obj0 = 0 ;
20842 13 : PyObject * obj1 = 0 ;
20843 13 : PyObject * obj2 = 0 ;
20844 13 : PyObject * obj3 = 0 ;
20845 : gpgme_error_t result;
20846 :
20847 13 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_verify",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20848 13 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
20849 13 : if (!SWIG_IsOK(res1)) {
20850 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_verify" "', argument " "1"" of type '" "gpgme_ctx_t""'");
20851 : }
20852 13 : arg1 = (gpgme_ctx_t)(argp1);
20853 : {
20854 : /* If we create a temporary wrapper2 object, we will store it in
20855 : wrapperN, where N is 2. Here in this fragment, SWIG will
20856 : automatically append 2. */
20857 : memset(&view2, 0, sizeof view2);
20858 13 : if (obj1 == Py_None)
20859 0 : arg2 = NULL;
20860 : else {
20861 : PyObject *pypointer;
20862 13 : pypointer = _pyme_obj2gpgme_data_t(obj1, 2, &wrapper2,
20863 : &bytesio2, &view2);
20864 13 : if (pypointer == NULL)
20865 : return NULL;
20866 13 : have_view2 = !! view2.obj;
20867 :
20868 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
20869 :
20870 : // Following code is from swig's python.swg
20871 :
20872 13 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
20873 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20874 0 : Py_DECREF(pypointer);
20875 : return NULL;
20876 : }
20877 13 : Py_DECREF(pypointer);
20878 : }
20879 : }
20880 : {
20881 : /* If we create a temporary wrapper3 object, we will store it in
20882 : wrapperN, where N is 3. Here in this fragment, SWIG will
20883 : automatically append 3. */
20884 : memset(&view3, 0, sizeof view3);
20885 13 : if (obj2 == Py_None)
20886 7 : arg3 = NULL;
20887 : else {
20888 : PyObject *pypointer;
20889 6 : pypointer = _pyme_obj2gpgme_data_t(obj2, 3, &wrapper3,
20890 : &bytesio3, &view3);
20891 6 : if (pypointer == NULL)
20892 : return NULL;
20893 6 : have_view3 = !! view3.obj;
20894 :
20895 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
20896 :
20897 : // Following code is from swig's python.swg
20898 :
20899 6 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
20900 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20901 0 : Py_DECREF(pypointer);
20902 : return NULL;
20903 : }
20904 6 : Py_DECREF(pypointer);
20905 : }
20906 : }
20907 : {
20908 : /* If we create a temporary wrapper4 object, we will store it in
20909 : wrapperN, where N is 4. Here in this fragment, SWIG will
20910 : automatically append 4. */
20911 : memset(&view4, 0, sizeof view4);
20912 13 : if (obj3 == Py_None)
20913 6 : arg4 = NULL;
20914 : else {
20915 : PyObject *pypointer;
20916 7 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
20917 : &bytesio4, &view4);
20918 7 : if (pypointer == NULL)
20919 : return NULL;
20920 7 : have_view4 = !! view4.obj;
20921 :
20922 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
20923 :
20924 : // Following code is from swig's python.swg
20925 :
20926 7 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
20927 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20928 0 : Py_DECREF(pypointer);
20929 : return NULL;
20930 : }
20931 7 : Py_DECREF(pypointer);
20932 : }
20933 : }
20934 13 : result = gpgme_op_verify(arg1,arg2,arg3,arg4);
20935 : {
20936 13 : resultobj = PyLong_FromLong(result);
20937 : }
20938 : {
20939 : /* See whether we need to update the Python buffer. */
20940 13 : if (resultobj && wrapper2 && view2.buf)
20941 : {
20942 : int dirty;
20943 7 : char *new_data = NULL;
20944 : size_t new_size;
20945 :
20946 :
20947 7 : new_data = wrapper2->data.mem.buffer;
20948 7 : new_size = wrapper2->data.mem.length;
20949 7 : dirty = new_data != NULL;
20950 :
20951 :
20952 :
20953 :
20954 :
20955 :
20956 :
20957 7 : if (dirty)
20958 : {
20959 : /* The buffer is dirty. */
20960 0 : if (view2.readonly)
20961 : {
20962 0 : Py_XDECREF(resultobj);
20963 0 : resultobj = NULL;
20964 0 : PyErr_SetString(PyExc_ValueError,
20965 : "cannot update read-only buffer");
20966 : }
20967 :
20968 : /* See if we need to truncate the buffer. */
20969 0 : if (resultobj && view2.len != new_size)
20970 : {
20971 0 : if (bytesio2 == NULL)
20972 : {
20973 0 : Py_XDECREF(resultobj);
20974 0 : resultobj = NULL;
20975 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20976 : }
20977 : else
20978 : {
20979 : PyObject *retval;
20980 0 : PyBuffer_Release(&view2);
20981 : assert(view2.obj == NULL);
20982 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
20983 : "l", (long) new_size);
20984 0 : if (retval == NULL)
20985 : {
20986 0 : Py_XDECREF(resultobj);
20987 : resultobj = NULL;
20988 : }
20989 : else
20990 : {
20991 0 : Py_DECREF(retval);
20992 :
20993 0 : retval = PyObject_CallMethod(bytesio2,
20994 : "getbuffer", NULL);
20995 0 : if (retval == NULL
20996 0 : || PyObject_GetBuffer(retval, &view2,
20997 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20998 : {
20999 0 : Py_XDECREF(resultobj);
21000 : resultobj = NULL;
21001 : }
21002 :
21003 0 : Py_XDECREF(retval);
21004 :
21005 0 : if (resultobj && view2.len
21006 0 : != new_size)
21007 : {
21008 0 : Py_XDECREF(resultobj);
21009 0 : resultobj = NULL;
21010 0 : PyErr_Format(PyExc_ValueError,
21011 : "Expected buffer of length %zu, got %zi",
21012 : new_size,
21013 : view2.len);
21014 : }
21015 : }
21016 : }
21017 : }
21018 0 : if (resultobj)
21019 0 : memcpy(view2.buf, new_data, new_size);
21020 : }
21021 :
21022 :
21023 :
21024 : }
21025 :
21026 : /* Free the temporary wrapper, if any. */
21027 13 : if (wrapper2)
21028 8 : gpgme_data_release(wrapper2);
21029 13 : Py_XDECREF (bytesio2);
21030 13 : if (have_view2 && view2.buf)
21031 7 : PyBuffer_Release(&view2);
21032 : }
21033 : {
21034 : /* See whether we need to update the Python buffer. */
21035 13 : if (resultobj && wrapper3 && view3.buf)
21036 : {
21037 : int dirty;
21038 4 : char *new_data = NULL;
21039 : size_t new_size;
21040 :
21041 :
21042 4 : new_data = wrapper3->data.mem.buffer;
21043 4 : new_size = wrapper3->data.mem.length;
21044 4 : dirty = new_data != NULL;
21045 :
21046 :
21047 :
21048 :
21049 :
21050 :
21051 :
21052 4 : if (dirty)
21053 : {
21054 : /* The buffer is dirty. */
21055 0 : if (view3.readonly)
21056 : {
21057 0 : Py_XDECREF(resultobj);
21058 0 : resultobj = NULL;
21059 0 : PyErr_SetString(PyExc_ValueError,
21060 : "cannot update read-only buffer");
21061 : }
21062 :
21063 : /* See if we need to truncate the buffer. */
21064 0 : if (resultobj && view3.len != new_size)
21065 : {
21066 0 : if (bytesio3 == NULL)
21067 : {
21068 0 : Py_XDECREF(resultobj);
21069 0 : resultobj = NULL;
21070 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21071 : }
21072 : else
21073 : {
21074 : PyObject *retval;
21075 0 : PyBuffer_Release(&view3);
21076 : assert(view3.obj == NULL);
21077 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
21078 : "l", (long) new_size);
21079 0 : if (retval == NULL)
21080 : {
21081 0 : Py_XDECREF(resultobj);
21082 : resultobj = NULL;
21083 : }
21084 : else
21085 : {
21086 0 : Py_DECREF(retval);
21087 :
21088 0 : retval = PyObject_CallMethod(bytesio3,
21089 : "getbuffer", NULL);
21090 0 : if (retval == NULL
21091 0 : || PyObject_GetBuffer(retval, &view3,
21092 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21093 : {
21094 0 : Py_XDECREF(resultobj);
21095 : resultobj = NULL;
21096 : }
21097 :
21098 0 : Py_XDECREF(retval);
21099 :
21100 0 : if (resultobj && view3.len
21101 0 : != new_size)
21102 : {
21103 0 : Py_XDECREF(resultobj);
21104 0 : resultobj = NULL;
21105 0 : PyErr_Format(PyExc_ValueError,
21106 : "Expected buffer of length %zu, got %zi",
21107 : new_size,
21108 : view3.len);
21109 : }
21110 : }
21111 : }
21112 : }
21113 0 : if (resultobj)
21114 0 : memcpy(view3.buf, new_data, new_size);
21115 : }
21116 :
21117 :
21118 :
21119 : }
21120 :
21121 : /* Free the temporary wrapper, if any. */
21122 13 : if (wrapper3)
21123 4 : gpgme_data_release(wrapper3);
21124 13 : Py_XDECREF (bytesio3);
21125 13 : if (have_view3 && view3.buf)
21126 4 : PyBuffer_Release(&view3);
21127 : }
21128 : {
21129 : /* See whether we need to update the Python buffer. */
21130 13 : if (resultobj && wrapper4 && view4.buf)
21131 : {
21132 : int dirty;
21133 0 : char *new_data = NULL;
21134 : size_t new_size;
21135 :
21136 :
21137 0 : new_data = wrapper4->data.mem.buffer;
21138 0 : new_size = wrapper4->data.mem.length;
21139 0 : dirty = new_data != NULL;
21140 :
21141 :
21142 :
21143 :
21144 :
21145 :
21146 :
21147 0 : if (dirty)
21148 : {
21149 : /* The buffer is dirty. */
21150 0 : if (view4.readonly)
21151 : {
21152 0 : Py_XDECREF(resultobj);
21153 0 : resultobj = NULL;
21154 0 : PyErr_SetString(PyExc_ValueError,
21155 : "cannot update read-only buffer");
21156 : }
21157 :
21158 : /* See if we need to truncate the buffer. */
21159 0 : if (resultobj && view4.len != new_size)
21160 : {
21161 0 : if (bytesio4 == NULL)
21162 : {
21163 0 : Py_XDECREF(resultobj);
21164 0 : resultobj = NULL;
21165 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21166 : }
21167 : else
21168 : {
21169 : PyObject *retval;
21170 0 : PyBuffer_Release(&view4);
21171 : assert(view4.obj == NULL);
21172 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
21173 : "l", (long) new_size);
21174 0 : if (retval == NULL)
21175 : {
21176 0 : Py_XDECREF(resultobj);
21177 : resultobj = NULL;
21178 : }
21179 : else
21180 : {
21181 0 : Py_DECREF(retval);
21182 :
21183 0 : retval = PyObject_CallMethod(bytesio4,
21184 : "getbuffer", NULL);
21185 0 : if (retval == NULL
21186 0 : || PyObject_GetBuffer(retval, &view4,
21187 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21188 : {
21189 0 : Py_XDECREF(resultobj);
21190 : resultobj = NULL;
21191 : }
21192 :
21193 0 : Py_XDECREF(retval);
21194 :
21195 0 : if (resultobj && view4.len
21196 0 : != new_size)
21197 : {
21198 0 : Py_XDECREF(resultobj);
21199 0 : resultobj = NULL;
21200 0 : PyErr_Format(PyExc_ValueError,
21201 : "Expected buffer of length %zu, got %zi",
21202 : new_size,
21203 : view4.len);
21204 : }
21205 : }
21206 : }
21207 : }
21208 0 : if (resultobj)
21209 0 : memcpy(view4.buf, new_data, new_size);
21210 : }
21211 :
21212 :
21213 :
21214 : }
21215 :
21216 : /* Free the temporary wrapper, if any. */
21217 13 : if (wrapper4)
21218 1 : gpgme_data_release(wrapper4);
21219 13 : Py_XDECREF (bytesio4);
21220 13 : if (have_view4 && view4.buf)
21221 0 : PyBuffer_Release(&view4);
21222 : }
21223 13 : return resultobj;
21224 : fail:
21225 : {
21226 : /* See whether we need to update the Python buffer. */
21227 : if (resultobj && wrapper2 && view2.buf)
21228 : {
21229 : int dirty;
21230 : char *new_data = NULL;
21231 : size_t new_size;
21232 :
21233 :
21234 : new_data = wrapper2->data.mem.buffer;
21235 : new_size = wrapper2->data.mem.length;
21236 : dirty = new_data != NULL;
21237 :
21238 :
21239 :
21240 :
21241 :
21242 :
21243 :
21244 : if (dirty)
21245 : {
21246 : /* The buffer is dirty. */
21247 : if (view2.readonly)
21248 : {
21249 : Py_XDECREF(resultobj);
21250 : resultobj = NULL;
21251 : PyErr_SetString(PyExc_ValueError,
21252 : "cannot update read-only buffer");
21253 : }
21254 :
21255 : /* See if we need to truncate the buffer. */
21256 : if (resultobj && view2.len != new_size)
21257 : {
21258 : if (bytesio2 == NULL)
21259 : {
21260 : Py_XDECREF(resultobj);
21261 : resultobj = NULL;
21262 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21263 : }
21264 : else
21265 : {
21266 : PyObject *retval;
21267 : PyBuffer_Release(&view2);
21268 : assert(view2.obj == NULL);
21269 : retval = PyObject_CallMethod(bytesio2, "truncate",
21270 : "l", (long) new_size);
21271 : if (retval == NULL)
21272 : {
21273 : Py_XDECREF(resultobj);
21274 : resultobj = NULL;
21275 : }
21276 : else
21277 : {
21278 : Py_DECREF(retval);
21279 :
21280 : retval = PyObject_CallMethod(bytesio2,
21281 : "getbuffer", NULL);
21282 : if (retval == NULL
21283 : || PyObject_GetBuffer(retval, &view2,
21284 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21285 : {
21286 : Py_XDECREF(resultobj);
21287 : resultobj = NULL;
21288 : }
21289 :
21290 : Py_XDECREF(retval);
21291 :
21292 : if (resultobj && view2.len
21293 : != new_size)
21294 : {
21295 : Py_XDECREF(resultobj);
21296 : resultobj = NULL;
21297 : PyErr_Format(PyExc_ValueError,
21298 : "Expected buffer of length %zu, got %zi",
21299 : new_size,
21300 : view2.len);
21301 : }
21302 : }
21303 : }
21304 : }
21305 : if (resultobj)
21306 : memcpy(view2.buf, new_data, new_size);
21307 : }
21308 :
21309 :
21310 :
21311 : }
21312 :
21313 : /* Free the temporary wrapper, if any. */
21314 0 : if (wrapper2)
21315 0 : gpgme_data_release(wrapper2);
21316 0 : Py_XDECREF (bytesio2);
21317 : if (have_view2 && view2.buf)
21318 : PyBuffer_Release(&view2);
21319 : }
21320 : {
21321 : /* See whether we need to update the Python buffer. */
21322 : if (resultobj && wrapper3 && view3.buf)
21323 : {
21324 : int dirty;
21325 : char *new_data = NULL;
21326 : size_t new_size;
21327 :
21328 :
21329 : new_data = wrapper3->data.mem.buffer;
21330 : new_size = wrapper3->data.mem.length;
21331 : dirty = new_data != NULL;
21332 :
21333 :
21334 :
21335 :
21336 :
21337 :
21338 :
21339 : if (dirty)
21340 : {
21341 : /* The buffer is dirty. */
21342 : if (view3.readonly)
21343 : {
21344 : Py_XDECREF(resultobj);
21345 : resultobj = NULL;
21346 : PyErr_SetString(PyExc_ValueError,
21347 : "cannot update read-only buffer");
21348 : }
21349 :
21350 : /* See if we need to truncate the buffer. */
21351 : if (resultobj && view3.len != new_size)
21352 : {
21353 : if (bytesio3 == NULL)
21354 : {
21355 : Py_XDECREF(resultobj);
21356 : resultobj = NULL;
21357 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21358 : }
21359 : else
21360 : {
21361 : PyObject *retval;
21362 : PyBuffer_Release(&view3);
21363 : assert(view3.obj == NULL);
21364 : retval = PyObject_CallMethod(bytesio3, "truncate",
21365 : "l", (long) new_size);
21366 : if (retval == NULL)
21367 : {
21368 : Py_XDECREF(resultobj);
21369 : resultobj = NULL;
21370 : }
21371 : else
21372 : {
21373 : Py_DECREF(retval);
21374 :
21375 : retval = PyObject_CallMethod(bytesio3,
21376 : "getbuffer", NULL);
21377 : if (retval == NULL
21378 : || PyObject_GetBuffer(retval, &view3,
21379 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21380 : {
21381 : Py_XDECREF(resultobj);
21382 : resultobj = NULL;
21383 : }
21384 :
21385 : Py_XDECREF(retval);
21386 :
21387 : if (resultobj && view3.len
21388 : != new_size)
21389 : {
21390 : Py_XDECREF(resultobj);
21391 : resultobj = NULL;
21392 : PyErr_Format(PyExc_ValueError,
21393 : "Expected buffer of length %zu, got %zi",
21394 : new_size,
21395 : view3.len);
21396 : }
21397 : }
21398 : }
21399 : }
21400 : if (resultobj)
21401 : memcpy(view3.buf, new_data, new_size);
21402 : }
21403 :
21404 :
21405 :
21406 : }
21407 :
21408 : /* Free the temporary wrapper, if any. */
21409 0 : if (wrapper3)
21410 0 : gpgme_data_release(wrapper3);
21411 0 : Py_XDECREF (bytesio3);
21412 : if (have_view3 && view3.buf)
21413 : PyBuffer_Release(&view3);
21414 : }
21415 : {
21416 : /* See whether we need to update the Python buffer. */
21417 : if (resultobj && wrapper4 && view4.buf)
21418 : {
21419 : int dirty;
21420 : char *new_data = NULL;
21421 : size_t new_size;
21422 :
21423 :
21424 : new_data = wrapper4->data.mem.buffer;
21425 : new_size = wrapper4->data.mem.length;
21426 : dirty = new_data != NULL;
21427 :
21428 :
21429 :
21430 :
21431 :
21432 :
21433 :
21434 : if (dirty)
21435 : {
21436 : /* The buffer is dirty. */
21437 : if (view4.readonly)
21438 : {
21439 : Py_XDECREF(resultobj);
21440 : resultobj = NULL;
21441 : PyErr_SetString(PyExc_ValueError,
21442 : "cannot update read-only buffer");
21443 : }
21444 :
21445 : /* See if we need to truncate the buffer. */
21446 : if (resultobj && view4.len != new_size)
21447 : {
21448 : if (bytesio4 == NULL)
21449 : {
21450 : Py_XDECREF(resultobj);
21451 : resultobj = NULL;
21452 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21453 : }
21454 : else
21455 : {
21456 : PyObject *retval;
21457 : PyBuffer_Release(&view4);
21458 : assert(view4.obj == NULL);
21459 : retval = PyObject_CallMethod(bytesio4, "truncate",
21460 : "l", (long) new_size);
21461 : if (retval == NULL)
21462 : {
21463 : Py_XDECREF(resultobj);
21464 : resultobj = NULL;
21465 : }
21466 : else
21467 : {
21468 : Py_DECREF(retval);
21469 :
21470 : retval = PyObject_CallMethod(bytesio4,
21471 : "getbuffer", NULL);
21472 : if (retval == NULL
21473 : || PyObject_GetBuffer(retval, &view4,
21474 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21475 : {
21476 : Py_XDECREF(resultobj);
21477 : resultobj = NULL;
21478 : }
21479 :
21480 : Py_XDECREF(retval);
21481 :
21482 : if (resultobj && view4.len
21483 : != new_size)
21484 : {
21485 : Py_XDECREF(resultobj);
21486 : resultobj = NULL;
21487 : PyErr_Format(PyExc_ValueError,
21488 : "Expected buffer of length %zu, got %zi",
21489 : new_size,
21490 : view4.len);
21491 : }
21492 : }
21493 : }
21494 : }
21495 : if (resultobj)
21496 : memcpy(view4.buf, new_data, new_size);
21497 : }
21498 :
21499 :
21500 :
21501 : }
21502 :
21503 : /* Free the temporary wrapper, if any. */
21504 0 : if (wrapper4)
21505 0 : gpgme_data_release(wrapper4);
21506 0 : Py_XDECREF (bytesio4);
21507 : if (have_view4 && view4.buf)
21508 : PyBuffer_Release(&view4);
21509 : }
21510 : return NULL;
21511 : }
21512 :
21513 :
21514 0 : SWIGINTERN PyObject *_wrap__gpgme_import_status_fpr_set(PyObject *self, PyObject *args) {
21515 0 : PyObject *resultobj = 0;
21516 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
21517 0 : char *arg2 = (char *) 0 ;
21518 0 : void *argp1 = 0 ;
21519 0 : int res1 = 0 ;
21520 : int res2 ;
21521 0 : char *buf2 = 0 ;
21522 0 : int alloc2 = 0 ;
21523 0 : PyObject * obj1 = 0 ;
21524 :
21525 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_import_status_fpr_set",&obj1)) SWIG_fail;
21526 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
21527 0 : if (!SWIG_IsOK(res1)) {
21528 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_fpr_set" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
21529 : }
21530 0 : arg1 = (struct _gpgme_import_status *)(argp1);
21531 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21532 0 : if (!SWIG_IsOK(res2)) {
21533 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_import_status_fpr_set" "', argument " "2"" of type '" "char *""'");
21534 : }
21535 0 : arg2 = (char *)(buf2);
21536 0 : if (arg1->fpr) free((char*)arg1->fpr);
21537 0 : if (arg2) {
21538 0 : size_t size = strlen((const char *)(arg2)) + 1;
21539 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
21540 : } else {
21541 0 : arg1->fpr = 0;
21542 : }
21543 0 : resultobj = SWIG_Py_Void();
21544 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
21545 : return resultobj;
21546 : fail:
21547 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
21548 : return NULL;
21549 : }
21550 :
21551 :
21552 3 : SWIGINTERN PyObject *_wrap__gpgme_import_status_fpr_get(PyObject *self, PyObject *args) {
21553 3 : PyObject *resultobj = 0;
21554 3 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
21555 3 : void *argp1 = 0 ;
21556 3 : int res1 = 0 ;
21557 3 : char *result = 0 ;
21558 :
21559 3 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
21560 3 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
21561 3 : if (!SWIG_IsOK(res1)) {
21562 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_fpr_get" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
21563 : }
21564 3 : arg1 = (struct _gpgme_import_status *)(argp1);
21565 3 : result = (char *) ((arg1)->fpr);
21566 3 : resultobj = SWIG_FromCharPtr((const char *)result);
21567 3 : return resultobj;
21568 : fail:
21569 : return NULL;
21570 : }
21571 :
21572 :
21573 0 : SWIGINTERN PyObject *_wrap__gpgme_import_status_result_set(PyObject *self, PyObject *args) {
21574 0 : PyObject *resultobj = 0;
21575 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
21576 : gpgme_error_t arg2 ;
21577 0 : void *argp1 = 0 ;
21578 0 : int res1 = 0 ;
21579 0 : PyObject * obj1 = 0 ;
21580 :
21581 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_import_status_result_set",&obj1)) SWIG_fail;
21582 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
21583 0 : if (!SWIG_IsOK(res1)) {
21584 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_result_set" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
21585 : }
21586 0 : arg1 = (struct _gpgme_import_status *)(argp1);
21587 : {
21588 0 : arg2 = PyLong_AsLong(obj1);
21589 : }
21590 0 : if (arg1) (arg1)->result = arg2;
21591 0 : resultobj = SWIG_Py_Void();
21592 0 : return resultobj;
21593 : fail:
21594 : return NULL;
21595 : }
21596 :
21597 :
21598 3 : SWIGINTERN PyObject *_wrap__gpgme_import_status_result_get(PyObject *self, PyObject *args) {
21599 3 : PyObject *resultobj = 0;
21600 3 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
21601 3 : void *argp1 = 0 ;
21602 3 : int res1 = 0 ;
21603 : gpgme_error_t result;
21604 :
21605 3 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
21606 3 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
21607 3 : if (!SWIG_IsOK(res1)) {
21608 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_result_get" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
21609 : }
21610 3 : arg1 = (struct _gpgme_import_status *)(argp1);
21611 3 : result = ((arg1)->result);
21612 : {
21613 3 : resultobj = PyLong_FromLong(result);
21614 : }
21615 3 : return resultobj;
21616 : fail:
21617 : return NULL;
21618 : }
21619 :
21620 :
21621 0 : SWIGINTERN PyObject *_wrap__gpgme_import_status_status_set(PyObject *self, PyObject *args) {
21622 0 : PyObject *resultobj = 0;
21623 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
21624 : unsigned int arg2 ;
21625 0 : void *argp1 = 0 ;
21626 0 : int res1 = 0 ;
21627 : unsigned int val2 ;
21628 0 : int ecode2 = 0 ;
21629 0 : PyObject * obj1 = 0 ;
21630 :
21631 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_import_status_status_set",&obj1)) SWIG_fail;
21632 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
21633 0 : if (!SWIG_IsOK(res1)) {
21634 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_status_set" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
21635 : }
21636 0 : arg1 = (struct _gpgme_import_status *)(argp1);
21637 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
21638 0 : if (!SWIG_IsOK(ecode2)) {
21639 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_import_status_status_set" "', argument " "2"" of type '" "unsigned int""'");
21640 : }
21641 0 : arg2 = (unsigned int)(val2);
21642 0 : if (arg1) (arg1)->status = arg2;
21643 0 : resultobj = SWIG_Py_Void();
21644 0 : return resultobj;
21645 : fail:
21646 : return NULL;
21647 : }
21648 :
21649 :
21650 3 : SWIGINTERN PyObject *_wrap__gpgme_import_status_status_get(PyObject *self, PyObject *args) {
21651 3 : PyObject *resultobj = 0;
21652 3 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
21653 3 : void *argp1 = 0 ;
21654 3 : int res1 = 0 ;
21655 : unsigned int result;
21656 :
21657 3 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
21658 3 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
21659 3 : if (!SWIG_IsOK(res1)) {
21660 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_status_get" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
21661 : }
21662 3 : arg1 = (struct _gpgme_import_status *)(argp1);
21663 3 : result = (unsigned int) ((arg1)->status);
21664 3 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21665 3 : return resultobj;
21666 : fail:
21667 : return NULL;
21668 : }
21669 :
21670 :
21671 0 : SWIGINTERN int _wrap_new__gpgme_import_status(PyObject *self, PyObject *args) {
21672 0 : PyObject *resultobj = 0;
21673 0 : struct _gpgme_import_status *result = 0 ;
21674 :
21675 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
21676 0 : result = (struct _gpgme_import_status *)calloc(1, sizeof(struct _gpgme_import_status));
21677 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_import_status, SWIG_BUILTIN_INIT | 0 );
21678 0 : return resultobj == Py_None ? -1 : 0;
21679 : fail:
21680 : return -1;
21681 : }
21682 :
21683 :
21684 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_import_status(PyObject *self, PyObject *args) {
21685 0 : PyObject *resultobj = 0;
21686 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
21687 0 : void *argp1 = 0 ;
21688 0 : int res1 = 0 ;
21689 :
21690 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
21691 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_import_status, SWIG_POINTER_DISOWN | 0 );
21692 0 : if (!SWIG_IsOK(res1)) {
21693 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_import_status" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
21694 : }
21695 0 : arg1 = (struct _gpgme_import_status *)(argp1);
21696 0 : free((char *) arg1);
21697 0 : resultobj = SWIG_Py_Void();
21698 0 : return resultobj;
21699 : fail:
21700 : return NULL;
21701 : }
21702 :
21703 :
21704 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_considered_set(PyObject *self, PyObject *args) {
21705 0 : PyObject *resultobj = 0;
21706 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21707 : int arg2 ;
21708 0 : void *argp1 = 0 ;
21709 0 : int res1 = 0 ;
21710 : int val2 ;
21711 0 : int ecode2 = 0 ;
21712 0 : PyObject * obj1 = 0 ;
21713 :
21714 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_considered_set",&obj1)) SWIG_fail;
21715 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21716 0 : if (!SWIG_IsOK(res1)) {
21717 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_considered_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21718 : }
21719 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21720 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21721 0 : if (!SWIG_IsOK(ecode2)) {
21722 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_considered_set" "', argument " "2"" of type '" "int""'");
21723 : }
21724 0 : arg2 = (int)(val2);
21725 0 : if (arg1) (arg1)->considered = arg2;
21726 0 : resultobj = SWIG_Py_Void();
21727 0 : return resultobj;
21728 : fail:
21729 : return NULL;
21730 : }
21731 :
21732 :
21733 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_considered_get(PyObject *self, PyObject *args) {
21734 2 : PyObject *resultobj = 0;
21735 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21736 2 : void *argp1 = 0 ;
21737 2 : int res1 = 0 ;
21738 : int result;
21739 :
21740 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
21741 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21742 2 : if (!SWIG_IsOK(res1)) {
21743 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_considered_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21744 : }
21745 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21746 2 : result = (int) ((arg1)->considered);
21747 2 : resultobj = SWIG_From_int((int)(result));
21748 2 : return resultobj;
21749 : fail:
21750 : return NULL;
21751 : }
21752 :
21753 :
21754 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_no_user_id_set(PyObject *self, PyObject *args) {
21755 0 : PyObject *resultobj = 0;
21756 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21757 : int arg2 ;
21758 0 : void *argp1 = 0 ;
21759 0 : int res1 = 0 ;
21760 : int val2 ;
21761 0 : int ecode2 = 0 ;
21762 0 : PyObject * obj1 = 0 ;
21763 :
21764 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_no_user_id_set",&obj1)) SWIG_fail;
21765 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21766 0 : if (!SWIG_IsOK(res1)) {
21767 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_no_user_id_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21768 : }
21769 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21770 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21771 0 : if (!SWIG_IsOK(ecode2)) {
21772 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_no_user_id_set" "', argument " "2"" of type '" "int""'");
21773 : }
21774 0 : arg2 = (int)(val2);
21775 0 : if (arg1) (arg1)->no_user_id = arg2;
21776 0 : resultobj = SWIG_Py_Void();
21777 0 : return resultobj;
21778 : fail:
21779 : return NULL;
21780 : }
21781 :
21782 :
21783 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_no_user_id_get(PyObject *self, PyObject *args) {
21784 2 : PyObject *resultobj = 0;
21785 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21786 2 : void *argp1 = 0 ;
21787 2 : int res1 = 0 ;
21788 : int result;
21789 :
21790 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
21791 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21792 2 : if (!SWIG_IsOK(res1)) {
21793 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_no_user_id_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21794 : }
21795 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21796 2 : result = (int) ((arg1)->no_user_id);
21797 2 : resultobj = SWIG_From_int((int)(result));
21798 2 : return resultobj;
21799 : fail:
21800 : return NULL;
21801 : }
21802 :
21803 :
21804 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_set(PyObject *self, PyObject *args) {
21805 0 : PyObject *resultobj = 0;
21806 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21807 : int arg2 ;
21808 0 : void *argp1 = 0 ;
21809 0 : int res1 = 0 ;
21810 : int val2 ;
21811 0 : int ecode2 = 0 ;
21812 0 : PyObject * obj1 = 0 ;
21813 :
21814 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_imported_set",&obj1)) SWIG_fail;
21815 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21816 0 : if (!SWIG_IsOK(res1)) {
21817 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imported_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21818 : }
21819 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21820 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21821 0 : if (!SWIG_IsOK(ecode2)) {
21822 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_imported_set" "', argument " "2"" of type '" "int""'");
21823 : }
21824 0 : arg2 = (int)(val2);
21825 0 : if (arg1) (arg1)->imported = arg2;
21826 0 : resultobj = SWIG_Py_Void();
21827 0 : return resultobj;
21828 : fail:
21829 : return NULL;
21830 : }
21831 :
21832 :
21833 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_get(PyObject *self, PyObject *args) {
21834 2 : PyObject *resultobj = 0;
21835 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21836 2 : void *argp1 = 0 ;
21837 2 : int res1 = 0 ;
21838 : int result;
21839 :
21840 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
21841 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21842 2 : if (!SWIG_IsOK(res1)) {
21843 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imported_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21844 : }
21845 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21846 2 : result = (int) ((arg1)->imported);
21847 2 : resultobj = SWIG_From_int((int)(result));
21848 2 : return resultobj;
21849 : fail:
21850 : return NULL;
21851 : }
21852 :
21853 :
21854 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_rsa_set(PyObject *self, PyObject *args) {
21855 0 : PyObject *resultobj = 0;
21856 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21857 : int arg2 ;
21858 0 : void *argp1 = 0 ;
21859 0 : int res1 = 0 ;
21860 : int val2 ;
21861 0 : int ecode2 = 0 ;
21862 0 : PyObject * obj1 = 0 ;
21863 :
21864 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_imported_rsa_set",&obj1)) SWIG_fail;
21865 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21866 0 : if (!SWIG_IsOK(res1)) {
21867 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imported_rsa_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21868 : }
21869 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21870 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21871 0 : if (!SWIG_IsOK(ecode2)) {
21872 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_imported_rsa_set" "', argument " "2"" of type '" "int""'");
21873 : }
21874 0 : arg2 = (int)(val2);
21875 0 : if (arg1) (arg1)->imported_rsa = arg2;
21876 0 : resultobj = SWIG_Py_Void();
21877 0 : return resultobj;
21878 : fail:
21879 : return NULL;
21880 : }
21881 :
21882 :
21883 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_rsa_get(PyObject *self, PyObject *args) {
21884 2 : PyObject *resultobj = 0;
21885 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21886 2 : void *argp1 = 0 ;
21887 2 : int res1 = 0 ;
21888 : int result;
21889 :
21890 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
21891 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21892 2 : if (!SWIG_IsOK(res1)) {
21893 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imported_rsa_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21894 : }
21895 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21896 2 : result = (int) ((arg1)->imported_rsa);
21897 2 : resultobj = SWIG_From_int((int)(result));
21898 2 : return resultobj;
21899 : fail:
21900 : return NULL;
21901 : }
21902 :
21903 :
21904 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_unchanged_set(PyObject *self, PyObject *args) {
21905 0 : PyObject *resultobj = 0;
21906 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21907 : int arg2 ;
21908 0 : void *argp1 = 0 ;
21909 0 : int res1 = 0 ;
21910 : int val2 ;
21911 0 : int ecode2 = 0 ;
21912 0 : PyObject * obj1 = 0 ;
21913 :
21914 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_unchanged_set",&obj1)) SWIG_fail;
21915 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21916 0 : if (!SWIG_IsOK(res1)) {
21917 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_unchanged_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21918 : }
21919 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21920 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21921 0 : if (!SWIG_IsOK(ecode2)) {
21922 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_unchanged_set" "', argument " "2"" of type '" "int""'");
21923 : }
21924 0 : arg2 = (int)(val2);
21925 0 : if (arg1) (arg1)->unchanged = arg2;
21926 0 : resultobj = SWIG_Py_Void();
21927 0 : return resultobj;
21928 : fail:
21929 : return NULL;
21930 : }
21931 :
21932 :
21933 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_unchanged_get(PyObject *self, PyObject *args) {
21934 2 : PyObject *resultobj = 0;
21935 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21936 2 : void *argp1 = 0 ;
21937 2 : int res1 = 0 ;
21938 : int result;
21939 :
21940 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
21941 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21942 2 : if (!SWIG_IsOK(res1)) {
21943 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_unchanged_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21944 : }
21945 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21946 2 : result = (int) ((arg1)->unchanged);
21947 2 : resultobj = SWIG_From_int((int)(result));
21948 2 : return resultobj;
21949 : fail:
21950 : return NULL;
21951 : }
21952 :
21953 :
21954 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_user_ids_set(PyObject *self, PyObject *args) {
21955 0 : PyObject *resultobj = 0;
21956 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21957 : int arg2 ;
21958 0 : void *argp1 = 0 ;
21959 0 : int res1 = 0 ;
21960 : int val2 ;
21961 0 : int ecode2 = 0 ;
21962 0 : PyObject * obj1 = 0 ;
21963 :
21964 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_user_ids_set",&obj1)) SWIG_fail;
21965 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21966 0 : if (!SWIG_IsOK(res1)) {
21967 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_user_ids_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21968 : }
21969 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21970 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21971 0 : if (!SWIG_IsOK(ecode2)) {
21972 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_user_ids_set" "', argument " "2"" of type '" "int""'");
21973 : }
21974 0 : arg2 = (int)(val2);
21975 0 : if (arg1) (arg1)->new_user_ids = arg2;
21976 0 : resultobj = SWIG_Py_Void();
21977 0 : return resultobj;
21978 : fail:
21979 : return NULL;
21980 : }
21981 :
21982 :
21983 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_user_ids_get(PyObject *self, PyObject *args) {
21984 2 : PyObject *resultobj = 0;
21985 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
21986 2 : void *argp1 = 0 ;
21987 2 : int res1 = 0 ;
21988 : int result;
21989 :
21990 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
21991 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
21992 2 : if (!SWIG_IsOK(res1)) {
21993 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_user_ids_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
21994 : }
21995 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
21996 2 : result = (int) ((arg1)->new_user_ids);
21997 2 : resultobj = SWIG_From_int((int)(result));
21998 2 : return resultobj;
21999 : fail:
22000 : return NULL;
22001 : }
22002 :
22003 :
22004 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_sub_keys_set(PyObject *self, PyObject *args) {
22005 0 : PyObject *resultobj = 0;
22006 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22007 : int arg2 ;
22008 0 : void *argp1 = 0 ;
22009 0 : int res1 = 0 ;
22010 : int val2 ;
22011 0 : int ecode2 = 0 ;
22012 0 : PyObject * obj1 = 0 ;
22013 :
22014 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_sub_keys_set",&obj1)) SWIG_fail;
22015 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22016 0 : if (!SWIG_IsOK(res1)) {
22017 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_sub_keys_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22018 : }
22019 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22020 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22021 0 : if (!SWIG_IsOK(ecode2)) {
22022 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_sub_keys_set" "', argument " "2"" of type '" "int""'");
22023 : }
22024 0 : arg2 = (int)(val2);
22025 0 : if (arg1) (arg1)->new_sub_keys = arg2;
22026 0 : resultobj = SWIG_Py_Void();
22027 0 : return resultobj;
22028 : fail:
22029 : return NULL;
22030 : }
22031 :
22032 :
22033 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_sub_keys_get(PyObject *self, PyObject *args) {
22034 2 : PyObject *resultobj = 0;
22035 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22036 2 : void *argp1 = 0 ;
22037 2 : int res1 = 0 ;
22038 : int result;
22039 :
22040 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
22041 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22042 2 : if (!SWIG_IsOK(res1)) {
22043 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_sub_keys_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22044 : }
22045 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22046 2 : result = (int) ((arg1)->new_sub_keys);
22047 2 : resultobj = SWIG_From_int((int)(result));
22048 2 : return resultobj;
22049 : fail:
22050 : return NULL;
22051 : }
22052 :
22053 :
22054 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_signatures_set(PyObject *self, PyObject *args) {
22055 0 : PyObject *resultobj = 0;
22056 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22057 : int arg2 ;
22058 0 : void *argp1 = 0 ;
22059 0 : int res1 = 0 ;
22060 : int val2 ;
22061 0 : int ecode2 = 0 ;
22062 0 : PyObject * obj1 = 0 ;
22063 :
22064 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_signatures_set",&obj1)) SWIG_fail;
22065 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22066 0 : if (!SWIG_IsOK(res1)) {
22067 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_signatures_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22068 : }
22069 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22070 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22071 0 : if (!SWIG_IsOK(ecode2)) {
22072 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_signatures_set" "', argument " "2"" of type '" "int""'");
22073 : }
22074 0 : arg2 = (int)(val2);
22075 0 : if (arg1) (arg1)->new_signatures = arg2;
22076 0 : resultobj = SWIG_Py_Void();
22077 0 : return resultobj;
22078 : fail:
22079 : return NULL;
22080 : }
22081 :
22082 :
22083 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_signatures_get(PyObject *self, PyObject *args) {
22084 2 : PyObject *resultobj = 0;
22085 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22086 2 : void *argp1 = 0 ;
22087 2 : int res1 = 0 ;
22088 : int result;
22089 :
22090 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
22091 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22092 2 : if (!SWIG_IsOK(res1)) {
22093 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_signatures_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22094 : }
22095 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22096 2 : result = (int) ((arg1)->new_signatures);
22097 2 : resultobj = SWIG_From_int((int)(result));
22098 2 : return resultobj;
22099 : fail:
22100 : return NULL;
22101 : }
22102 :
22103 :
22104 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_revocations_set(PyObject *self, PyObject *args) {
22105 0 : PyObject *resultobj = 0;
22106 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22107 : int arg2 ;
22108 0 : void *argp1 = 0 ;
22109 0 : int res1 = 0 ;
22110 : int val2 ;
22111 0 : int ecode2 = 0 ;
22112 0 : PyObject * obj1 = 0 ;
22113 :
22114 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_revocations_set",&obj1)) SWIG_fail;
22115 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22116 0 : if (!SWIG_IsOK(res1)) {
22117 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_revocations_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22118 : }
22119 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22120 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22121 0 : if (!SWIG_IsOK(ecode2)) {
22122 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_revocations_set" "', argument " "2"" of type '" "int""'");
22123 : }
22124 0 : arg2 = (int)(val2);
22125 0 : if (arg1) (arg1)->new_revocations = arg2;
22126 0 : resultobj = SWIG_Py_Void();
22127 0 : return resultobj;
22128 : fail:
22129 : return NULL;
22130 : }
22131 :
22132 :
22133 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_revocations_get(PyObject *self, PyObject *args) {
22134 2 : PyObject *resultobj = 0;
22135 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22136 2 : void *argp1 = 0 ;
22137 2 : int res1 = 0 ;
22138 : int result;
22139 :
22140 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
22141 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22142 2 : if (!SWIG_IsOK(res1)) {
22143 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_revocations_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22144 : }
22145 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22146 2 : result = (int) ((arg1)->new_revocations);
22147 2 : resultobj = SWIG_From_int((int)(result));
22148 2 : return resultobj;
22149 : fail:
22150 : return NULL;
22151 : }
22152 :
22153 :
22154 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_read_set(PyObject *self, PyObject *args) {
22155 0 : PyObject *resultobj = 0;
22156 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22157 : int arg2 ;
22158 0 : void *argp1 = 0 ;
22159 0 : int res1 = 0 ;
22160 : int val2 ;
22161 0 : int ecode2 = 0 ;
22162 0 : PyObject * obj1 = 0 ;
22163 :
22164 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_secret_read_set",&obj1)) SWIG_fail;
22165 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22166 0 : if (!SWIG_IsOK(res1)) {
22167 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_read_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22168 : }
22169 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22170 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22171 0 : if (!SWIG_IsOK(ecode2)) {
22172 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_secret_read_set" "', argument " "2"" of type '" "int""'");
22173 : }
22174 0 : arg2 = (int)(val2);
22175 0 : if (arg1) (arg1)->secret_read = arg2;
22176 0 : resultobj = SWIG_Py_Void();
22177 0 : return resultobj;
22178 : fail:
22179 : return NULL;
22180 : }
22181 :
22182 :
22183 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_read_get(PyObject *self, PyObject *args) {
22184 2 : PyObject *resultobj = 0;
22185 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22186 2 : void *argp1 = 0 ;
22187 2 : int res1 = 0 ;
22188 : int result;
22189 :
22190 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
22191 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22192 2 : if (!SWIG_IsOK(res1)) {
22193 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_read_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22194 : }
22195 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22196 2 : result = (int) ((arg1)->secret_read);
22197 2 : resultobj = SWIG_From_int((int)(result));
22198 2 : return resultobj;
22199 : fail:
22200 : return NULL;
22201 : }
22202 :
22203 :
22204 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_imported_set(PyObject *self, PyObject *args) {
22205 0 : PyObject *resultobj = 0;
22206 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22207 : int arg2 ;
22208 0 : void *argp1 = 0 ;
22209 0 : int res1 = 0 ;
22210 : int val2 ;
22211 0 : int ecode2 = 0 ;
22212 0 : PyObject * obj1 = 0 ;
22213 :
22214 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_secret_imported_set",&obj1)) SWIG_fail;
22215 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22216 0 : if (!SWIG_IsOK(res1)) {
22217 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_imported_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22218 : }
22219 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22220 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22221 0 : if (!SWIG_IsOK(ecode2)) {
22222 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_secret_imported_set" "', argument " "2"" of type '" "int""'");
22223 : }
22224 0 : arg2 = (int)(val2);
22225 0 : if (arg1) (arg1)->secret_imported = arg2;
22226 0 : resultobj = SWIG_Py_Void();
22227 0 : return resultobj;
22228 : fail:
22229 : return NULL;
22230 : }
22231 :
22232 :
22233 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_imported_get(PyObject *self, PyObject *args) {
22234 2 : PyObject *resultobj = 0;
22235 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22236 2 : void *argp1 = 0 ;
22237 2 : int res1 = 0 ;
22238 : int result;
22239 :
22240 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
22241 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22242 2 : if (!SWIG_IsOK(res1)) {
22243 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_imported_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22244 : }
22245 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22246 2 : result = (int) ((arg1)->secret_imported);
22247 2 : resultobj = SWIG_From_int((int)(result));
22248 2 : return resultobj;
22249 : fail:
22250 : return NULL;
22251 : }
22252 :
22253 :
22254 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_unchanged_set(PyObject *self, PyObject *args) {
22255 0 : PyObject *resultobj = 0;
22256 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22257 : int arg2 ;
22258 0 : void *argp1 = 0 ;
22259 0 : int res1 = 0 ;
22260 : int val2 ;
22261 0 : int ecode2 = 0 ;
22262 0 : PyObject * obj1 = 0 ;
22263 :
22264 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_secret_unchanged_set",&obj1)) SWIG_fail;
22265 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22266 0 : if (!SWIG_IsOK(res1)) {
22267 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_unchanged_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22268 : }
22269 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22270 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22271 0 : if (!SWIG_IsOK(ecode2)) {
22272 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_secret_unchanged_set" "', argument " "2"" of type '" "int""'");
22273 : }
22274 0 : arg2 = (int)(val2);
22275 0 : if (arg1) (arg1)->secret_unchanged = arg2;
22276 0 : resultobj = SWIG_Py_Void();
22277 0 : return resultobj;
22278 : fail:
22279 : return NULL;
22280 : }
22281 :
22282 :
22283 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_unchanged_get(PyObject *self, PyObject *args) {
22284 2 : PyObject *resultobj = 0;
22285 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22286 2 : void *argp1 = 0 ;
22287 2 : int res1 = 0 ;
22288 : int result;
22289 :
22290 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
22291 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22292 2 : if (!SWIG_IsOK(res1)) {
22293 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_unchanged_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22294 : }
22295 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22296 2 : result = (int) ((arg1)->secret_unchanged);
22297 2 : resultobj = SWIG_From_int((int)(result));
22298 2 : return resultobj;
22299 : fail:
22300 : return NULL;
22301 : }
22302 :
22303 :
22304 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_skipped_new_keys_set(PyObject *self, PyObject *args) {
22305 0 : PyObject *resultobj = 0;
22306 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22307 : int arg2 ;
22308 0 : void *argp1 = 0 ;
22309 0 : int res1 = 0 ;
22310 : int val2 ;
22311 0 : int ecode2 = 0 ;
22312 0 : PyObject * obj1 = 0 ;
22313 :
22314 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_skipped_new_keys_set",&obj1)) SWIG_fail;
22315 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22316 0 : if (!SWIG_IsOK(res1)) {
22317 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_skipped_new_keys_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22318 : }
22319 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22320 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22321 0 : if (!SWIG_IsOK(ecode2)) {
22322 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_skipped_new_keys_set" "', argument " "2"" of type '" "int""'");
22323 : }
22324 0 : arg2 = (int)(val2);
22325 0 : if (arg1) (arg1)->skipped_new_keys = arg2;
22326 0 : resultobj = SWIG_Py_Void();
22327 0 : return resultobj;
22328 : fail:
22329 : return NULL;
22330 : }
22331 :
22332 :
22333 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_skipped_new_keys_get(PyObject *self, PyObject *args) {
22334 2 : PyObject *resultobj = 0;
22335 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22336 2 : void *argp1 = 0 ;
22337 2 : int res1 = 0 ;
22338 : int result;
22339 :
22340 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
22341 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22342 2 : if (!SWIG_IsOK(res1)) {
22343 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_skipped_new_keys_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22344 : }
22345 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22346 2 : result = (int) ((arg1)->skipped_new_keys);
22347 2 : resultobj = SWIG_From_int((int)(result));
22348 2 : return resultobj;
22349 : fail:
22350 : return NULL;
22351 : }
22352 :
22353 :
22354 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_not_imported_set(PyObject *self, PyObject *args) {
22355 0 : PyObject *resultobj = 0;
22356 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22357 : int arg2 ;
22358 0 : void *argp1 = 0 ;
22359 0 : int res1 = 0 ;
22360 : int val2 ;
22361 0 : int ecode2 = 0 ;
22362 0 : PyObject * obj1 = 0 ;
22363 :
22364 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_not_imported_set",&obj1)) SWIG_fail;
22365 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22366 0 : if (!SWIG_IsOK(res1)) {
22367 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_not_imported_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22368 : }
22369 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22370 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22371 0 : if (!SWIG_IsOK(ecode2)) {
22372 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_not_imported_set" "', argument " "2"" of type '" "int""'");
22373 : }
22374 0 : arg2 = (int)(val2);
22375 0 : if (arg1) (arg1)->not_imported = arg2;
22376 0 : resultobj = SWIG_Py_Void();
22377 0 : return resultobj;
22378 : fail:
22379 : return NULL;
22380 : }
22381 :
22382 :
22383 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_not_imported_get(PyObject *self, PyObject *args) {
22384 2 : PyObject *resultobj = 0;
22385 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22386 2 : void *argp1 = 0 ;
22387 2 : int res1 = 0 ;
22388 : int result;
22389 :
22390 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
22391 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22392 2 : if (!SWIG_IsOK(res1)) {
22393 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_not_imported_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22394 : }
22395 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22396 2 : result = (int) ((arg1)->not_imported);
22397 2 : resultobj = SWIG_From_int((int)(result));
22398 2 : return resultobj;
22399 : fail:
22400 : return NULL;
22401 : }
22402 :
22403 :
22404 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imports_set(PyObject *self, PyObject *args) {
22405 0 : PyObject *resultobj = 0;
22406 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22407 0 : gpgme_import_status_t arg2 = (gpgme_import_status_t) 0 ;
22408 0 : void *argp1 = 0 ;
22409 0 : int res1 = 0 ;
22410 0 : void *argp2 = 0 ;
22411 0 : int res2 = 0 ;
22412 0 : PyObject * obj1 = 0 ;
22413 :
22414 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_imports_set",&obj1)) SWIG_fail;
22415 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22416 0 : if (!SWIG_IsOK(res1)) {
22417 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imports_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22418 : }
22419 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22420 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_import_status, SWIG_POINTER_DISOWN | 0 );
22421 0 : if (!SWIG_IsOK(res2)) {
22422 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_import_result_imports_set" "', argument " "2"" of type '" "gpgme_import_status_t""'");
22423 : }
22424 0 : arg2 = (gpgme_import_status_t)(argp2);
22425 0 : if (arg1) (arg1)->imports = arg2;
22426 0 : resultobj = SWIG_Py_Void();
22427 0 : return resultobj;
22428 : fail:
22429 : return NULL;
22430 : }
22431 :
22432 :
22433 4 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imports_get(PyObject *self, PyObject *args) {
22434 4 : PyObject *resultobj = 0;
22435 4 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22436 4 : void *argp1 = 0 ;
22437 4 : int res1 = 0 ;
22438 : gpgme_import_status_t result;
22439 :
22440 4 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
22441 4 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
22442 4 : if (!SWIG_IsOK(res1)) {
22443 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imports_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22444 : }
22445 4 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22446 4 : result = (gpgme_import_status_t) ((arg1)->imports);
22447 : {
22448 : int i;
22449 4 : int size = 0;
22450 : gpgme_import_status_t curr;
22451 10 : for (curr = result; curr != NULL; curr = curr->next) {
22452 6 : size++;
22453 : }
22454 4 : resultobj = PyList_New(size);
22455 10 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
22456 6 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_import_status, 0 );
22457 6 : PyList_SetItem(resultobj, i, o);
22458 : }
22459 : }
22460 : return resultobj;
22461 : fail:
22462 : return NULL;
22463 : }
22464 :
22465 :
22466 0 : SWIGINTERN int _wrap_new__gpgme_op_import_result(PyObject *self, PyObject *args) {
22467 0 : PyObject *resultobj = 0;
22468 0 : struct _gpgme_op_import_result *result = 0 ;
22469 :
22470 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
22471 0 : result = (struct _gpgme_op_import_result *)calloc(1, sizeof(struct _gpgme_op_import_result));
22472 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_import_result, SWIG_BUILTIN_INIT | 0 );
22473 0 : return resultobj == Py_None ? -1 : 0;
22474 : fail:
22475 : return -1;
22476 : }
22477 :
22478 :
22479 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_import_result(PyObject *self, PyObject *args) {
22480 0 : PyObject *resultobj = 0;
22481 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
22482 0 : void *argp1 = 0 ;
22483 0 : int res1 = 0 ;
22484 :
22485 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
22486 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_import_result, SWIG_POINTER_DISOWN | 0 );
22487 0 : if (!SWIG_IsOK(res1)) {
22488 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_import_result" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
22489 : }
22490 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
22491 0 : free((char *) arg1);
22492 0 : resultobj = SWIG_Py_Void();
22493 0 : return resultobj;
22494 : fail:
22495 : return NULL;
22496 : }
22497 :
22498 :
22499 2 : SWIGINTERN PyObject *_wrap_gpgme_op_import_result(PyObject *self, PyObject *args) {
22500 2 : PyObject *resultobj = 0;
22501 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
22502 2 : void *argp1 = 0 ;
22503 2 : int res1 = 0 ;
22504 2 : PyObject * obj0 = 0 ;
22505 : gpgme_import_result_t result;
22506 :
22507 2 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_import_result",&obj0)) SWIG_fail;
22508 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
22509 2 : if (!SWIG_IsOK(res1)) {
22510 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
22511 : }
22512 2 : arg1 = (gpgme_ctx_t)(argp1);
22513 2 : result = (gpgme_import_result_t)gpgme_op_import_result(arg1);
22514 : {
22515 : PyObject *fragile;
22516 2 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_import_result,
22517 : 0 );
22518 2 : resultobj = _pyme_wrap_result(fragile, "ImportResult");
22519 2 : Py_DECREF(fragile);
22520 : }
22521 2 : return resultobj;
22522 : fail:
22523 : return NULL;
22524 : }
22525 :
22526 :
22527 0 : SWIGINTERN PyObject *_wrap_gpgme_op_import_start(PyObject *self, PyObject *args) {
22528 0 : PyObject *resultobj = 0;
22529 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
22530 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
22531 0 : void *argp1 = 0 ;
22532 0 : int res1 = 0 ;
22533 0 : gpgme_data_t wrapper2 = NULL ;
22534 0 : PyObject *bytesio2 = NULL ;
22535 : Py_buffer view2 ;
22536 0 : int have_view2 = 0 ;
22537 0 : PyObject * obj0 = 0 ;
22538 0 : PyObject * obj1 = 0 ;
22539 : gpgme_error_t result;
22540 :
22541 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import_start",&obj0,&obj1)) SWIG_fail;
22542 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
22543 0 : if (!SWIG_IsOK(res1)) {
22544 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
22545 : }
22546 0 : arg1 = (gpgme_ctx_t)(argp1);
22547 : {
22548 : /* If we create a temporary wrapper2 object, we will store it in
22549 : wrapperN, where N is 2. Here in this fragment, SWIG will
22550 : automatically append 2. */
22551 : memset(&view2, 0, sizeof view2);
22552 0 : if (obj1 == Py_None)
22553 0 : arg2 = NULL;
22554 : else {
22555 : PyObject *pypointer;
22556 0 : pypointer = _pyme_obj2gpgme_data_t(obj1, 2, &wrapper2,
22557 : &bytesio2, &view2);
22558 0 : if (pypointer == NULL)
22559 : return NULL;
22560 0 : have_view2 = !! view2.obj;
22561 :
22562 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
22563 :
22564 : // Following code is from swig's python.swg
22565 :
22566 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
22567 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
22568 0 : Py_DECREF(pypointer);
22569 : return NULL;
22570 : }
22571 0 : Py_DECREF(pypointer);
22572 : }
22573 : }
22574 0 : result = gpgme_op_import_start(arg1,arg2);
22575 : {
22576 0 : resultobj = PyLong_FromLong(result);
22577 : }
22578 : {
22579 : /* See whether we need to update the Python buffer. */
22580 0 : if (resultobj && wrapper2 && view2.buf)
22581 : {
22582 : int dirty;
22583 0 : char *new_data = NULL;
22584 : size_t new_size;
22585 :
22586 :
22587 0 : new_data = wrapper2->data.mem.buffer;
22588 0 : new_size = wrapper2->data.mem.length;
22589 0 : dirty = new_data != NULL;
22590 :
22591 :
22592 :
22593 :
22594 :
22595 :
22596 :
22597 0 : if (dirty)
22598 : {
22599 : /* The buffer is dirty. */
22600 0 : if (view2.readonly)
22601 : {
22602 0 : Py_XDECREF(resultobj);
22603 0 : resultobj = NULL;
22604 0 : PyErr_SetString(PyExc_ValueError,
22605 : "cannot update read-only buffer");
22606 : }
22607 :
22608 : /* See if we need to truncate the buffer. */
22609 0 : if (resultobj && view2.len != new_size)
22610 : {
22611 0 : if (bytesio2 == NULL)
22612 : {
22613 0 : Py_XDECREF(resultobj);
22614 0 : resultobj = NULL;
22615 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22616 : }
22617 : else
22618 : {
22619 : PyObject *retval;
22620 0 : PyBuffer_Release(&view2);
22621 : assert(view2.obj == NULL);
22622 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
22623 : "l", (long) new_size);
22624 0 : if (retval == NULL)
22625 : {
22626 0 : Py_XDECREF(resultobj);
22627 : resultobj = NULL;
22628 : }
22629 : else
22630 : {
22631 0 : Py_DECREF(retval);
22632 :
22633 0 : retval = PyObject_CallMethod(bytesio2,
22634 : "getbuffer", NULL);
22635 0 : if (retval == NULL
22636 0 : || PyObject_GetBuffer(retval, &view2,
22637 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22638 : {
22639 0 : Py_XDECREF(resultobj);
22640 : resultobj = NULL;
22641 : }
22642 :
22643 0 : Py_XDECREF(retval);
22644 :
22645 0 : if (resultobj && view2.len
22646 0 : != new_size)
22647 : {
22648 0 : Py_XDECREF(resultobj);
22649 0 : resultobj = NULL;
22650 0 : PyErr_Format(PyExc_ValueError,
22651 : "Expected buffer of length %zu, got %zi",
22652 : new_size,
22653 : view2.len);
22654 : }
22655 : }
22656 : }
22657 : }
22658 0 : if (resultobj)
22659 0 : memcpy(view2.buf, new_data, new_size);
22660 : }
22661 :
22662 :
22663 :
22664 : }
22665 :
22666 : /* Free the temporary wrapper, if any. */
22667 0 : if (wrapper2)
22668 0 : gpgme_data_release(wrapper2);
22669 0 : Py_XDECREF (bytesio2);
22670 0 : if (have_view2 && view2.buf)
22671 0 : PyBuffer_Release(&view2);
22672 : }
22673 0 : return resultobj;
22674 : fail:
22675 : {
22676 : /* See whether we need to update the Python buffer. */
22677 : if (resultobj && wrapper2 && view2.buf)
22678 : {
22679 : int dirty;
22680 : char *new_data = NULL;
22681 : size_t new_size;
22682 :
22683 :
22684 : new_data = wrapper2->data.mem.buffer;
22685 : new_size = wrapper2->data.mem.length;
22686 : dirty = new_data != NULL;
22687 :
22688 :
22689 :
22690 :
22691 :
22692 :
22693 :
22694 : if (dirty)
22695 : {
22696 : /* The buffer is dirty. */
22697 : if (view2.readonly)
22698 : {
22699 : Py_XDECREF(resultobj);
22700 : resultobj = NULL;
22701 : PyErr_SetString(PyExc_ValueError,
22702 : "cannot update read-only buffer");
22703 : }
22704 :
22705 : /* See if we need to truncate the buffer. */
22706 : if (resultobj && view2.len != new_size)
22707 : {
22708 : if (bytesio2 == NULL)
22709 : {
22710 : Py_XDECREF(resultobj);
22711 : resultobj = NULL;
22712 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22713 : }
22714 : else
22715 : {
22716 : PyObject *retval;
22717 : PyBuffer_Release(&view2);
22718 : assert(view2.obj == NULL);
22719 : retval = PyObject_CallMethod(bytesio2, "truncate",
22720 : "l", (long) new_size);
22721 : if (retval == NULL)
22722 : {
22723 : Py_XDECREF(resultobj);
22724 : resultobj = NULL;
22725 : }
22726 : else
22727 : {
22728 : Py_DECREF(retval);
22729 :
22730 : retval = PyObject_CallMethod(bytesio2,
22731 : "getbuffer", NULL);
22732 : if (retval == NULL
22733 : || PyObject_GetBuffer(retval, &view2,
22734 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22735 : {
22736 : Py_XDECREF(resultobj);
22737 : resultobj = NULL;
22738 : }
22739 :
22740 : Py_XDECREF(retval);
22741 :
22742 : if (resultobj && view2.len
22743 : != new_size)
22744 : {
22745 : Py_XDECREF(resultobj);
22746 : resultobj = NULL;
22747 : PyErr_Format(PyExc_ValueError,
22748 : "Expected buffer of length %zu, got %zi",
22749 : new_size,
22750 : view2.len);
22751 : }
22752 : }
22753 : }
22754 : }
22755 : if (resultobj)
22756 : memcpy(view2.buf, new_data, new_size);
22757 : }
22758 :
22759 :
22760 :
22761 : }
22762 :
22763 : /* Free the temporary wrapper, if any. */
22764 0 : if (wrapper2)
22765 0 : gpgme_data_release(wrapper2);
22766 0 : Py_XDECREF (bytesio2);
22767 : if (have_view2 && view2.buf)
22768 : PyBuffer_Release(&view2);
22769 : }
22770 : return NULL;
22771 : }
22772 :
22773 :
22774 4 : SWIGINTERN PyObject *_wrap_gpgme_op_import(PyObject *self, PyObject *args) {
22775 4 : PyObject *resultobj = 0;
22776 4 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
22777 4 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
22778 4 : void *argp1 = 0 ;
22779 4 : int res1 = 0 ;
22780 4 : gpgme_data_t wrapper2 = NULL ;
22781 4 : PyObject *bytesio2 = NULL ;
22782 : Py_buffer view2 ;
22783 4 : int have_view2 = 0 ;
22784 4 : PyObject * obj0 = 0 ;
22785 4 : PyObject * obj1 = 0 ;
22786 : gpgme_error_t result;
22787 :
22788 4 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import",&obj0,&obj1)) SWIG_fail;
22789 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
22790 4 : if (!SWIG_IsOK(res1)) {
22791 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import" "', argument " "1"" of type '" "gpgme_ctx_t""'");
22792 : }
22793 4 : arg1 = (gpgme_ctx_t)(argp1);
22794 : {
22795 : /* If we create a temporary wrapper2 object, we will store it in
22796 : wrapperN, where N is 2. Here in this fragment, SWIG will
22797 : automatically append 2. */
22798 : memset(&view2, 0, sizeof view2);
22799 4 : if (obj1 == Py_None)
22800 0 : arg2 = NULL;
22801 : else {
22802 : PyObject *pypointer;
22803 4 : pypointer = _pyme_obj2gpgme_data_t(obj1, 2, &wrapper2,
22804 : &bytesio2, &view2);
22805 4 : if (pypointer == NULL)
22806 : return NULL;
22807 4 : have_view2 = !! view2.obj;
22808 :
22809 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
22810 :
22811 : // Following code is from swig's python.swg
22812 :
22813 4 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
22814 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
22815 0 : Py_DECREF(pypointer);
22816 : return NULL;
22817 : }
22818 4 : Py_DECREF(pypointer);
22819 : }
22820 : }
22821 4 : result = gpgme_op_import(arg1,arg2);
22822 : {
22823 4 : resultobj = PyLong_FromLong(result);
22824 : }
22825 : {
22826 : /* See whether we need to update the Python buffer. */
22827 4 : if (resultobj && wrapper2 && view2.buf)
22828 : {
22829 : int dirty;
22830 0 : char *new_data = NULL;
22831 : size_t new_size;
22832 :
22833 :
22834 0 : new_data = wrapper2->data.mem.buffer;
22835 0 : new_size = wrapper2->data.mem.length;
22836 0 : dirty = new_data != NULL;
22837 :
22838 :
22839 :
22840 :
22841 :
22842 :
22843 :
22844 0 : if (dirty)
22845 : {
22846 : /* The buffer is dirty. */
22847 0 : if (view2.readonly)
22848 : {
22849 0 : Py_XDECREF(resultobj);
22850 0 : resultobj = NULL;
22851 0 : PyErr_SetString(PyExc_ValueError,
22852 : "cannot update read-only buffer");
22853 : }
22854 :
22855 : /* See if we need to truncate the buffer. */
22856 0 : if (resultobj && view2.len != new_size)
22857 : {
22858 0 : if (bytesio2 == NULL)
22859 : {
22860 0 : Py_XDECREF(resultobj);
22861 0 : resultobj = NULL;
22862 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22863 : }
22864 : else
22865 : {
22866 : PyObject *retval;
22867 0 : PyBuffer_Release(&view2);
22868 : assert(view2.obj == NULL);
22869 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
22870 : "l", (long) new_size);
22871 0 : if (retval == NULL)
22872 : {
22873 0 : Py_XDECREF(resultobj);
22874 : resultobj = NULL;
22875 : }
22876 : else
22877 : {
22878 0 : Py_DECREF(retval);
22879 :
22880 0 : retval = PyObject_CallMethod(bytesio2,
22881 : "getbuffer", NULL);
22882 0 : if (retval == NULL
22883 0 : || PyObject_GetBuffer(retval, &view2,
22884 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22885 : {
22886 0 : Py_XDECREF(resultobj);
22887 : resultobj = NULL;
22888 : }
22889 :
22890 0 : Py_XDECREF(retval);
22891 :
22892 0 : if (resultobj && view2.len
22893 0 : != new_size)
22894 : {
22895 0 : Py_XDECREF(resultobj);
22896 0 : resultobj = NULL;
22897 0 : PyErr_Format(PyExc_ValueError,
22898 : "Expected buffer of length %zu, got %zi",
22899 : new_size,
22900 : view2.len);
22901 : }
22902 : }
22903 : }
22904 : }
22905 0 : if (resultobj)
22906 0 : memcpy(view2.buf, new_data, new_size);
22907 : }
22908 :
22909 :
22910 :
22911 : }
22912 :
22913 : /* Free the temporary wrapper, if any. */
22914 4 : if (wrapper2)
22915 2 : gpgme_data_release(wrapper2);
22916 4 : Py_XDECREF (bytesio2);
22917 4 : if (have_view2 && view2.buf)
22918 0 : PyBuffer_Release(&view2);
22919 : }
22920 4 : return resultobj;
22921 : fail:
22922 : {
22923 : /* See whether we need to update the Python buffer. */
22924 : if (resultobj && wrapper2 && view2.buf)
22925 : {
22926 : int dirty;
22927 : char *new_data = NULL;
22928 : size_t new_size;
22929 :
22930 :
22931 : new_data = wrapper2->data.mem.buffer;
22932 : new_size = wrapper2->data.mem.length;
22933 : dirty = new_data != NULL;
22934 :
22935 :
22936 :
22937 :
22938 :
22939 :
22940 :
22941 : if (dirty)
22942 : {
22943 : /* The buffer is dirty. */
22944 : if (view2.readonly)
22945 : {
22946 : Py_XDECREF(resultobj);
22947 : resultobj = NULL;
22948 : PyErr_SetString(PyExc_ValueError,
22949 : "cannot update read-only buffer");
22950 : }
22951 :
22952 : /* See if we need to truncate the buffer. */
22953 : if (resultobj && view2.len != new_size)
22954 : {
22955 : if (bytesio2 == NULL)
22956 : {
22957 : Py_XDECREF(resultobj);
22958 : resultobj = NULL;
22959 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22960 : }
22961 : else
22962 : {
22963 : PyObject *retval;
22964 : PyBuffer_Release(&view2);
22965 : assert(view2.obj == NULL);
22966 : retval = PyObject_CallMethod(bytesio2, "truncate",
22967 : "l", (long) new_size);
22968 : if (retval == NULL)
22969 : {
22970 : Py_XDECREF(resultobj);
22971 : resultobj = NULL;
22972 : }
22973 : else
22974 : {
22975 : Py_DECREF(retval);
22976 :
22977 : retval = PyObject_CallMethod(bytesio2,
22978 : "getbuffer", NULL);
22979 : if (retval == NULL
22980 : || PyObject_GetBuffer(retval, &view2,
22981 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22982 : {
22983 : Py_XDECREF(resultobj);
22984 : resultobj = NULL;
22985 : }
22986 :
22987 : Py_XDECREF(retval);
22988 :
22989 : if (resultobj && view2.len
22990 : != new_size)
22991 : {
22992 : Py_XDECREF(resultobj);
22993 : resultobj = NULL;
22994 : PyErr_Format(PyExc_ValueError,
22995 : "Expected buffer of length %zu, got %zi",
22996 : new_size,
22997 : view2.len);
22998 : }
22999 : }
23000 : }
23001 : }
23002 : if (resultobj)
23003 : memcpy(view2.buf, new_data, new_size);
23004 : }
23005 :
23006 :
23007 :
23008 : }
23009 :
23010 : /* Free the temporary wrapper, if any. */
23011 0 : if (wrapper2)
23012 0 : gpgme_data_release(wrapper2);
23013 0 : Py_XDECREF (bytesio2);
23014 : if (have_view2 && view2.buf)
23015 : PyBuffer_Release(&view2);
23016 : }
23017 : return NULL;
23018 : }
23019 :
23020 :
23021 0 : SWIGINTERN PyObject *_wrap_gpgme_op_import_keys_start(PyObject *self, PyObject *args) {
23022 0 : PyObject *resultobj = 0;
23023 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
23024 : gpgme_key_t *arg2 ;
23025 0 : void *argp1 = 0 ;
23026 0 : int res1 = 0 ;
23027 0 : PyObject * obj0 = 0 ;
23028 0 : PyObject * obj1 = 0 ;
23029 : gpgme_error_t result;
23030 :
23031 : {
23032 0 : arg2 = NULL;
23033 : }
23034 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import_keys_start",&obj0,&obj1)) SWIG_fail;
23035 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
23036 0 : if (!SWIG_IsOK(res1)) {
23037 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_keys_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
23038 : }
23039 0 : arg1 = (gpgme_ctx_t)(argp1);
23040 : {
23041 0 : int i, numb = 0;
23042 0 : if (!PySequence_Check(obj1)) {
23043 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
23044 : 2);
23045 0 : return NULL;
23046 : }
23047 0 : if((numb = PySequence_Length(obj1)) != 0) {
23048 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
23049 0 : for(i=0; i<numb; i++) {
23050 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
23051 :
23052 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
23053 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
23054 :
23055 : // Following code is from swig's python.swg
23056 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
23057 0 : Py_DECREF(pypointer);
23058 : return NULL;
23059 : }
23060 0 : Py_DECREF(pypointer);
23061 : }
23062 0 : arg2[numb] = NULL;
23063 : }
23064 : }
23065 0 : result = gpgme_op_import_keys_start(arg1,arg2);
23066 : {
23067 0 : resultobj = PyLong_FromLong(result);
23068 : }
23069 : {
23070 0 : if (arg2) free(arg2);
23071 : }
23072 0 : return resultobj;
23073 : fail:
23074 : {
23075 : if (arg2) free(arg2);
23076 : }
23077 : return NULL;
23078 : }
23079 :
23080 :
23081 0 : SWIGINTERN PyObject *_wrap_gpgme_op_import_keys(PyObject *self, PyObject *args) {
23082 0 : PyObject *resultobj = 0;
23083 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
23084 : gpgme_key_t *arg2 ;
23085 0 : void *argp1 = 0 ;
23086 0 : int res1 = 0 ;
23087 0 : PyObject * obj0 = 0 ;
23088 0 : PyObject * obj1 = 0 ;
23089 : gpgme_error_t result;
23090 :
23091 : {
23092 0 : arg2 = NULL;
23093 : }
23094 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import_keys",&obj0,&obj1)) SWIG_fail;
23095 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
23096 0 : if (!SWIG_IsOK(res1)) {
23097 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_keys" "', argument " "1"" of type '" "gpgme_ctx_t""'");
23098 : }
23099 0 : arg1 = (gpgme_ctx_t)(argp1);
23100 : {
23101 0 : int i, numb = 0;
23102 0 : if (!PySequence_Check(obj1)) {
23103 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
23104 : 2);
23105 0 : return NULL;
23106 : }
23107 0 : if((numb = PySequence_Length(obj1)) != 0) {
23108 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
23109 0 : for(i=0; i<numb; i++) {
23110 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
23111 :
23112 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
23113 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
23114 :
23115 : // Following code is from swig's python.swg
23116 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
23117 0 : Py_DECREF(pypointer);
23118 : return NULL;
23119 : }
23120 0 : Py_DECREF(pypointer);
23121 : }
23122 0 : arg2[numb] = NULL;
23123 : }
23124 : }
23125 0 : result = gpgme_op_import_keys(arg1,arg2);
23126 : {
23127 0 : resultobj = PyLong_FromLong(result);
23128 : }
23129 : {
23130 0 : if (arg2) free(arg2);
23131 : }
23132 0 : return resultobj;
23133 : fail:
23134 : {
23135 : if (arg2) free(arg2);
23136 : }
23137 : return NULL;
23138 : }
23139 :
23140 :
23141 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export_start(PyObject *self, PyObject *args) {
23142 0 : PyObject *resultobj = 0;
23143 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
23144 0 : char *arg2 = (char *) 0 ;
23145 : gpgme_export_mode_t arg3 ;
23146 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
23147 0 : void *argp1 = 0 ;
23148 0 : int res1 = 0 ;
23149 : unsigned int val3 ;
23150 0 : int ecode3 = 0 ;
23151 0 : gpgme_data_t wrapper4 = NULL ;
23152 0 : PyObject *bytesio4 = NULL ;
23153 : Py_buffer view4 ;
23154 0 : int have_view4 = 0 ;
23155 0 : PyObject * obj0 = 0 ;
23156 0 : PyObject * obj1 = 0 ;
23157 0 : PyObject * obj2 = 0 ;
23158 0 : PyObject * obj3 = 0 ;
23159 : gpgme_error_t result;
23160 :
23161 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23162 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
23163 0 : if (!SWIG_IsOK(res1)) {
23164 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
23165 : }
23166 0 : arg1 = (gpgme_ctx_t)(argp1);
23167 : {
23168 0 : if (obj1 == Py_None)
23169 : arg2 = NULL;
23170 0 : else if (PyUnicode_Check(obj1))
23171 0 : arg2 = PyUnicode_AsUTF8(obj1);
23172 0 : else if (PyBytes_Check(obj1))
23173 0 : arg2 = PyBytes_AsString(obj1);
23174 : else {
23175 0 : PyErr_Format(PyExc_TypeError,
23176 : "arg %d: expected str, bytes, or None, got %s",
23177 : 2, obj1->ob_type->tp_name);
23178 0 : return NULL;
23179 : }
23180 : }
23181 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
23182 0 : if (!SWIG_IsOK(ecode3)) {
23183 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_start" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
23184 : }
23185 0 : arg3 = (gpgme_export_mode_t)(val3);
23186 : {
23187 : /* If we create a temporary wrapper4 object, we will store it in
23188 : wrapperN, where N is 4. Here in this fragment, SWIG will
23189 : automatically append 4. */
23190 : memset(&view4, 0, sizeof view4);
23191 0 : if (obj3 == Py_None)
23192 0 : arg4 = NULL;
23193 : else {
23194 : PyObject *pypointer;
23195 0 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
23196 : &bytesio4, &view4);
23197 0 : if (pypointer == NULL)
23198 : return NULL;
23199 0 : have_view4 = !! view4.obj;
23200 :
23201 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
23202 :
23203 : // Following code is from swig's python.swg
23204 :
23205 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
23206 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
23207 0 : Py_DECREF(pypointer);
23208 : return NULL;
23209 : }
23210 0 : Py_DECREF(pypointer);
23211 : }
23212 : }
23213 0 : result = gpgme_op_export_start(arg1,(char const *)arg2,arg3,arg4);
23214 : {
23215 0 : resultobj = PyLong_FromLong(result);
23216 : }
23217 : {
23218 : /* See whether we need to update the Python buffer. */
23219 0 : if (resultobj && wrapper4 && view4.buf)
23220 : {
23221 : int dirty;
23222 0 : char *new_data = NULL;
23223 : size_t new_size;
23224 :
23225 :
23226 0 : new_data = wrapper4->data.mem.buffer;
23227 0 : new_size = wrapper4->data.mem.length;
23228 0 : dirty = new_data != NULL;
23229 :
23230 :
23231 :
23232 :
23233 :
23234 :
23235 :
23236 0 : if (dirty)
23237 : {
23238 : /* The buffer is dirty. */
23239 0 : if (view4.readonly)
23240 : {
23241 0 : Py_XDECREF(resultobj);
23242 0 : resultobj = NULL;
23243 0 : PyErr_SetString(PyExc_ValueError,
23244 : "cannot update read-only buffer");
23245 : }
23246 :
23247 : /* See if we need to truncate the buffer. */
23248 0 : if (resultobj && view4.len != new_size)
23249 : {
23250 0 : if (bytesio4 == NULL)
23251 : {
23252 0 : Py_XDECREF(resultobj);
23253 0 : resultobj = NULL;
23254 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23255 : }
23256 : else
23257 : {
23258 : PyObject *retval;
23259 0 : PyBuffer_Release(&view4);
23260 : assert(view4.obj == NULL);
23261 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
23262 : "l", (long) new_size);
23263 0 : if (retval == NULL)
23264 : {
23265 0 : Py_XDECREF(resultobj);
23266 : resultobj = NULL;
23267 : }
23268 : else
23269 : {
23270 0 : Py_DECREF(retval);
23271 :
23272 0 : retval = PyObject_CallMethod(bytesio4,
23273 : "getbuffer", NULL);
23274 0 : if (retval == NULL
23275 0 : || PyObject_GetBuffer(retval, &view4,
23276 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23277 : {
23278 0 : Py_XDECREF(resultobj);
23279 : resultobj = NULL;
23280 : }
23281 :
23282 0 : Py_XDECREF(retval);
23283 :
23284 0 : if (resultobj && view4.len
23285 0 : != new_size)
23286 : {
23287 0 : Py_XDECREF(resultobj);
23288 0 : resultobj = NULL;
23289 0 : PyErr_Format(PyExc_ValueError,
23290 : "Expected buffer of length %zu, got %zi",
23291 : new_size,
23292 : view4.len);
23293 : }
23294 : }
23295 : }
23296 : }
23297 0 : if (resultobj)
23298 0 : memcpy(view4.buf, new_data, new_size);
23299 : }
23300 :
23301 :
23302 :
23303 : }
23304 :
23305 : /* Free the temporary wrapper, if any. */
23306 0 : if (wrapper4)
23307 0 : gpgme_data_release(wrapper4);
23308 0 : Py_XDECREF (bytesio4);
23309 0 : if (have_view4 && view4.buf)
23310 0 : PyBuffer_Release(&view4);
23311 : }
23312 0 : return resultobj;
23313 : fail:
23314 : {
23315 : /* See whether we need to update the Python buffer. */
23316 : if (resultobj && wrapper4 && view4.buf)
23317 : {
23318 : int dirty;
23319 : char *new_data = NULL;
23320 : size_t new_size;
23321 :
23322 :
23323 : new_data = wrapper4->data.mem.buffer;
23324 : new_size = wrapper4->data.mem.length;
23325 : dirty = new_data != NULL;
23326 :
23327 :
23328 :
23329 :
23330 :
23331 :
23332 :
23333 : if (dirty)
23334 : {
23335 : /* The buffer is dirty. */
23336 : if (view4.readonly)
23337 : {
23338 : Py_XDECREF(resultobj);
23339 : resultobj = NULL;
23340 : PyErr_SetString(PyExc_ValueError,
23341 : "cannot update read-only buffer");
23342 : }
23343 :
23344 : /* See if we need to truncate the buffer. */
23345 : if (resultobj && view4.len != new_size)
23346 : {
23347 : if (bytesio4 == NULL)
23348 : {
23349 : Py_XDECREF(resultobj);
23350 : resultobj = NULL;
23351 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23352 : }
23353 : else
23354 : {
23355 : PyObject *retval;
23356 : PyBuffer_Release(&view4);
23357 : assert(view4.obj == NULL);
23358 : retval = PyObject_CallMethod(bytesio4, "truncate",
23359 : "l", (long) new_size);
23360 : if (retval == NULL)
23361 : {
23362 : Py_XDECREF(resultobj);
23363 : resultobj = NULL;
23364 : }
23365 : else
23366 : {
23367 : Py_DECREF(retval);
23368 :
23369 : retval = PyObject_CallMethod(bytesio4,
23370 : "getbuffer", NULL);
23371 : if (retval == NULL
23372 : || PyObject_GetBuffer(retval, &view4,
23373 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23374 : {
23375 : Py_XDECREF(resultobj);
23376 : resultobj = NULL;
23377 : }
23378 :
23379 : Py_XDECREF(retval);
23380 :
23381 : if (resultobj && view4.len
23382 : != new_size)
23383 : {
23384 : Py_XDECREF(resultobj);
23385 : resultobj = NULL;
23386 : PyErr_Format(PyExc_ValueError,
23387 : "Expected buffer of length %zu, got %zi",
23388 : new_size,
23389 : view4.len);
23390 : }
23391 : }
23392 : }
23393 : }
23394 : if (resultobj)
23395 : memcpy(view4.buf, new_data, new_size);
23396 : }
23397 :
23398 :
23399 :
23400 : }
23401 :
23402 : /* Free the temporary wrapper, if any. */
23403 0 : if (wrapper4)
23404 0 : gpgme_data_release(wrapper4);
23405 0 : Py_XDECREF (bytesio4);
23406 : if (have_view4 && view4.buf)
23407 : PyBuffer_Release(&view4);
23408 : }
23409 : return NULL;
23410 : }
23411 :
23412 :
23413 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export(PyObject *self, PyObject *args) {
23414 0 : PyObject *resultobj = 0;
23415 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
23416 0 : char *arg2 = (char *) 0 ;
23417 : gpgme_export_mode_t arg3 ;
23418 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
23419 0 : void *argp1 = 0 ;
23420 0 : int res1 = 0 ;
23421 : unsigned int val3 ;
23422 0 : int ecode3 = 0 ;
23423 0 : gpgme_data_t wrapper4 = NULL ;
23424 0 : PyObject *bytesio4 = NULL ;
23425 : Py_buffer view4 ;
23426 0 : int have_view4 = 0 ;
23427 0 : PyObject * obj0 = 0 ;
23428 0 : PyObject * obj1 = 0 ;
23429 0 : PyObject * obj2 = 0 ;
23430 0 : PyObject * obj3 = 0 ;
23431 : gpgme_error_t result;
23432 :
23433 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23434 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
23435 0 : if (!SWIG_IsOK(res1)) {
23436 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export" "', argument " "1"" of type '" "gpgme_ctx_t""'");
23437 : }
23438 0 : arg1 = (gpgme_ctx_t)(argp1);
23439 : {
23440 0 : if (obj1 == Py_None)
23441 : arg2 = NULL;
23442 0 : else if (PyUnicode_Check(obj1))
23443 0 : arg2 = PyUnicode_AsUTF8(obj1);
23444 0 : else if (PyBytes_Check(obj1))
23445 0 : arg2 = PyBytes_AsString(obj1);
23446 : else {
23447 0 : PyErr_Format(PyExc_TypeError,
23448 : "arg %d: expected str, bytes, or None, got %s",
23449 : 2, obj1->ob_type->tp_name);
23450 0 : return NULL;
23451 : }
23452 : }
23453 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
23454 0 : if (!SWIG_IsOK(ecode3)) {
23455 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
23456 : }
23457 0 : arg3 = (gpgme_export_mode_t)(val3);
23458 : {
23459 : /* If we create a temporary wrapper4 object, we will store it in
23460 : wrapperN, where N is 4. Here in this fragment, SWIG will
23461 : automatically append 4. */
23462 : memset(&view4, 0, sizeof view4);
23463 0 : if (obj3 == Py_None)
23464 0 : arg4 = NULL;
23465 : else {
23466 : PyObject *pypointer;
23467 0 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
23468 : &bytesio4, &view4);
23469 0 : if (pypointer == NULL)
23470 : return NULL;
23471 0 : have_view4 = !! view4.obj;
23472 :
23473 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
23474 :
23475 : // Following code is from swig's python.swg
23476 :
23477 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
23478 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
23479 0 : Py_DECREF(pypointer);
23480 : return NULL;
23481 : }
23482 0 : Py_DECREF(pypointer);
23483 : }
23484 : }
23485 0 : result = gpgme_op_export(arg1,(char const *)arg2,arg3,arg4);
23486 : {
23487 0 : resultobj = PyLong_FromLong(result);
23488 : }
23489 : {
23490 : /* See whether we need to update the Python buffer. */
23491 0 : if (resultobj && wrapper4 && view4.buf)
23492 : {
23493 : int dirty;
23494 0 : char *new_data = NULL;
23495 : size_t new_size;
23496 :
23497 :
23498 0 : new_data = wrapper4->data.mem.buffer;
23499 0 : new_size = wrapper4->data.mem.length;
23500 0 : dirty = new_data != NULL;
23501 :
23502 :
23503 :
23504 :
23505 :
23506 :
23507 :
23508 0 : if (dirty)
23509 : {
23510 : /* The buffer is dirty. */
23511 0 : if (view4.readonly)
23512 : {
23513 0 : Py_XDECREF(resultobj);
23514 0 : resultobj = NULL;
23515 0 : PyErr_SetString(PyExc_ValueError,
23516 : "cannot update read-only buffer");
23517 : }
23518 :
23519 : /* See if we need to truncate the buffer. */
23520 0 : if (resultobj && view4.len != new_size)
23521 : {
23522 0 : if (bytesio4 == NULL)
23523 : {
23524 0 : Py_XDECREF(resultobj);
23525 0 : resultobj = NULL;
23526 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23527 : }
23528 : else
23529 : {
23530 : PyObject *retval;
23531 0 : PyBuffer_Release(&view4);
23532 : assert(view4.obj == NULL);
23533 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
23534 : "l", (long) new_size);
23535 0 : if (retval == NULL)
23536 : {
23537 0 : Py_XDECREF(resultobj);
23538 : resultobj = NULL;
23539 : }
23540 : else
23541 : {
23542 0 : Py_DECREF(retval);
23543 :
23544 0 : retval = PyObject_CallMethod(bytesio4,
23545 : "getbuffer", NULL);
23546 0 : if (retval == NULL
23547 0 : || PyObject_GetBuffer(retval, &view4,
23548 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23549 : {
23550 0 : Py_XDECREF(resultobj);
23551 : resultobj = NULL;
23552 : }
23553 :
23554 0 : Py_XDECREF(retval);
23555 :
23556 0 : if (resultobj && view4.len
23557 0 : != new_size)
23558 : {
23559 0 : Py_XDECREF(resultobj);
23560 0 : resultobj = NULL;
23561 0 : PyErr_Format(PyExc_ValueError,
23562 : "Expected buffer of length %zu, got %zi",
23563 : new_size,
23564 : view4.len);
23565 : }
23566 : }
23567 : }
23568 : }
23569 0 : if (resultobj)
23570 0 : memcpy(view4.buf, new_data, new_size);
23571 : }
23572 :
23573 :
23574 :
23575 : }
23576 :
23577 : /* Free the temporary wrapper, if any. */
23578 0 : if (wrapper4)
23579 0 : gpgme_data_release(wrapper4);
23580 0 : Py_XDECREF (bytesio4);
23581 0 : if (have_view4 && view4.buf)
23582 0 : PyBuffer_Release(&view4);
23583 : }
23584 0 : return resultobj;
23585 : fail:
23586 : {
23587 : /* See whether we need to update the Python buffer. */
23588 : if (resultobj && wrapper4 && view4.buf)
23589 : {
23590 : int dirty;
23591 : char *new_data = NULL;
23592 : size_t new_size;
23593 :
23594 :
23595 : new_data = wrapper4->data.mem.buffer;
23596 : new_size = wrapper4->data.mem.length;
23597 : dirty = new_data != NULL;
23598 :
23599 :
23600 :
23601 :
23602 :
23603 :
23604 :
23605 : if (dirty)
23606 : {
23607 : /* The buffer is dirty. */
23608 : if (view4.readonly)
23609 : {
23610 : Py_XDECREF(resultobj);
23611 : resultobj = NULL;
23612 : PyErr_SetString(PyExc_ValueError,
23613 : "cannot update read-only buffer");
23614 : }
23615 :
23616 : /* See if we need to truncate the buffer. */
23617 : if (resultobj && view4.len != new_size)
23618 : {
23619 : if (bytesio4 == NULL)
23620 : {
23621 : Py_XDECREF(resultobj);
23622 : resultobj = NULL;
23623 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23624 : }
23625 : else
23626 : {
23627 : PyObject *retval;
23628 : PyBuffer_Release(&view4);
23629 : assert(view4.obj == NULL);
23630 : retval = PyObject_CallMethod(bytesio4, "truncate",
23631 : "l", (long) new_size);
23632 : if (retval == NULL)
23633 : {
23634 : Py_XDECREF(resultobj);
23635 : resultobj = NULL;
23636 : }
23637 : else
23638 : {
23639 : Py_DECREF(retval);
23640 :
23641 : retval = PyObject_CallMethod(bytesio4,
23642 : "getbuffer", NULL);
23643 : if (retval == NULL
23644 : || PyObject_GetBuffer(retval, &view4,
23645 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23646 : {
23647 : Py_XDECREF(resultobj);
23648 : resultobj = NULL;
23649 : }
23650 :
23651 : Py_XDECREF(retval);
23652 :
23653 : if (resultobj && view4.len
23654 : != new_size)
23655 : {
23656 : Py_XDECREF(resultobj);
23657 : resultobj = NULL;
23658 : PyErr_Format(PyExc_ValueError,
23659 : "Expected buffer of length %zu, got %zi",
23660 : new_size,
23661 : view4.len);
23662 : }
23663 : }
23664 : }
23665 : }
23666 : if (resultobj)
23667 : memcpy(view4.buf, new_data, new_size);
23668 : }
23669 :
23670 :
23671 :
23672 : }
23673 :
23674 : /* Free the temporary wrapper, if any. */
23675 0 : if (wrapper4)
23676 0 : gpgme_data_release(wrapper4);
23677 0 : Py_XDECREF (bytesio4);
23678 : if (have_view4 && view4.buf)
23679 : PyBuffer_Release(&view4);
23680 : }
23681 : return NULL;
23682 : }
23683 :
23684 :
23685 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export_ext_start(PyObject *self, PyObject *args) {
23686 0 : PyObject *resultobj = 0;
23687 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
23688 : char **arg2 ;
23689 : gpgme_export_mode_t arg3 ;
23690 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
23691 0 : void *argp1 = 0 ;
23692 0 : int res1 = 0 ;
23693 0 : void *vector2 = NULL ;
23694 : unsigned int val3 ;
23695 0 : int ecode3 = 0 ;
23696 0 : gpgme_data_t wrapper4 = NULL ;
23697 0 : PyObject *bytesio4 = NULL ;
23698 : Py_buffer view4 ;
23699 0 : int have_view4 = 0 ;
23700 0 : PyObject * obj0 = 0 ;
23701 0 : PyObject * obj1 = 0 ;
23702 0 : PyObject * obj2 = 0 ;
23703 0 : PyObject * obj3 = 0 ;
23704 : gpgme_error_t result;
23705 :
23706 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_ext_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23707 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
23708 0 : if (!SWIG_IsOK(res1)) {
23709 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_ext_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
23710 : }
23711 0 : arg1 = (gpgme_ctx_t)(argp1);
23712 : {
23713 : /* Check if is a list */
23714 0 : if (PyList_Check(obj1)) {
23715 0 : size_t i, size = PyList_Size(obj1);
23716 0 : arg2 = (char **) (vector2 = malloc((size+1) * sizeof(char *)));
23717 :
23718 0 : for (i = 0; i < size; i++) {
23719 0 : PyObject *o = PyList_GetItem(obj1,i);
23720 0 : if (PyUnicode_Check(o))
23721 0 : arg2[i] = PyUnicode_AsUTF8(o);
23722 0 : else if (PyString_Check(o))
23723 0 : arg2[i] = PyString_AsString(o);
23724 : else {
23725 0 : PyErr_Format(PyExc_TypeError,
23726 : "arg %d: list must contain only str or bytes, got %s "
23727 : "at position %d",
23728 0 : 2, o->ob_type->tp_name, i);
23729 0 : free(arg2);
23730 0 : return NULL;
23731 : }
23732 : }
23733 0 : arg2[i] = NULL;
23734 : } else {
23735 0 : PyErr_Format(PyExc_TypeError,
23736 : "arg %d: expected a list of str or bytes, got %s",
23737 : 2, obj1->ob_type->tp_name);
23738 0 : return NULL;
23739 : }
23740 : }
23741 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
23742 0 : if (!SWIG_IsOK(ecode3)) {
23743 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_ext_start" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
23744 : }
23745 0 : arg3 = (gpgme_export_mode_t)(val3);
23746 : {
23747 : /* If we create a temporary wrapper4 object, we will store it in
23748 : wrapperN, where N is 4. Here in this fragment, SWIG will
23749 : automatically append 4. */
23750 : memset(&view4, 0, sizeof view4);
23751 0 : if (obj3 == Py_None)
23752 0 : arg4 = NULL;
23753 : else {
23754 : PyObject *pypointer;
23755 0 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
23756 : &bytesio4, &view4);
23757 0 : if (pypointer == NULL)
23758 : return NULL;
23759 0 : have_view4 = !! view4.obj;
23760 :
23761 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
23762 :
23763 : // Following code is from swig's python.swg
23764 :
23765 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
23766 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
23767 0 : Py_DECREF(pypointer);
23768 : return NULL;
23769 : }
23770 0 : Py_DECREF(pypointer);
23771 : }
23772 : }
23773 0 : result = gpgme_op_export_ext_start(arg1,(char const *(*))arg2,arg3,arg4);
23774 : {
23775 0 : resultobj = PyLong_FromLong(result);
23776 : }
23777 : {
23778 0 : free(vector2);
23779 : }
23780 : {
23781 : /* See whether we need to update the Python buffer. */
23782 0 : if (resultobj && wrapper4 && view4.buf)
23783 : {
23784 : int dirty;
23785 0 : char *new_data = NULL;
23786 : size_t new_size;
23787 :
23788 :
23789 0 : new_data = wrapper4->data.mem.buffer;
23790 0 : new_size = wrapper4->data.mem.length;
23791 0 : dirty = new_data != NULL;
23792 :
23793 :
23794 :
23795 :
23796 :
23797 :
23798 :
23799 0 : if (dirty)
23800 : {
23801 : /* The buffer is dirty. */
23802 0 : if (view4.readonly)
23803 : {
23804 0 : Py_XDECREF(resultobj);
23805 0 : resultobj = NULL;
23806 0 : PyErr_SetString(PyExc_ValueError,
23807 : "cannot update read-only buffer");
23808 : }
23809 :
23810 : /* See if we need to truncate the buffer. */
23811 0 : if (resultobj && view4.len != new_size)
23812 : {
23813 0 : if (bytesio4 == NULL)
23814 : {
23815 0 : Py_XDECREF(resultobj);
23816 0 : resultobj = NULL;
23817 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23818 : }
23819 : else
23820 : {
23821 : PyObject *retval;
23822 0 : PyBuffer_Release(&view4);
23823 : assert(view4.obj == NULL);
23824 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
23825 : "l", (long) new_size);
23826 0 : if (retval == NULL)
23827 : {
23828 0 : Py_XDECREF(resultobj);
23829 : resultobj = NULL;
23830 : }
23831 : else
23832 : {
23833 0 : Py_DECREF(retval);
23834 :
23835 0 : retval = PyObject_CallMethod(bytesio4,
23836 : "getbuffer", NULL);
23837 0 : if (retval == NULL
23838 0 : || PyObject_GetBuffer(retval, &view4,
23839 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23840 : {
23841 0 : Py_XDECREF(resultobj);
23842 : resultobj = NULL;
23843 : }
23844 :
23845 0 : Py_XDECREF(retval);
23846 :
23847 0 : if (resultobj && view4.len
23848 0 : != new_size)
23849 : {
23850 0 : Py_XDECREF(resultobj);
23851 0 : resultobj = NULL;
23852 0 : PyErr_Format(PyExc_ValueError,
23853 : "Expected buffer of length %zu, got %zi",
23854 : new_size,
23855 : view4.len);
23856 : }
23857 : }
23858 : }
23859 : }
23860 0 : if (resultobj)
23861 0 : memcpy(view4.buf, new_data, new_size);
23862 : }
23863 :
23864 :
23865 :
23866 : }
23867 :
23868 : /* Free the temporary wrapper, if any. */
23869 0 : if (wrapper4)
23870 0 : gpgme_data_release(wrapper4);
23871 0 : Py_XDECREF (bytesio4);
23872 0 : if (have_view4 && view4.buf)
23873 0 : PyBuffer_Release(&view4);
23874 : }
23875 0 : return resultobj;
23876 : fail:
23877 : {
23878 0 : free(vector2);
23879 : }
23880 : {
23881 : /* See whether we need to update the Python buffer. */
23882 : if (resultobj && wrapper4 && view4.buf)
23883 : {
23884 : int dirty;
23885 : char *new_data = NULL;
23886 : size_t new_size;
23887 :
23888 :
23889 : new_data = wrapper4->data.mem.buffer;
23890 : new_size = wrapper4->data.mem.length;
23891 : dirty = new_data != NULL;
23892 :
23893 :
23894 :
23895 :
23896 :
23897 :
23898 :
23899 : if (dirty)
23900 : {
23901 : /* The buffer is dirty. */
23902 : if (view4.readonly)
23903 : {
23904 : Py_XDECREF(resultobj);
23905 : resultobj = NULL;
23906 : PyErr_SetString(PyExc_ValueError,
23907 : "cannot update read-only buffer");
23908 : }
23909 :
23910 : /* See if we need to truncate the buffer. */
23911 : if (resultobj && view4.len != new_size)
23912 : {
23913 : if (bytesio4 == NULL)
23914 : {
23915 : Py_XDECREF(resultobj);
23916 : resultobj = NULL;
23917 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23918 : }
23919 : else
23920 : {
23921 : PyObject *retval;
23922 : PyBuffer_Release(&view4);
23923 : assert(view4.obj == NULL);
23924 : retval = PyObject_CallMethod(bytesio4, "truncate",
23925 : "l", (long) new_size);
23926 : if (retval == NULL)
23927 : {
23928 : Py_XDECREF(resultobj);
23929 : resultobj = NULL;
23930 : }
23931 : else
23932 : {
23933 : Py_DECREF(retval);
23934 :
23935 : retval = PyObject_CallMethod(bytesio4,
23936 : "getbuffer", NULL);
23937 : if (retval == NULL
23938 : || PyObject_GetBuffer(retval, &view4,
23939 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23940 : {
23941 : Py_XDECREF(resultobj);
23942 : resultobj = NULL;
23943 : }
23944 :
23945 : Py_XDECREF(retval);
23946 :
23947 : if (resultobj && view4.len
23948 : != new_size)
23949 : {
23950 : Py_XDECREF(resultobj);
23951 : resultobj = NULL;
23952 : PyErr_Format(PyExc_ValueError,
23953 : "Expected buffer of length %zu, got %zi",
23954 : new_size,
23955 : view4.len);
23956 : }
23957 : }
23958 : }
23959 : }
23960 : if (resultobj)
23961 : memcpy(view4.buf, new_data, new_size);
23962 : }
23963 :
23964 :
23965 :
23966 : }
23967 :
23968 : /* Free the temporary wrapper, if any. */
23969 0 : if (wrapper4)
23970 0 : gpgme_data_release(wrapper4);
23971 0 : Py_XDECREF (bytesio4);
23972 : if (have_view4 && view4.buf)
23973 : PyBuffer_Release(&view4);
23974 : }
23975 : return NULL;
23976 : }
23977 :
23978 :
23979 1 : SWIGINTERN PyObject *_wrap_gpgme_op_export_ext(PyObject *self, PyObject *args) {
23980 1 : PyObject *resultobj = 0;
23981 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
23982 : char **arg2 ;
23983 : gpgme_export_mode_t arg3 ;
23984 1 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
23985 1 : void *argp1 = 0 ;
23986 1 : int res1 = 0 ;
23987 1 : void *vector2 = NULL ;
23988 : unsigned int val3 ;
23989 1 : int ecode3 = 0 ;
23990 1 : gpgme_data_t wrapper4 = NULL ;
23991 1 : PyObject *bytesio4 = NULL ;
23992 : Py_buffer view4 ;
23993 1 : int have_view4 = 0 ;
23994 1 : PyObject * obj0 = 0 ;
23995 1 : PyObject * obj1 = 0 ;
23996 1 : PyObject * obj2 = 0 ;
23997 1 : PyObject * obj3 = 0 ;
23998 : gpgme_error_t result;
23999 :
24000 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_ext",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24001 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
24002 1 : if (!SWIG_IsOK(res1)) {
24003 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
24004 : }
24005 1 : arg1 = (gpgme_ctx_t)(argp1);
24006 : {
24007 : /* Check if is a list */
24008 1 : if (PyList_Check(obj1)) {
24009 1 : size_t i, size = PyList_Size(obj1);
24010 1 : arg2 = (char **) (vector2 = malloc((size+1) * sizeof(char *)));
24011 :
24012 3 : for (i = 0; i < size; i++) {
24013 2 : PyObject *o = PyList_GetItem(obj1,i);
24014 2 : if (PyUnicode_Check(o))
24015 2 : arg2[i] = PyUnicode_AsUTF8(o);
24016 0 : else if (PyString_Check(o))
24017 0 : arg2[i] = PyString_AsString(o);
24018 : else {
24019 0 : PyErr_Format(PyExc_TypeError,
24020 : "arg %d: list must contain only str or bytes, got %s "
24021 : "at position %d",
24022 0 : 2, o->ob_type->tp_name, i);
24023 0 : free(arg2);
24024 0 : return NULL;
24025 : }
24026 : }
24027 1 : arg2[i] = NULL;
24028 : } else {
24029 0 : PyErr_Format(PyExc_TypeError,
24030 : "arg %d: expected a list of str or bytes, got %s",
24031 : 2, obj1->ob_type->tp_name);
24032 0 : return NULL;
24033 : }
24034 : }
24035 1 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
24036 1 : if (!SWIG_IsOK(ecode3)) {
24037 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_ext" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
24038 : }
24039 1 : arg3 = (gpgme_export_mode_t)(val3);
24040 : {
24041 : /* If we create a temporary wrapper4 object, we will store it in
24042 : wrapperN, where N is 4. Here in this fragment, SWIG will
24043 : automatically append 4. */
24044 : memset(&view4, 0, sizeof view4);
24045 1 : if (obj3 == Py_None)
24046 0 : arg4 = NULL;
24047 : else {
24048 : PyObject *pypointer;
24049 1 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
24050 : &bytesio4, &view4);
24051 1 : if (pypointer == NULL)
24052 : return NULL;
24053 1 : have_view4 = !! view4.obj;
24054 :
24055 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
24056 :
24057 : // Following code is from swig's python.swg
24058 :
24059 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
24060 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
24061 0 : Py_DECREF(pypointer);
24062 : return NULL;
24063 : }
24064 1 : Py_DECREF(pypointer);
24065 : }
24066 : }
24067 1 : result = gpgme_op_export_ext(arg1,(char const *(*))arg2,arg3,arg4);
24068 : {
24069 1 : resultobj = PyLong_FromLong(result);
24070 : }
24071 : {
24072 1 : free(vector2);
24073 : }
24074 : {
24075 : /* See whether we need to update the Python buffer. */
24076 1 : if (resultobj && wrapper4 && view4.buf)
24077 : {
24078 : int dirty;
24079 0 : char *new_data = NULL;
24080 : size_t new_size;
24081 :
24082 :
24083 0 : new_data = wrapper4->data.mem.buffer;
24084 0 : new_size = wrapper4->data.mem.length;
24085 0 : dirty = new_data != NULL;
24086 :
24087 :
24088 :
24089 :
24090 :
24091 :
24092 :
24093 0 : if (dirty)
24094 : {
24095 : /* The buffer is dirty. */
24096 0 : if (view4.readonly)
24097 : {
24098 0 : Py_XDECREF(resultobj);
24099 0 : resultobj = NULL;
24100 0 : PyErr_SetString(PyExc_ValueError,
24101 : "cannot update read-only buffer");
24102 : }
24103 :
24104 : /* See if we need to truncate the buffer. */
24105 0 : if (resultobj && view4.len != new_size)
24106 : {
24107 0 : if (bytesio4 == NULL)
24108 : {
24109 0 : Py_XDECREF(resultobj);
24110 0 : resultobj = NULL;
24111 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
24112 : }
24113 : else
24114 : {
24115 : PyObject *retval;
24116 0 : PyBuffer_Release(&view4);
24117 : assert(view4.obj == NULL);
24118 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
24119 : "l", (long) new_size);
24120 0 : if (retval == NULL)
24121 : {
24122 0 : Py_XDECREF(resultobj);
24123 : resultobj = NULL;
24124 : }
24125 : else
24126 : {
24127 0 : Py_DECREF(retval);
24128 :
24129 0 : retval = PyObject_CallMethod(bytesio4,
24130 : "getbuffer", NULL);
24131 0 : if (retval == NULL
24132 0 : || PyObject_GetBuffer(retval, &view4,
24133 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
24134 : {
24135 0 : Py_XDECREF(resultobj);
24136 : resultobj = NULL;
24137 : }
24138 :
24139 0 : Py_XDECREF(retval);
24140 :
24141 0 : if (resultobj && view4.len
24142 0 : != new_size)
24143 : {
24144 0 : Py_XDECREF(resultobj);
24145 0 : resultobj = NULL;
24146 0 : PyErr_Format(PyExc_ValueError,
24147 : "Expected buffer of length %zu, got %zi",
24148 : new_size,
24149 : view4.len);
24150 : }
24151 : }
24152 : }
24153 : }
24154 0 : if (resultobj)
24155 0 : memcpy(view4.buf, new_data, new_size);
24156 : }
24157 :
24158 :
24159 :
24160 : }
24161 :
24162 : /* Free the temporary wrapper, if any. */
24163 1 : if (wrapper4)
24164 0 : gpgme_data_release(wrapper4);
24165 1 : Py_XDECREF (bytesio4);
24166 1 : if (have_view4 && view4.buf)
24167 0 : PyBuffer_Release(&view4);
24168 : }
24169 1 : return resultobj;
24170 : fail:
24171 : {
24172 0 : free(vector2);
24173 : }
24174 : {
24175 : /* See whether we need to update the Python buffer. */
24176 : if (resultobj && wrapper4 && view4.buf)
24177 : {
24178 : int dirty;
24179 : char *new_data = NULL;
24180 : size_t new_size;
24181 :
24182 :
24183 : new_data = wrapper4->data.mem.buffer;
24184 : new_size = wrapper4->data.mem.length;
24185 : dirty = new_data != NULL;
24186 :
24187 :
24188 :
24189 :
24190 :
24191 :
24192 :
24193 : if (dirty)
24194 : {
24195 : /* The buffer is dirty. */
24196 : if (view4.readonly)
24197 : {
24198 : Py_XDECREF(resultobj);
24199 : resultobj = NULL;
24200 : PyErr_SetString(PyExc_ValueError,
24201 : "cannot update read-only buffer");
24202 : }
24203 :
24204 : /* See if we need to truncate the buffer. */
24205 : if (resultobj && view4.len != new_size)
24206 : {
24207 : if (bytesio4 == NULL)
24208 : {
24209 : Py_XDECREF(resultobj);
24210 : resultobj = NULL;
24211 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
24212 : }
24213 : else
24214 : {
24215 : PyObject *retval;
24216 : PyBuffer_Release(&view4);
24217 : assert(view4.obj == NULL);
24218 : retval = PyObject_CallMethod(bytesio4, "truncate",
24219 : "l", (long) new_size);
24220 : if (retval == NULL)
24221 : {
24222 : Py_XDECREF(resultobj);
24223 : resultobj = NULL;
24224 : }
24225 : else
24226 : {
24227 : Py_DECREF(retval);
24228 :
24229 : retval = PyObject_CallMethod(bytesio4,
24230 : "getbuffer", NULL);
24231 : if (retval == NULL
24232 : || PyObject_GetBuffer(retval, &view4,
24233 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
24234 : {
24235 : Py_XDECREF(resultobj);
24236 : resultobj = NULL;
24237 : }
24238 :
24239 : Py_XDECREF(retval);
24240 :
24241 : if (resultobj && view4.len
24242 : != new_size)
24243 : {
24244 : Py_XDECREF(resultobj);
24245 : resultobj = NULL;
24246 : PyErr_Format(PyExc_ValueError,
24247 : "Expected buffer of length %zu, got %zi",
24248 : new_size,
24249 : view4.len);
24250 : }
24251 : }
24252 : }
24253 : }
24254 : if (resultobj)
24255 : memcpy(view4.buf, new_data, new_size);
24256 : }
24257 :
24258 :
24259 :
24260 : }
24261 :
24262 : /* Free the temporary wrapper, if any. */
24263 0 : if (wrapper4)
24264 0 : gpgme_data_release(wrapper4);
24265 0 : Py_XDECREF (bytesio4);
24266 : if (have_view4 && view4.buf)
24267 : PyBuffer_Release(&view4);
24268 : }
24269 : return NULL;
24270 : }
24271 :
24272 :
24273 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export_keys_start(PyObject *self, PyObject *args) {
24274 0 : PyObject *resultobj = 0;
24275 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
24276 : gpgme_key_t *arg2 ;
24277 : gpgme_export_mode_t arg3 ;
24278 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
24279 0 : void *argp1 = 0 ;
24280 0 : int res1 = 0 ;
24281 : unsigned int val3 ;
24282 0 : int ecode3 = 0 ;
24283 0 : gpgme_data_t wrapper4 = NULL ;
24284 0 : PyObject *bytesio4 = NULL ;
24285 : Py_buffer view4 ;
24286 0 : int have_view4 = 0 ;
24287 0 : PyObject * obj0 = 0 ;
24288 0 : PyObject * obj1 = 0 ;
24289 0 : PyObject * obj2 = 0 ;
24290 0 : PyObject * obj3 = 0 ;
24291 : gpgme_error_t result;
24292 :
24293 : {
24294 0 : arg2 = NULL;
24295 : }
24296 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_keys_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24297 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
24298 0 : if (!SWIG_IsOK(res1)) {
24299 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_keys_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
24300 : }
24301 0 : arg1 = (gpgme_ctx_t)(argp1);
24302 : {
24303 0 : int i, numb = 0;
24304 0 : if (!PySequence_Check(obj1)) {
24305 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
24306 : 2);
24307 0 : return NULL;
24308 : }
24309 0 : if((numb = PySequence_Length(obj1)) != 0) {
24310 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
24311 0 : for(i=0; i<numb; i++) {
24312 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
24313 :
24314 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
24315 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
24316 :
24317 : // Following code is from swig's python.swg
24318 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
24319 0 : Py_DECREF(pypointer);
24320 : return NULL;
24321 : }
24322 0 : Py_DECREF(pypointer);
24323 : }
24324 0 : arg2[numb] = NULL;
24325 : }
24326 : }
24327 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
24328 0 : if (!SWIG_IsOK(ecode3)) {
24329 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_keys_start" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
24330 : }
24331 0 : arg3 = (gpgme_export_mode_t)(val3);
24332 : {
24333 : /* If we create a temporary wrapper4 object, we will store it in
24334 : wrapperN, where N is 4. Here in this fragment, SWIG will
24335 : automatically append 4. */
24336 : memset(&view4, 0, sizeof view4);
24337 0 : if (obj3 == Py_None)
24338 0 : arg4 = NULL;
24339 : else {
24340 : PyObject *pypointer;
24341 0 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
24342 : &bytesio4, &view4);
24343 0 : if (pypointer == NULL)
24344 : return NULL;
24345 0 : have_view4 = !! view4.obj;
24346 :
24347 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
24348 :
24349 : // Following code is from swig's python.swg
24350 :
24351 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
24352 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
24353 0 : Py_DECREF(pypointer);
24354 : return NULL;
24355 : }
24356 0 : Py_DECREF(pypointer);
24357 : }
24358 : }
24359 0 : result = gpgme_op_export_keys_start(arg1,arg2,arg3,arg4);
24360 : {
24361 0 : resultobj = PyLong_FromLong(result);
24362 : }
24363 : {
24364 0 : if (arg2) free(arg2);
24365 : }
24366 : {
24367 : /* See whether we need to update the Python buffer. */
24368 0 : if (resultobj && wrapper4 && view4.buf)
24369 : {
24370 : int dirty;
24371 0 : char *new_data = NULL;
24372 : size_t new_size;
24373 :
24374 :
24375 0 : new_data = wrapper4->data.mem.buffer;
24376 0 : new_size = wrapper4->data.mem.length;
24377 0 : dirty = new_data != NULL;
24378 :
24379 :
24380 :
24381 :
24382 :
24383 :
24384 :
24385 0 : if (dirty)
24386 : {
24387 : /* The buffer is dirty. */
24388 0 : if (view4.readonly)
24389 : {
24390 0 : Py_XDECREF(resultobj);
24391 0 : resultobj = NULL;
24392 0 : PyErr_SetString(PyExc_ValueError,
24393 : "cannot update read-only buffer");
24394 : }
24395 :
24396 : /* See if we need to truncate the buffer. */
24397 0 : if (resultobj && view4.len != new_size)
24398 : {
24399 0 : if (bytesio4 == NULL)
24400 : {
24401 0 : Py_XDECREF(resultobj);
24402 0 : resultobj = NULL;
24403 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
24404 : }
24405 : else
24406 : {
24407 : PyObject *retval;
24408 0 : PyBuffer_Release(&view4);
24409 : assert(view4.obj == NULL);
24410 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
24411 : "l", (long) new_size);
24412 0 : if (retval == NULL)
24413 : {
24414 0 : Py_XDECREF(resultobj);
24415 : resultobj = NULL;
24416 : }
24417 : else
24418 : {
24419 0 : Py_DECREF(retval);
24420 :
24421 0 : retval = PyObject_CallMethod(bytesio4,
24422 : "getbuffer", NULL);
24423 0 : if (retval == NULL
24424 0 : || PyObject_GetBuffer(retval, &view4,
24425 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
24426 : {
24427 0 : Py_XDECREF(resultobj);
24428 : resultobj = NULL;
24429 : }
24430 :
24431 0 : Py_XDECREF(retval);
24432 :
24433 0 : if (resultobj && view4.len
24434 0 : != new_size)
24435 : {
24436 0 : Py_XDECREF(resultobj);
24437 0 : resultobj = NULL;
24438 0 : PyErr_Format(PyExc_ValueError,
24439 : "Expected buffer of length %zu, got %zi",
24440 : new_size,
24441 : view4.len);
24442 : }
24443 : }
24444 : }
24445 : }
24446 0 : if (resultobj)
24447 0 : memcpy(view4.buf, new_data, new_size);
24448 : }
24449 :
24450 :
24451 :
24452 : }
24453 :
24454 : /* Free the temporary wrapper, if any. */
24455 0 : if (wrapper4)
24456 0 : gpgme_data_release(wrapper4);
24457 0 : Py_XDECREF (bytesio4);
24458 0 : if (have_view4 && view4.buf)
24459 0 : PyBuffer_Release(&view4);
24460 : }
24461 0 : return resultobj;
24462 : fail:
24463 : {
24464 0 : if (arg2) free(arg2);
24465 : }
24466 : {
24467 : /* See whether we need to update the Python buffer. */
24468 : if (resultobj && wrapper4 && view4.buf)
24469 : {
24470 : int dirty;
24471 : char *new_data = NULL;
24472 : size_t new_size;
24473 :
24474 :
24475 : new_data = wrapper4->data.mem.buffer;
24476 : new_size = wrapper4->data.mem.length;
24477 : dirty = new_data != NULL;
24478 :
24479 :
24480 :
24481 :
24482 :
24483 :
24484 :
24485 : if (dirty)
24486 : {
24487 : /* The buffer is dirty. */
24488 : if (view4.readonly)
24489 : {
24490 : Py_XDECREF(resultobj);
24491 : resultobj = NULL;
24492 : PyErr_SetString(PyExc_ValueError,
24493 : "cannot update read-only buffer");
24494 : }
24495 :
24496 : /* See if we need to truncate the buffer. */
24497 : if (resultobj && view4.len != new_size)
24498 : {
24499 : if (bytesio4 == NULL)
24500 : {
24501 : Py_XDECREF(resultobj);
24502 : resultobj = NULL;
24503 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
24504 : }
24505 : else
24506 : {
24507 : PyObject *retval;
24508 : PyBuffer_Release(&view4);
24509 : assert(view4.obj == NULL);
24510 : retval = PyObject_CallMethod(bytesio4, "truncate",
24511 : "l", (long) new_size);
24512 : if (retval == NULL)
24513 : {
24514 : Py_XDECREF(resultobj);
24515 : resultobj = NULL;
24516 : }
24517 : else
24518 : {
24519 : Py_DECREF(retval);
24520 :
24521 : retval = PyObject_CallMethod(bytesio4,
24522 : "getbuffer", NULL);
24523 : if (retval == NULL
24524 : || PyObject_GetBuffer(retval, &view4,
24525 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
24526 : {
24527 : Py_XDECREF(resultobj);
24528 : resultobj = NULL;
24529 : }
24530 :
24531 : Py_XDECREF(retval);
24532 :
24533 : if (resultobj && view4.len
24534 : != new_size)
24535 : {
24536 : Py_XDECREF(resultobj);
24537 : resultobj = NULL;
24538 : PyErr_Format(PyExc_ValueError,
24539 : "Expected buffer of length %zu, got %zi",
24540 : new_size,
24541 : view4.len);
24542 : }
24543 : }
24544 : }
24545 : }
24546 : if (resultobj)
24547 : memcpy(view4.buf, new_data, new_size);
24548 : }
24549 :
24550 :
24551 :
24552 : }
24553 :
24554 : /* Free the temporary wrapper, if any. */
24555 0 : if (wrapper4)
24556 0 : gpgme_data_release(wrapper4);
24557 0 : Py_XDECREF (bytesio4);
24558 : if (have_view4 && view4.buf)
24559 : PyBuffer_Release(&view4);
24560 : }
24561 : return NULL;
24562 : }
24563 :
24564 :
24565 1 : SWIGINTERN PyObject *_wrap_gpgme_op_export_keys(PyObject *self, PyObject *args) {
24566 1 : PyObject *resultobj = 0;
24567 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
24568 : gpgme_key_t *arg2 ;
24569 : gpgme_export_mode_t arg3 ;
24570 1 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
24571 1 : void *argp1 = 0 ;
24572 1 : int res1 = 0 ;
24573 : unsigned int val3 ;
24574 1 : int ecode3 = 0 ;
24575 1 : gpgme_data_t wrapper4 = NULL ;
24576 1 : PyObject *bytesio4 = NULL ;
24577 : Py_buffer view4 ;
24578 1 : int have_view4 = 0 ;
24579 1 : PyObject * obj0 = 0 ;
24580 1 : PyObject * obj1 = 0 ;
24581 1 : PyObject * obj2 = 0 ;
24582 1 : PyObject * obj3 = 0 ;
24583 : gpgme_error_t result;
24584 :
24585 : {
24586 1 : arg2 = NULL;
24587 : }
24588 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_keys",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24589 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
24590 1 : if (!SWIG_IsOK(res1)) {
24591 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_keys" "', argument " "1"" of type '" "gpgme_ctx_t""'");
24592 : }
24593 1 : arg1 = (gpgme_ctx_t)(argp1);
24594 : {
24595 1 : int i, numb = 0;
24596 1 : if (!PySequence_Check(obj1)) {
24597 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
24598 : 2);
24599 0 : return NULL;
24600 : }
24601 1 : if((numb = PySequence_Length(obj1)) != 0) {
24602 1 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
24603 3 : for(i=0; i<numb; i++) {
24604 2 : PyObject *pypointer = PySequence_GetItem(obj1, i);
24605 :
24606 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
24607 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
24608 :
24609 : // Following code is from swig's python.swg
24610 2 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
24611 0 : Py_DECREF(pypointer);
24612 : return NULL;
24613 : }
24614 2 : Py_DECREF(pypointer);
24615 : }
24616 1 : arg2[numb] = NULL;
24617 : }
24618 : }
24619 1 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
24620 1 : if (!SWIG_IsOK(ecode3)) {
24621 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_keys" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
24622 : }
24623 1 : arg3 = (gpgme_export_mode_t)(val3);
24624 : {
24625 : /* If we create a temporary wrapper4 object, we will store it in
24626 : wrapperN, where N is 4. Here in this fragment, SWIG will
24627 : automatically append 4. */
24628 : memset(&view4, 0, sizeof view4);
24629 1 : if (obj3 == Py_None)
24630 0 : arg4 = NULL;
24631 : else {
24632 : PyObject *pypointer;
24633 1 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
24634 : &bytesio4, &view4);
24635 1 : if (pypointer == NULL)
24636 : return NULL;
24637 1 : have_view4 = !! view4.obj;
24638 :
24639 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
24640 :
24641 : // Following code is from swig's python.swg
24642 :
24643 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
24644 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
24645 0 : Py_DECREF(pypointer);
24646 : return NULL;
24647 : }
24648 1 : Py_DECREF(pypointer);
24649 : }
24650 : }
24651 1 : result = gpgme_op_export_keys(arg1,arg2,arg3,arg4);
24652 : {
24653 1 : resultobj = PyLong_FromLong(result);
24654 : }
24655 : {
24656 1 : if (arg2) free(arg2);
24657 : }
24658 : {
24659 : /* See whether we need to update the Python buffer. */
24660 1 : if (resultobj && wrapper4 && view4.buf)
24661 : {
24662 : int dirty;
24663 0 : char *new_data = NULL;
24664 : size_t new_size;
24665 :
24666 :
24667 0 : new_data = wrapper4->data.mem.buffer;
24668 0 : new_size = wrapper4->data.mem.length;
24669 0 : dirty = new_data != NULL;
24670 :
24671 :
24672 :
24673 :
24674 :
24675 :
24676 :
24677 0 : if (dirty)
24678 : {
24679 : /* The buffer is dirty. */
24680 0 : if (view4.readonly)
24681 : {
24682 0 : Py_XDECREF(resultobj);
24683 0 : resultobj = NULL;
24684 0 : PyErr_SetString(PyExc_ValueError,
24685 : "cannot update read-only buffer");
24686 : }
24687 :
24688 : /* See if we need to truncate the buffer. */
24689 0 : if (resultobj && view4.len != new_size)
24690 : {
24691 0 : if (bytesio4 == NULL)
24692 : {
24693 0 : Py_XDECREF(resultobj);
24694 0 : resultobj = NULL;
24695 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
24696 : }
24697 : else
24698 : {
24699 : PyObject *retval;
24700 0 : PyBuffer_Release(&view4);
24701 : assert(view4.obj == NULL);
24702 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
24703 : "l", (long) new_size);
24704 0 : if (retval == NULL)
24705 : {
24706 0 : Py_XDECREF(resultobj);
24707 : resultobj = NULL;
24708 : }
24709 : else
24710 : {
24711 0 : Py_DECREF(retval);
24712 :
24713 0 : retval = PyObject_CallMethod(bytesio4,
24714 : "getbuffer", NULL);
24715 0 : if (retval == NULL
24716 0 : || PyObject_GetBuffer(retval, &view4,
24717 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
24718 : {
24719 0 : Py_XDECREF(resultobj);
24720 : resultobj = NULL;
24721 : }
24722 :
24723 0 : Py_XDECREF(retval);
24724 :
24725 0 : if (resultobj && view4.len
24726 0 : != new_size)
24727 : {
24728 0 : Py_XDECREF(resultobj);
24729 0 : resultobj = NULL;
24730 0 : PyErr_Format(PyExc_ValueError,
24731 : "Expected buffer of length %zu, got %zi",
24732 : new_size,
24733 : view4.len);
24734 : }
24735 : }
24736 : }
24737 : }
24738 0 : if (resultobj)
24739 0 : memcpy(view4.buf, new_data, new_size);
24740 : }
24741 :
24742 :
24743 :
24744 : }
24745 :
24746 : /* Free the temporary wrapper, if any. */
24747 1 : if (wrapper4)
24748 0 : gpgme_data_release(wrapper4);
24749 1 : Py_XDECREF (bytesio4);
24750 1 : if (have_view4 && view4.buf)
24751 0 : PyBuffer_Release(&view4);
24752 : }
24753 1 : return resultobj;
24754 : fail:
24755 : {
24756 0 : if (arg2) free(arg2);
24757 : }
24758 : {
24759 : /* See whether we need to update the Python buffer. */
24760 : if (resultobj && wrapper4 && view4.buf)
24761 : {
24762 : int dirty;
24763 : char *new_data = NULL;
24764 : size_t new_size;
24765 :
24766 :
24767 : new_data = wrapper4->data.mem.buffer;
24768 : new_size = wrapper4->data.mem.length;
24769 : dirty = new_data != NULL;
24770 :
24771 :
24772 :
24773 :
24774 :
24775 :
24776 :
24777 : if (dirty)
24778 : {
24779 : /* The buffer is dirty. */
24780 : if (view4.readonly)
24781 : {
24782 : Py_XDECREF(resultobj);
24783 : resultobj = NULL;
24784 : PyErr_SetString(PyExc_ValueError,
24785 : "cannot update read-only buffer");
24786 : }
24787 :
24788 : /* See if we need to truncate the buffer. */
24789 : if (resultobj && view4.len != new_size)
24790 : {
24791 : if (bytesio4 == NULL)
24792 : {
24793 : Py_XDECREF(resultobj);
24794 : resultobj = NULL;
24795 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
24796 : }
24797 : else
24798 : {
24799 : PyObject *retval;
24800 : PyBuffer_Release(&view4);
24801 : assert(view4.obj == NULL);
24802 : retval = PyObject_CallMethod(bytesio4, "truncate",
24803 : "l", (long) new_size);
24804 : if (retval == NULL)
24805 : {
24806 : Py_XDECREF(resultobj);
24807 : resultobj = NULL;
24808 : }
24809 : else
24810 : {
24811 : Py_DECREF(retval);
24812 :
24813 : retval = PyObject_CallMethod(bytesio4,
24814 : "getbuffer", NULL);
24815 : if (retval == NULL
24816 : || PyObject_GetBuffer(retval, &view4,
24817 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
24818 : {
24819 : Py_XDECREF(resultobj);
24820 : resultobj = NULL;
24821 : }
24822 :
24823 : Py_XDECREF(retval);
24824 :
24825 : if (resultobj && view4.len
24826 : != new_size)
24827 : {
24828 : Py_XDECREF(resultobj);
24829 : resultobj = NULL;
24830 : PyErr_Format(PyExc_ValueError,
24831 : "Expected buffer of length %zu, got %zi",
24832 : new_size,
24833 : view4.len);
24834 : }
24835 : }
24836 : }
24837 : }
24838 : if (resultobj)
24839 : memcpy(view4.buf, new_data, new_size);
24840 : }
24841 :
24842 :
24843 :
24844 : }
24845 :
24846 : /* Free the temporary wrapper, if any. */
24847 0 : if (wrapper4)
24848 0 : gpgme_data_release(wrapper4);
24849 0 : Py_XDECREF (bytesio4);
24850 : if (have_view4 && view4.buf)
24851 : PyBuffer_Release(&view4);
24852 : }
24853 : return NULL;
24854 : }
24855 :
24856 :
24857 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_primary_set(PyObject *self, PyObject *args) {
24858 0 : PyObject *resultobj = 0;
24859 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
24860 : unsigned int arg2 ;
24861 0 : void *argp1 = 0 ;
24862 0 : int res1 = 0 ;
24863 : unsigned int val2 ;
24864 0 : int ecode2 = 0 ;
24865 0 : PyObject * obj1 = 0 ;
24866 :
24867 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_primary_set",&obj1)) SWIG_fail;
24868 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
24869 0 : if (!SWIG_IsOK(res1)) {
24870 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_primary_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
24871 : }
24872 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
24873 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24874 0 : if (!SWIG_IsOK(ecode2)) {
24875 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_genkey_result_primary_set" "', argument " "2"" of type '" "unsigned int""'");
24876 : }
24877 0 : arg2 = (unsigned int)(val2);
24878 0 : if (arg1) (arg1)->primary = arg2;
24879 0 : resultobj = SWIG_Py_Void();
24880 0 : return resultobj;
24881 : fail:
24882 : return NULL;
24883 : }
24884 :
24885 :
24886 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_primary_get(PyObject *self, PyObject *args) {
24887 0 : PyObject *resultobj = 0;
24888 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
24889 0 : void *argp1 = 0 ;
24890 0 : int res1 = 0 ;
24891 : unsigned int result;
24892 :
24893 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
24894 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
24895 0 : if (!SWIG_IsOK(res1)) {
24896 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_primary_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
24897 : }
24898 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
24899 0 : result = (unsigned int) ((arg1)->primary);
24900 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
24901 0 : return resultobj;
24902 : fail:
24903 : return NULL;
24904 : }
24905 :
24906 :
24907 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_sub_set(PyObject *self, PyObject *args) {
24908 0 : PyObject *resultobj = 0;
24909 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
24910 : unsigned int arg2 ;
24911 0 : void *argp1 = 0 ;
24912 0 : int res1 = 0 ;
24913 : unsigned int val2 ;
24914 0 : int ecode2 = 0 ;
24915 0 : PyObject * obj1 = 0 ;
24916 :
24917 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_sub_set",&obj1)) SWIG_fail;
24918 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
24919 0 : if (!SWIG_IsOK(res1)) {
24920 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_sub_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
24921 : }
24922 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
24923 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24924 0 : if (!SWIG_IsOK(ecode2)) {
24925 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_genkey_result_sub_set" "', argument " "2"" of type '" "unsigned int""'");
24926 : }
24927 0 : arg2 = (unsigned int)(val2);
24928 0 : if (arg1) (arg1)->sub = arg2;
24929 0 : resultobj = SWIG_Py_Void();
24930 0 : return resultobj;
24931 : fail:
24932 : return NULL;
24933 : }
24934 :
24935 :
24936 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_sub_get(PyObject *self, PyObject *args) {
24937 0 : PyObject *resultobj = 0;
24938 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
24939 0 : void *argp1 = 0 ;
24940 0 : int res1 = 0 ;
24941 : unsigned int result;
24942 :
24943 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
24944 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
24945 0 : if (!SWIG_IsOK(res1)) {
24946 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_sub_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
24947 : }
24948 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
24949 0 : result = (unsigned int) ((arg1)->sub);
24950 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
24951 0 : return resultobj;
24952 : fail:
24953 : return NULL;
24954 : }
24955 :
24956 :
24957 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result__unused_set(PyObject *self, PyObject *args) {
24958 0 : PyObject *resultobj = 0;
24959 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
24960 : unsigned int arg2 ;
24961 0 : void *argp1 = 0 ;
24962 0 : int res1 = 0 ;
24963 : unsigned int val2 ;
24964 0 : int ecode2 = 0 ;
24965 0 : PyObject * obj1 = 0 ;
24966 :
24967 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result__unused_set",&obj1)) SWIG_fail;
24968 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
24969 0 : if (!SWIG_IsOK(res1)) {
24970 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result__unused_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
24971 : }
24972 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
24973 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24974 0 : if (!SWIG_IsOK(ecode2)) {
24975 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_genkey_result__unused_set" "', argument " "2"" of type '" "unsigned int""'");
24976 : }
24977 0 : arg2 = (unsigned int)(val2);
24978 0 : if (arg1) (arg1)->_unused = arg2;
24979 0 : resultobj = SWIG_Py_Void();
24980 0 : return resultobj;
24981 : fail:
24982 : return NULL;
24983 : }
24984 :
24985 :
24986 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result__unused_get(PyObject *self, PyObject *args) {
24987 0 : PyObject *resultobj = 0;
24988 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
24989 0 : void *argp1 = 0 ;
24990 0 : int res1 = 0 ;
24991 : unsigned int result;
24992 :
24993 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
24994 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
24995 0 : if (!SWIG_IsOK(res1)) {
24996 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result__unused_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
24997 : }
24998 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
24999 0 : result = (unsigned int) ((arg1)->_unused);
25000 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
25001 0 : return resultobj;
25002 : fail:
25003 : return NULL;
25004 : }
25005 :
25006 :
25007 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_fpr_set(PyObject *self, PyObject *args) {
25008 0 : PyObject *resultobj = 0;
25009 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
25010 0 : char *arg2 = (char *) 0 ;
25011 0 : void *argp1 = 0 ;
25012 0 : int res1 = 0 ;
25013 : int res2 ;
25014 0 : char *buf2 = 0 ;
25015 0 : int alloc2 = 0 ;
25016 0 : PyObject * obj1 = 0 ;
25017 :
25018 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_fpr_set",&obj1)) SWIG_fail;
25019 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
25020 0 : if (!SWIG_IsOK(res1)) {
25021 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_fpr_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
25022 : }
25023 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
25024 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25025 0 : if (!SWIG_IsOK(res2)) {
25026 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_genkey_result_fpr_set" "', argument " "2"" of type '" "char *""'");
25027 : }
25028 0 : arg2 = (char *)(buf2);
25029 0 : if (arg1->fpr) free((char*)arg1->fpr);
25030 0 : if (arg2) {
25031 0 : size_t size = strlen((const char *)(arg2)) + 1;
25032 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
25033 : } else {
25034 0 : arg1->fpr = 0;
25035 : }
25036 0 : resultobj = SWIG_Py_Void();
25037 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
25038 : return resultobj;
25039 : fail:
25040 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
25041 : return NULL;
25042 : }
25043 :
25044 :
25045 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_fpr_get(PyObject *self, PyObject *args) {
25046 0 : PyObject *resultobj = 0;
25047 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
25048 0 : void *argp1 = 0 ;
25049 0 : int res1 = 0 ;
25050 0 : char *result = 0 ;
25051 :
25052 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
25053 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
25054 0 : if (!SWIG_IsOK(res1)) {
25055 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_fpr_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
25056 : }
25057 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
25058 0 : result = (char *) ((arg1)->fpr);
25059 0 : resultobj = SWIG_FromCharPtr((const char *)result);
25060 0 : return resultobj;
25061 : fail:
25062 : return NULL;
25063 : }
25064 :
25065 :
25066 0 : SWIGINTERN int _wrap_new__gpgme_op_genkey_result(PyObject *self, PyObject *args) {
25067 0 : PyObject *resultobj = 0;
25068 0 : struct _gpgme_op_genkey_result *result = 0 ;
25069 :
25070 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
25071 0 : result = (struct _gpgme_op_genkey_result *)calloc(1, sizeof(struct _gpgme_op_genkey_result));
25072 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_genkey_result, SWIG_BUILTIN_INIT | 0 );
25073 0 : return resultobj == Py_None ? -1 : 0;
25074 : fail:
25075 : return -1;
25076 : }
25077 :
25078 :
25079 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_genkey_result(PyObject *self, PyObject *args) {
25080 0 : PyObject *resultobj = 0;
25081 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
25082 0 : void *argp1 = 0 ;
25083 0 : int res1 = 0 ;
25084 :
25085 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
25086 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, SWIG_POINTER_DISOWN | 0 );
25087 0 : if (!SWIG_IsOK(res1)) {
25088 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_genkey_result" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
25089 : }
25090 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
25091 0 : free((char *) arg1);
25092 0 : resultobj = SWIG_Py_Void();
25093 0 : return resultobj;
25094 : fail:
25095 : return NULL;
25096 : }
25097 :
25098 :
25099 0 : SWIGINTERN PyObject *_wrap_gpgme_op_genkey_start(PyObject *self, PyObject *args) {
25100 0 : PyObject *resultobj = 0;
25101 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
25102 0 : char *arg2 = (char *) 0 ;
25103 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
25104 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
25105 0 : void *argp1 = 0 ;
25106 0 : int res1 = 0 ;
25107 0 : gpgme_data_t wrapper3 = NULL ;
25108 0 : PyObject *bytesio3 = NULL ;
25109 : Py_buffer view3 ;
25110 0 : int have_view3 = 0 ;
25111 0 : gpgme_data_t wrapper4 = NULL ;
25112 0 : PyObject *bytesio4 = NULL ;
25113 : Py_buffer view4 ;
25114 0 : int have_view4 = 0 ;
25115 0 : PyObject * obj0 = 0 ;
25116 0 : PyObject * obj1 = 0 ;
25117 0 : PyObject * obj2 = 0 ;
25118 0 : PyObject * obj3 = 0 ;
25119 : gpgme_error_t result;
25120 :
25121 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_genkey_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25122 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
25123 0 : if (!SWIG_IsOK(res1)) {
25124 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_genkey_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
25125 : }
25126 0 : arg1 = (gpgme_ctx_t)(argp1);
25127 : {
25128 0 : if (obj1 == Py_None)
25129 : arg2 = NULL;
25130 0 : else if (PyUnicode_Check(obj1))
25131 0 : arg2 = PyUnicode_AsUTF8(obj1);
25132 0 : else if (PyBytes_Check(obj1))
25133 0 : arg2 = PyBytes_AsString(obj1);
25134 : else {
25135 0 : PyErr_Format(PyExc_TypeError,
25136 : "arg %d: expected str, bytes, or None, got %s",
25137 : 2, obj1->ob_type->tp_name);
25138 0 : return NULL;
25139 : }
25140 : }
25141 : {
25142 : /* If we create a temporary wrapper3 object, we will store it in
25143 : wrapperN, where N is 3. Here in this fragment, SWIG will
25144 : automatically append 3. */
25145 : memset(&view3, 0, sizeof view3);
25146 0 : if (obj2 == Py_None)
25147 0 : arg3 = NULL;
25148 : else {
25149 : PyObject *pypointer;
25150 0 : pypointer = _pyme_obj2gpgme_data_t(obj2, 3, &wrapper3,
25151 : &bytesio3, &view3);
25152 0 : if (pypointer == NULL)
25153 : return NULL;
25154 0 : have_view3 = !! view3.obj;
25155 :
25156 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
25157 :
25158 : // Following code is from swig's python.swg
25159 :
25160 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
25161 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
25162 0 : Py_DECREF(pypointer);
25163 : return NULL;
25164 : }
25165 0 : Py_DECREF(pypointer);
25166 : }
25167 : }
25168 : {
25169 : /* If we create a temporary wrapper4 object, we will store it in
25170 : wrapperN, where N is 4. Here in this fragment, SWIG will
25171 : automatically append 4. */
25172 : memset(&view4, 0, sizeof view4);
25173 0 : if (obj3 == Py_None)
25174 0 : arg4 = NULL;
25175 : else {
25176 : PyObject *pypointer;
25177 0 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
25178 : &bytesio4, &view4);
25179 0 : if (pypointer == NULL)
25180 : return NULL;
25181 0 : have_view4 = !! view4.obj;
25182 :
25183 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
25184 :
25185 : // Following code is from swig's python.swg
25186 :
25187 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
25188 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
25189 0 : Py_DECREF(pypointer);
25190 : return NULL;
25191 : }
25192 0 : Py_DECREF(pypointer);
25193 : }
25194 : }
25195 0 : result = gpgme_op_genkey_start(arg1,(char const *)arg2,arg3,arg4);
25196 : {
25197 0 : resultobj = PyLong_FromLong(result);
25198 : }
25199 : {
25200 : /* See whether we need to update the Python buffer. */
25201 0 : if (resultobj && wrapper3 && view3.buf)
25202 : {
25203 : int dirty;
25204 0 : char *new_data = NULL;
25205 : size_t new_size;
25206 :
25207 :
25208 0 : new_data = wrapper3->data.mem.buffer;
25209 0 : new_size = wrapper3->data.mem.length;
25210 0 : dirty = new_data != NULL;
25211 :
25212 :
25213 :
25214 :
25215 :
25216 :
25217 :
25218 0 : if (dirty)
25219 : {
25220 : /* The buffer is dirty. */
25221 0 : if (view3.readonly)
25222 : {
25223 0 : Py_XDECREF(resultobj);
25224 0 : resultobj = NULL;
25225 0 : PyErr_SetString(PyExc_ValueError,
25226 : "cannot update read-only buffer");
25227 : }
25228 :
25229 : /* See if we need to truncate the buffer. */
25230 0 : if (resultobj && view3.len != new_size)
25231 : {
25232 0 : if (bytesio3 == NULL)
25233 : {
25234 0 : Py_XDECREF(resultobj);
25235 0 : resultobj = NULL;
25236 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25237 : }
25238 : else
25239 : {
25240 : PyObject *retval;
25241 0 : PyBuffer_Release(&view3);
25242 : assert(view3.obj == NULL);
25243 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
25244 : "l", (long) new_size);
25245 0 : if (retval == NULL)
25246 : {
25247 0 : Py_XDECREF(resultobj);
25248 : resultobj = NULL;
25249 : }
25250 : else
25251 : {
25252 0 : Py_DECREF(retval);
25253 :
25254 0 : retval = PyObject_CallMethod(bytesio3,
25255 : "getbuffer", NULL);
25256 0 : if (retval == NULL
25257 0 : || PyObject_GetBuffer(retval, &view3,
25258 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25259 : {
25260 0 : Py_XDECREF(resultobj);
25261 : resultobj = NULL;
25262 : }
25263 :
25264 0 : Py_XDECREF(retval);
25265 :
25266 0 : if (resultobj && view3.len
25267 0 : != new_size)
25268 : {
25269 0 : Py_XDECREF(resultobj);
25270 0 : resultobj = NULL;
25271 0 : PyErr_Format(PyExc_ValueError,
25272 : "Expected buffer of length %zu, got %zi",
25273 : new_size,
25274 : view3.len);
25275 : }
25276 : }
25277 : }
25278 : }
25279 0 : if (resultobj)
25280 0 : memcpy(view3.buf, new_data, new_size);
25281 : }
25282 :
25283 :
25284 :
25285 : }
25286 :
25287 : /* Free the temporary wrapper, if any. */
25288 0 : if (wrapper3)
25289 0 : gpgme_data_release(wrapper3);
25290 0 : Py_XDECREF (bytesio3);
25291 0 : if (have_view3 && view3.buf)
25292 0 : PyBuffer_Release(&view3);
25293 : }
25294 : {
25295 : /* See whether we need to update the Python buffer. */
25296 0 : if (resultobj && wrapper4 && view4.buf)
25297 : {
25298 : int dirty;
25299 0 : char *new_data = NULL;
25300 : size_t new_size;
25301 :
25302 :
25303 0 : new_data = wrapper4->data.mem.buffer;
25304 0 : new_size = wrapper4->data.mem.length;
25305 0 : dirty = new_data != NULL;
25306 :
25307 :
25308 :
25309 :
25310 :
25311 :
25312 :
25313 0 : if (dirty)
25314 : {
25315 : /* The buffer is dirty. */
25316 0 : if (view4.readonly)
25317 : {
25318 0 : Py_XDECREF(resultobj);
25319 0 : resultobj = NULL;
25320 0 : PyErr_SetString(PyExc_ValueError,
25321 : "cannot update read-only buffer");
25322 : }
25323 :
25324 : /* See if we need to truncate the buffer. */
25325 0 : if (resultobj && view4.len != new_size)
25326 : {
25327 0 : if (bytesio4 == NULL)
25328 : {
25329 0 : Py_XDECREF(resultobj);
25330 0 : resultobj = NULL;
25331 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25332 : }
25333 : else
25334 : {
25335 : PyObject *retval;
25336 0 : PyBuffer_Release(&view4);
25337 : assert(view4.obj == NULL);
25338 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
25339 : "l", (long) new_size);
25340 0 : if (retval == NULL)
25341 : {
25342 0 : Py_XDECREF(resultobj);
25343 : resultobj = NULL;
25344 : }
25345 : else
25346 : {
25347 0 : Py_DECREF(retval);
25348 :
25349 0 : retval = PyObject_CallMethod(bytesio4,
25350 : "getbuffer", NULL);
25351 0 : if (retval == NULL
25352 0 : || PyObject_GetBuffer(retval, &view4,
25353 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25354 : {
25355 0 : Py_XDECREF(resultobj);
25356 : resultobj = NULL;
25357 : }
25358 :
25359 0 : Py_XDECREF(retval);
25360 :
25361 0 : if (resultobj && view4.len
25362 0 : != new_size)
25363 : {
25364 0 : Py_XDECREF(resultobj);
25365 0 : resultobj = NULL;
25366 0 : PyErr_Format(PyExc_ValueError,
25367 : "Expected buffer of length %zu, got %zi",
25368 : new_size,
25369 : view4.len);
25370 : }
25371 : }
25372 : }
25373 : }
25374 0 : if (resultobj)
25375 0 : memcpy(view4.buf, new_data, new_size);
25376 : }
25377 :
25378 :
25379 :
25380 : }
25381 :
25382 : /* Free the temporary wrapper, if any. */
25383 0 : if (wrapper4)
25384 0 : gpgme_data_release(wrapper4);
25385 0 : Py_XDECREF (bytesio4);
25386 0 : if (have_view4 && view4.buf)
25387 0 : PyBuffer_Release(&view4);
25388 : }
25389 0 : return resultobj;
25390 : fail:
25391 : {
25392 : /* See whether we need to update the Python buffer. */
25393 : if (resultobj && wrapper3 && view3.buf)
25394 : {
25395 : int dirty;
25396 : char *new_data = NULL;
25397 : size_t new_size;
25398 :
25399 :
25400 : new_data = wrapper3->data.mem.buffer;
25401 : new_size = wrapper3->data.mem.length;
25402 : dirty = new_data != NULL;
25403 :
25404 :
25405 :
25406 :
25407 :
25408 :
25409 :
25410 : if (dirty)
25411 : {
25412 : /* The buffer is dirty. */
25413 : if (view3.readonly)
25414 : {
25415 : Py_XDECREF(resultobj);
25416 : resultobj = NULL;
25417 : PyErr_SetString(PyExc_ValueError,
25418 : "cannot update read-only buffer");
25419 : }
25420 :
25421 : /* See if we need to truncate the buffer. */
25422 : if (resultobj && view3.len != new_size)
25423 : {
25424 : if (bytesio3 == NULL)
25425 : {
25426 : Py_XDECREF(resultobj);
25427 : resultobj = NULL;
25428 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25429 : }
25430 : else
25431 : {
25432 : PyObject *retval;
25433 : PyBuffer_Release(&view3);
25434 : assert(view3.obj == NULL);
25435 : retval = PyObject_CallMethod(bytesio3, "truncate",
25436 : "l", (long) new_size);
25437 : if (retval == NULL)
25438 : {
25439 : Py_XDECREF(resultobj);
25440 : resultobj = NULL;
25441 : }
25442 : else
25443 : {
25444 : Py_DECREF(retval);
25445 :
25446 : retval = PyObject_CallMethod(bytesio3,
25447 : "getbuffer", NULL);
25448 : if (retval == NULL
25449 : || PyObject_GetBuffer(retval, &view3,
25450 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25451 : {
25452 : Py_XDECREF(resultobj);
25453 : resultobj = NULL;
25454 : }
25455 :
25456 : Py_XDECREF(retval);
25457 :
25458 : if (resultobj && view3.len
25459 : != new_size)
25460 : {
25461 : Py_XDECREF(resultobj);
25462 : resultobj = NULL;
25463 : PyErr_Format(PyExc_ValueError,
25464 : "Expected buffer of length %zu, got %zi",
25465 : new_size,
25466 : view3.len);
25467 : }
25468 : }
25469 : }
25470 : }
25471 : if (resultobj)
25472 : memcpy(view3.buf, new_data, new_size);
25473 : }
25474 :
25475 :
25476 :
25477 : }
25478 :
25479 : /* Free the temporary wrapper, if any. */
25480 0 : if (wrapper3)
25481 0 : gpgme_data_release(wrapper3);
25482 0 : Py_XDECREF (bytesio3);
25483 : if (have_view3 && view3.buf)
25484 : PyBuffer_Release(&view3);
25485 : }
25486 : {
25487 : /* See whether we need to update the Python buffer. */
25488 : if (resultobj && wrapper4 && view4.buf)
25489 : {
25490 : int dirty;
25491 : char *new_data = NULL;
25492 : size_t new_size;
25493 :
25494 :
25495 : new_data = wrapper4->data.mem.buffer;
25496 : new_size = wrapper4->data.mem.length;
25497 : dirty = new_data != NULL;
25498 :
25499 :
25500 :
25501 :
25502 :
25503 :
25504 :
25505 : if (dirty)
25506 : {
25507 : /* The buffer is dirty. */
25508 : if (view4.readonly)
25509 : {
25510 : Py_XDECREF(resultobj);
25511 : resultobj = NULL;
25512 : PyErr_SetString(PyExc_ValueError,
25513 : "cannot update read-only buffer");
25514 : }
25515 :
25516 : /* See if we need to truncate the buffer. */
25517 : if (resultobj && view4.len != new_size)
25518 : {
25519 : if (bytesio4 == NULL)
25520 : {
25521 : Py_XDECREF(resultobj);
25522 : resultobj = NULL;
25523 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25524 : }
25525 : else
25526 : {
25527 : PyObject *retval;
25528 : PyBuffer_Release(&view4);
25529 : assert(view4.obj == NULL);
25530 : retval = PyObject_CallMethod(bytesio4, "truncate",
25531 : "l", (long) new_size);
25532 : if (retval == NULL)
25533 : {
25534 : Py_XDECREF(resultobj);
25535 : resultobj = NULL;
25536 : }
25537 : else
25538 : {
25539 : Py_DECREF(retval);
25540 :
25541 : retval = PyObject_CallMethod(bytesio4,
25542 : "getbuffer", NULL);
25543 : if (retval == NULL
25544 : || PyObject_GetBuffer(retval, &view4,
25545 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25546 : {
25547 : Py_XDECREF(resultobj);
25548 : resultobj = NULL;
25549 : }
25550 :
25551 : Py_XDECREF(retval);
25552 :
25553 : if (resultobj && view4.len
25554 : != new_size)
25555 : {
25556 : Py_XDECREF(resultobj);
25557 : resultobj = NULL;
25558 : PyErr_Format(PyExc_ValueError,
25559 : "Expected buffer of length %zu, got %zi",
25560 : new_size,
25561 : view4.len);
25562 : }
25563 : }
25564 : }
25565 : }
25566 : if (resultobj)
25567 : memcpy(view4.buf, new_data, new_size);
25568 : }
25569 :
25570 :
25571 :
25572 : }
25573 :
25574 : /* Free the temporary wrapper, if any. */
25575 0 : if (wrapper4)
25576 0 : gpgme_data_release(wrapper4);
25577 0 : Py_XDECREF (bytesio4);
25578 : if (have_view4 && view4.buf)
25579 : PyBuffer_Release(&view4);
25580 : }
25581 : return NULL;
25582 : }
25583 :
25584 :
25585 2 : SWIGINTERN PyObject *_wrap_gpgme_op_genkey(PyObject *self, PyObject *args) {
25586 2 : PyObject *resultobj = 0;
25587 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
25588 2 : char *arg2 = (char *) 0 ;
25589 2 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
25590 2 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
25591 2 : void *argp1 = 0 ;
25592 2 : int res1 = 0 ;
25593 2 : gpgme_data_t wrapper3 = NULL ;
25594 2 : PyObject *bytesio3 = NULL ;
25595 : Py_buffer view3 ;
25596 2 : int have_view3 = 0 ;
25597 2 : gpgme_data_t wrapper4 = NULL ;
25598 2 : PyObject *bytesio4 = NULL ;
25599 : Py_buffer view4 ;
25600 2 : int have_view4 = 0 ;
25601 2 : PyObject * obj0 = 0 ;
25602 2 : PyObject * obj1 = 0 ;
25603 2 : PyObject * obj2 = 0 ;
25604 2 : PyObject * obj3 = 0 ;
25605 : gpgme_error_t result;
25606 :
25607 2 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_genkey",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25608 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
25609 2 : if (!SWIG_IsOK(res1)) {
25610 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_genkey" "', argument " "1"" of type '" "gpgme_ctx_t""'");
25611 : }
25612 2 : arg1 = (gpgme_ctx_t)(argp1);
25613 : {
25614 2 : if (obj1 == Py_None)
25615 : arg2 = NULL;
25616 2 : else if (PyUnicode_Check(obj1))
25617 2 : arg2 = PyUnicode_AsUTF8(obj1);
25618 0 : else if (PyBytes_Check(obj1))
25619 0 : arg2 = PyBytes_AsString(obj1);
25620 : else {
25621 0 : PyErr_Format(PyExc_TypeError,
25622 : "arg %d: expected str, bytes, or None, got %s",
25623 : 2, obj1->ob_type->tp_name);
25624 0 : return NULL;
25625 : }
25626 : }
25627 : {
25628 : /* If we create a temporary wrapper3 object, we will store it in
25629 : wrapperN, where N is 3. Here in this fragment, SWIG will
25630 : automatically append 3. */
25631 : memset(&view3, 0, sizeof view3);
25632 2 : if (obj2 == Py_None)
25633 2 : arg3 = NULL;
25634 : else {
25635 : PyObject *pypointer;
25636 0 : pypointer = _pyme_obj2gpgme_data_t(obj2, 3, &wrapper3,
25637 : &bytesio3, &view3);
25638 0 : if (pypointer == NULL)
25639 : return NULL;
25640 0 : have_view3 = !! view3.obj;
25641 :
25642 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
25643 :
25644 : // Following code is from swig's python.swg
25645 :
25646 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
25647 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
25648 0 : Py_DECREF(pypointer);
25649 : return NULL;
25650 : }
25651 0 : Py_DECREF(pypointer);
25652 : }
25653 : }
25654 : {
25655 : /* If we create a temporary wrapper4 object, we will store it in
25656 : wrapperN, where N is 4. Here in this fragment, SWIG will
25657 : automatically append 4. */
25658 : memset(&view4, 0, sizeof view4);
25659 2 : if (obj3 == Py_None)
25660 2 : arg4 = NULL;
25661 : else {
25662 : PyObject *pypointer;
25663 0 : pypointer = _pyme_obj2gpgme_data_t(obj3, 4, &wrapper4,
25664 : &bytesio4, &view4);
25665 0 : if (pypointer == NULL)
25666 : return NULL;
25667 0 : have_view4 = !! view4.obj;
25668 :
25669 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
25670 :
25671 : // Following code is from swig's python.swg
25672 :
25673 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
25674 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
25675 0 : Py_DECREF(pypointer);
25676 : return NULL;
25677 : }
25678 0 : Py_DECREF(pypointer);
25679 : }
25680 : }
25681 2 : result = gpgme_op_genkey(arg1,(char const *)arg2,arg3,arg4);
25682 : {
25683 2 : resultobj = PyLong_FromLong(result);
25684 : }
25685 : {
25686 : /* See whether we need to update the Python buffer. */
25687 2 : if (resultobj && wrapper3 && view3.buf)
25688 : {
25689 : int dirty;
25690 0 : char *new_data = NULL;
25691 : size_t new_size;
25692 :
25693 :
25694 0 : new_data = wrapper3->data.mem.buffer;
25695 0 : new_size = wrapper3->data.mem.length;
25696 0 : dirty = new_data != NULL;
25697 :
25698 :
25699 :
25700 :
25701 :
25702 :
25703 :
25704 0 : if (dirty)
25705 : {
25706 : /* The buffer is dirty. */
25707 0 : if (view3.readonly)
25708 : {
25709 0 : Py_XDECREF(resultobj);
25710 0 : resultobj = NULL;
25711 0 : PyErr_SetString(PyExc_ValueError,
25712 : "cannot update read-only buffer");
25713 : }
25714 :
25715 : /* See if we need to truncate the buffer. */
25716 0 : if (resultobj && view3.len != new_size)
25717 : {
25718 0 : if (bytesio3 == NULL)
25719 : {
25720 0 : Py_XDECREF(resultobj);
25721 0 : resultobj = NULL;
25722 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25723 : }
25724 : else
25725 : {
25726 : PyObject *retval;
25727 0 : PyBuffer_Release(&view3);
25728 : assert(view3.obj == NULL);
25729 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
25730 : "l", (long) new_size);
25731 0 : if (retval == NULL)
25732 : {
25733 0 : Py_XDECREF(resultobj);
25734 : resultobj = NULL;
25735 : }
25736 : else
25737 : {
25738 0 : Py_DECREF(retval);
25739 :
25740 0 : retval = PyObject_CallMethod(bytesio3,
25741 : "getbuffer", NULL);
25742 0 : if (retval == NULL
25743 0 : || PyObject_GetBuffer(retval, &view3,
25744 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25745 : {
25746 0 : Py_XDECREF(resultobj);
25747 : resultobj = NULL;
25748 : }
25749 :
25750 0 : Py_XDECREF(retval);
25751 :
25752 0 : if (resultobj && view3.len
25753 0 : != new_size)
25754 : {
25755 0 : Py_XDECREF(resultobj);
25756 0 : resultobj = NULL;
25757 0 : PyErr_Format(PyExc_ValueError,
25758 : "Expected buffer of length %zu, got %zi",
25759 : new_size,
25760 : view3.len);
25761 : }
25762 : }
25763 : }
25764 : }
25765 0 : if (resultobj)
25766 0 : memcpy(view3.buf, new_data, new_size);
25767 : }
25768 :
25769 :
25770 :
25771 : }
25772 :
25773 : /* Free the temporary wrapper, if any. */
25774 2 : if (wrapper3)
25775 0 : gpgme_data_release(wrapper3);
25776 2 : Py_XDECREF (bytesio3);
25777 2 : if (have_view3 && view3.buf)
25778 0 : PyBuffer_Release(&view3);
25779 : }
25780 : {
25781 : /* See whether we need to update the Python buffer. */
25782 2 : if (resultobj && wrapper4 && view4.buf)
25783 : {
25784 : int dirty;
25785 0 : char *new_data = NULL;
25786 : size_t new_size;
25787 :
25788 :
25789 0 : new_data = wrapper4->data.mem.buffer;
25790 0 : new_size = wrapper4->data.mem.length;
25791 0 : dirty = new_data != NULL;
25792 :
25793 :
25794 :
25795 :
25796 :
25797 :
25798 :
25799 0 : if (dirty)
25800 : {
25801 : /* The buffer is dirty. */
25802 0 : if (view4.readonly)
25803 : {
25804 0 : Py_XDECREF(resultobj);
25805 0 : resultobj = NULL;
25806 0 : PyErr_SetString(PyExc_ValueError,
25807 : "cannot update read-only buffer");
25808 : }
25809 :
25810 : /* See if we need to truncate the buffer. */
25811 0 : if (resultobj && view4.len != new_size)
25812 : {
25813 0 : if (bytesio4 == NULL)
25814 : {
25815 0 : Py_XDECREF(resultobj);
25816 0 : resultobj = NULL;
25817 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25818 : }
25819 : else
25820 : {
25821 : PyObject *retval;
25822 0 : PyBuffer_Release(&view4);
25823 : assert(view4.obj == NULL);
25824 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
25825 : "l", (long) new_size);
25826 0 : if (retval == NULL)
25827 : {
25828 0 : Py_XDECREF(resultobj);
25829 : resultobj = NULL;
25830 : }
25831 : else
25832 : {
25833 0 : Py_DECREF(retval);
25834 :
25835 0 : retval = PyObject_CallMethod(bytesio4,
25836 : "getbuffer", NULL);
25837 0 : if (retval == NULL
25838 0 : || PyObject_GetBuffer(retval, &view4,
25839 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25840 : {
25841 0 : Py_XDECREF(resultobj);
25842 : resultobj = NULL;
25843 : }
25844 :
25845 0 : Py_XDECREF(retval);
25846 :
25847 0 : if (resultobj && view4.len
25848 0 : != new_size)
25849 : {
25850 0 : Py_XDECREF(resultobj);
25851 0 : resultobj = NULL;
25852 0 : PyErr_Format(PyExc_ValueError,
25853 : "Expected buffer of length %zu, got %zi",
25854 : new_size,
25855 : view4.len);
25856 : }
25857 : }
25858 : }
25859 : }
25860 0 : if (resultobj)
25861 0 : memcpy(view4.buf, new_data, new_size);
25862 : }
25863 :
25864 :
25865 :
25866 : }
25867 :
25868 : /* Free the temporary wrapper, if any. */
25869 2 : if (wrapper4)
25870 0 : gpgme_data_release(wrapper4);
25871 2 : Py_XDECREF (bytesio4);
25872 2 : if (have_view4 && view4.buf)
25873 0 : PyBuffer_Release(&view4);
25874 : }
25875 2 : return resultobj;
25876 : fail:
25877 : {
25878 : /* See whether we need to update the Python buffer. */
25879 : if (resultobj && wrapper3 && view3.buf)
25880 : {
25881 : int dirty;
25882 : char *new_data = NULL;
25883 : size_t new_size;
25884 :
25885 :
25886 : new_data = wrapper3->data.mem.buffer;
25887 : new_size = wrapper3->data.mem.length;
25888 : dirty = new_data != NULL;
25889 :
25890 :
25891 :
25892 :
25893 :
25894 :
25895 :
25896 : if (dirty)
25897 : {
25898 : /* The buffer is dirty. */
25899 : if (view3.readonly)
25900 : {
25901 : Py_XDECREF(resultobj);
25902 : resultobj = NULL;
25903 : PyErr_SetString(PyExc_ValueError,
25904 : "cannot update read-only buffer");
25905 : }
25906 :
25907 : /* See if we need to truncate the buffer. */
25908 : if (resultobj && view3.len != new_size)
25909 : {
25910 : if (bytesio3 == NULL)
25911 : {
25912 : Py_XDECREF(resultobj);
25913 : resultobj = NULL;
25914 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25915 : }
25916 : else
25917 : {
25918 : PyObject *retval;
25919 : PyBuffer_Release(&view3);
25920 : assert(view3.obj == NULL);
25921 : retval = PyObject_CallMethod(bytesio3, "truncate",
25922 : "l", (long) new_size);
25923 : if (retval == NULL)
25924 : {
25925 : Py_XDECREF(resultobj);
25926 : resultobj = NULL;
25927 : }
25928 : else
25929 : {
25930 : Py_DECREF(retval);
25931 :
25932 : retval = PyObject_CallMethod(bytesio3,
25933 : "getbuffer", NULL);
25934 : if (retval == NULL
25935 : || PyObject_GetBuffer(retval, &view3,
25936 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25937 : {
25938 : Py_XDECREF(resultobj);
25939 : resultobj = NULL;
25940 : }
25941 :
25942 : Py_XDECREF(retval);
25943 :
25944 : if (resultobj && view3.len
25945 : != new_size)
25946 : {
25947 : Py_XDECREF(resultobj);
25948 : resultobj = NULL;
25949 : PyErr_Format(PyExc_ValueError,
25950 : "Expected buffer of length %zu, got %zi",
25951 : new_size,
25952 : view3.len);
25953 : }
25954 : }
25955 : }
25956 : }
25957 : if (resultobj)
25958 : memcpy(view3.buf, new_data, new_size);
25959 : }
25960 :
25961 :
25962 :
25963 : }
25964 :
25965 : /* Free the temporary wrapper, if any. */
25966 0 : if (wrapper3)
25967 0 : gpgme_data_release(wrapper3);
25968 0 : Py_XDECREF (bytesio3);
25969 : if (have_view3 && view3.buf)
25970 : PyBuffer_Release(&view3);
25971 : }
25972 : {
25973 : /* See whether we need to update the Python buffer. */
25974 : if (resultobj && wrapper4 && view4.buf)
25975 : {
25976 : int dirty;
25977 : char *new_data = NULL;
25978 : size_t new_size;
25979 :
25980 :
25981 : new_data = wrapper4->data.mem.buffer;
25982 : new_size = wrapper4->data.mem.length;
25983 : dirty = new_data != NULL;
25984 :
25985 :
25986 :
25987 :
25988 :
25989 :
25990 :
25991 : if (dirty)
25992 : {
25993 : /* The buffer is dirty. */
25994 : if (view4.readonly)
25995 : {
25996 : Py_XDECREF(resultobj);
25997 : resultobj = NULL;
25998 : PyErr_SetString(PyExc_ValueError,
25999 : "cannot update read-only buffer");
26000 : }
26001 :
26002 : /* See if we need to truncate the buffer. */
26003 : if (resultobj && view4.len != new_size)
26004 : {
26005 : if (bytesio4 == NULL)
26006 : {
26007 : Py_XDECREF(resultobj);
26008 : resultobj = NULL;
26009 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26010 : }
26011 : else
26012 : {
26013 : PyObject *retval;
26014 : PyBuffer_Release(&view4);
26015 : assert(view4.obj == NULL);
26016 : retval = PyObject_CallMethod(bytesio4, "truncate",
26017 : "l", (long) new_size);
26018 : if (retval == NULL)
26019 : {
26020 : Py_XDECREF(resultobj);
26021 : resultobj = NULL;
26022 : }
26023 : else
26024 : {
26025 : Py_DECREF(retval);
26026 :
26027 : retval = PyObject_CallMethod(bytesio4,
26028 : "getbuffer", NULL);
26029 : if (retval == NULL
26030 : || PyObject_GetBuffer(retval, &view4,
26031 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26032 : {
26033 : Py_XDECREF(resultobj);
26034 : resultobj = NULL;
26035 : }
26036 :
26037 : Py_XDECREF(retval);
26038 :
26039 : if (resultobj && view4.len
26040 : != new_size)
26041 : {
26042 : Py_XDECREF(resultobj);
26043 : resultobj = NULL;
26044 : PyErr_Format(PyExc_ValueError,
26045 : "Expected buffer of length %zu, got %zi",
26046 : new_size,
26047 : view4.len);
26048 : }
26049 : }
26050 : }
26051 : }
26052 : if (resultobj)
26053 : memcpy(view4.buf, new_data, new_size);
26054 : }
26055 :
26056 :
26057 :
26058 : }
26059 :
26060 : /* Free the temporary wrapper, if any. */
26061 0 : if (wrapper4)
26062 0 : gpgme_data_release(wrapper4);
26063 0 : Py_XDECREF (bytesio4);
26064 : if (have_view4 && view4.buf)
26065 : PyBuffer_Release(&view4);
26066 : }
26067 : return NULL;
26068 : }
26069 :
26070 :
26071 0 : SWIGINTERN PyObject *_wrap_gpgme_op_genkey_result(PyObject *self, PyObject *args) {
26072 0 : PyObject *resultobj = 0;
26073 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26074 0 : void *argp1 = 0 ;
26075 0 : int res1 = 0 ;
26076 0 : PyObject * obj0 = 0 ;
26077 : gpgme_genkey_result_t result;
26078 :
26079 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_genkey_result",&obj0)) SWIG_fail;
26080 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
26081 0 : if (!SWIG_IsOK(res1)) {
26082 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_genkey_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
26083 : }
26084 0 : arg1 = (gpgme_ctx_t)(argp1);
26085 0 : result = (gpgme_genkey_result_t)gpgme_op_genkey_result(arg1);
26086 : {
26087 : PyObject *fragile;
26088 0 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_genkey_result,
26089 : 0 );
26090 0 : resultobj = _pyme_wrap_result(fragile, "GenkeyResult");
26091 0 : Py_DECREF(fragile);
26092 : }
26093 0 : return resultobj;
26094 : fail:
26095 : return NULL;
26096 : }
26097 :
26098 :
26099 0 : SWIGINTERN PyObject *_wrap_gpgme_op_delete_start(PyObject *self, PyObject *args) {
26100 0 : PyObject *resultobj = 0;
26101 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26102 0 : gpgme_key_t arg2 = (gpgme_key_t) (gpgme_key_t)0 ;
26103 : int arg3 ;
26104 0 : void *argp1 = 0 ;
26105 0 : int res1 = 0 ;
26106 0 : void *argp2 = 0 ;
26107 0 : int res2 = 0 ;
26108 : int val3 ;
26109 0 : int ecode3 = 0 ;
26110 0 : PyObject * obj0 = 0 ;
26111 0 : PyObject * obj1 = 0 ;
26112 0 : PyObject * obj2 = 0 ;
26113 : gpgme_error_t result;
26114 :
26115 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_delete_start",&obj0,&obj1,&obj2)) SWIG_fail;
26116 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
26117 0 : if (!SWIG_IsOK(res1)) {
26118 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_delete_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
26119 : }
26120 0 : arg1 = (gpgme_ctx_t)(argp1);
26121 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
26122 0 : if (!SWIG_IsOK(res2)) {
26123 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_delete_start" "', argument " "2"" of type '" "gpgme_key_t const""'");
26124 : }
26125 0 : arg2 = (gpgme_key_t)(argp2);
26126 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
26127 0 : if (!SWIG_IsOK(ecode3)) {
26128 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_delete_start" "', argument " "3"" of type '" "int""'");
26129 : }
26130 0 : arg3 = (int)(val3);
26131 0 : result = gpgme_op_delete_start(arg1,arg2,arg3);
26132 : {
26133 0 : resultobj = PyLong_FromLong(result);
26134 : }
26135 0 : return resultobj;
26136 : fail:
26137 : return NULL;
26138 : }
26139 :
26140 :
26141 0 : SWIGINTERN PyObject *_wrap_gpgme_op_delete(PyObject *self, PyObject *args) {
26142 0 : PyObject *resultobj = 0;
26143 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26144 0 : gpgme_key_t arg2 = (gpgme_key_t) (gpgme_key_t)0 ;
26145 : int arg3 ;
26146 0 : void *argp1 = 0 ;
26147 0 : int res1 = 0 ;
26148 0 : void *argp2 = 0 ;
26149 0 : int res2 = 0 ;
26150 : int val3 ;
26151 0 : int ecode3 = 0 ;
26152 0 : PyObject * obj0 = 0 ;
26153 0 : PyObject * obj1 = 0 ;
26154 0 : PyObject * obj2 = 0 ;
26155 : gpgme_error_t result;
26156 :
26157 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_delete",&obj0,&obj1,&obj2)) SWIG_fail;
26158 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
26159 0 : if (!SWIG_IsOK(res1)) {
26160 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_delete" "', argument " "1"" of type '" "gpgme_ctx_t""'");
26161 : }
26162 0 : arg1 = (gpgme_ctx_t)(argp1);
26163 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
26164 0 : if (!SWIG_IsOK(res2)) {
26165 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_delete" "', argument " "2"" of type '" "gpgme_key_t const""'");
26166 : }
26167 0 : arg2 = (gpgme_key_t)(argp2);
26168 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
26169 0 : if (!SWIG_IsOK(ecode3)) {
26170 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_delete" "', argument " "3"" of type '" "int""'");
26171 : }
26172 0 : arg3 = (int)(val3);
26173 0 : result = gpgme_op_delete(arg1,arg2,arg3);
26174 : {
26175 0 : resultobj = PyLong_FromLong(result);
26176 : }
26177 0 : return resultobj;
26178 : fail:
26179 : return NULL;
26180 : }
26181 :
26182 :
26183 0 : SWIGINTERN PyObject *_wrap_gpgme_op_edit_start(PyObject *self, PyObject *args) {
26184 0 : PyObject *resultobj = 0;
26185 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26186 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
26187 0 : gpgme_edit_cb_t arg3 = (gpgme_edit_cb_t) 0 ;
26188 0 : void *arg4 = (void *) 0 ;
26189 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
26190 0 : void *argp1 = 0 ;
26191 0 : int res1 = 0 ;
26192 0 : void *argp2 = 0 ;
26193 0 : int res2 = 0 ;
26194 0 : gpgme_data_t wrapper5 = NULL ;
26195 0 : PyObject *bytesio5 = NULL ;
26196 : Py_buffer view5 ;
26197 0 : int have_view5 = 0 ;
26198 0 : PyObject * obj0 = 0 ;
26199 0 : PyObject * obj1 = 0 ;
26200 0 : PyObject * obj2 = 0 ;
26201 0 : PyObject * obj3 = 0 ;
26202 : gpgme_error_t result;
26203 :
26204 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_edit_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26205 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
26206 0 : if (!SWIG_IsOK(res1)) {
26207 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_edit_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
26208 : }
26209 0 : arg1 = (gpgme_ctx_t)(argp1);
26210 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
26211 0 : if (!SWIG_IsOK(res2)) {
26212 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_edit_start" "', argument " "2"" of type '" "gpgme_key_t""'");
26213 : }
26214 0 : arg2 = (gpgme_key_t)(argp2);
26215 : {
26216 0 : if (! PyTuple_Check(obj2))
26217 0 : return PyErr_Format(PyExc_TypeError, "edit callback must be a tuple");
26218 0 : if (PyTuple_Size(obj2) != 2 && PyTuple_Size(obj2) != 3)
26219 0 : return PyErr_Format(PyExc_TypeError,
26220 : "edit callback must be a tuple of size 2 or 3");
26221 :
26222 0 : arg3 = (gpgme_edit_cb_t) _pyme_edit_cb;
26223 0 : arg4 = obj2;
26224 : }
26225 : {
26226 : /* If we create a temporary wrapper5 object, we will store it in
26227 : wrapperN, where N is 5. Here in this fragment, SWIG will
26228 : automatically append 5. */
26229 : memset(&view5, 0, sizeof view5);
26230 0 : if (obj3 == Py_None)
26231 0 : arg5 = NULL;
26232 : else {
26233 : PyObject *pypointer;
26234 0 : pypointer = _pyme_obj2gpgme_data_t(obj3, 5, &wrapper5,
26235 : &bytesio5, &view5);
26236 0 : if (pypointer == NULL)
26237 : return NULL;
26238 0 : have_view5 = !! view5.obj;
26239 :
26240 : /* input = obj3, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
26241 :
26242 : // Following code is from swig's python.swg
26243 :
26244 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
26245 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
26246 0 : Py_DECREF(pypointer);
26247 : return NULL;
26248 : }
26249 0 : Py_DECREF(pypointer);
26250 : }
26251 : }
26252 0 : result = gpgme_op_edit_start(arg1,arg2,arg3,arg4,arg5);
26253 : {
26254 0 : resultobj = PyLong_FromLong(result);
26255 : }
26256 : {
26257 : /* See whether we need to update the Python buffer. */
26258 0 : if (resultobj && wrapper5 && view5.buf)
26259 : {
26260 : int dirty;
26261 0 : char *new_data = NULL;
26262 : size_t new_size;
26263 :
26264 :
26265 0 : new_data = wrapper5->data.mem.buffer;
26266 0 : new_size = wrapper5->data.mem.length;
26267 0 : dirty = new_data != NULL;
26268 :
26269 :
26270 :
26271 :
26272 :
26273 :
26274 :
26275 0 : if (dirty)
26276 : {
26277 : /* The buffer is dirty. */
26278 0 : if (view5.readonly)
26279 : {
26280 0 : Py_XDECREF(resultobj);
26281 0 : resultobj = NULL;
26282 0 : PyErr_SetString(PyExc_ValueError,
26283 : "cannot update read-only buffer");
26284 : }
26285 :
26286 : /* See if we need to truncate the buffer. */
26287 0 : if (resultobj && view5.len != new_size)
26288 : {
26289 0 : if (bytesio5 == NULL)
26290 : {
26291 0 : Py_XDECREF(resultobj);
26292 0 : resultobj = NULL;
26293 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26294 : }
26295 : else
26296 : {
26297 : PyObject *retval;
26298 0 : PyBuffer_Release(&view5);
26299 : assert(view5.obj == NULL);
26300 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
26301 : "l", (long) new_size);
26302 0 : if (retval == NULL)
26303 : {
26304 0 : Py_XDECREF(resultobj);
26305 : resultobj = NULL;
26306 : }
26307 : else
26308 : {
26309 0 : Py_DECREF(retval);
26310 :
26311 0 : retval = PyObject_CallMethod(bytesio5,
26312 : "getbuffer", NULL);
26313 0 : if (retval == NULL
26314 0 : || PyObject_GetBuffer(retval, &view5,
26315 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26316 : {
26317 0 : Py_XDECREF(resultobj);
26318 : resultobj = NULL;
26319 : }
26320 :
26321 0 : Py_XDECREF(retval);
26322 :
26323 0 : if (resultobj && view5.len
26324 0 : != new_size)
26325 : {
26326 0 : Py_XDECREF(resultobj);
26327 0 : resultobj = NULL;
26328 0 : PyErr_Format(PyExc_ValueError,
26329 : "Expected buffer of length %zu, got %zi",
26330 : new_size,
26331 : view5.len);
26332 : }
26333 : }
26334 : }
26335 : }
26336 0 : if (resultobj)
26337 0 : memcpy(view5.buf, new_data, new_size);
26338 : }
26339 :
26340 :
26341 :
26342 : }
26343 :
26344 : /* Free the temporary wrapper, if any. */
26345 0 : if (wrapper5)
26346 0 : gpgme_data_release(wrapper5);
26347 0 : Py_XDECREF (bytesio5);
26348 0 : if (have_view5 && view5.buf)
26349 0 : PyBuffer_Release(&view5);
26350 : }
26351 0 : return resultobj;
26352 : fail:
26353 : {
26354 : /* See whether we need to update the Python buffer. */
26355 : if (resultobj && wrapper5 && view5.buf)
26356 : {
26357 : int dirty;
26358 : char *new_data = NULL;
26359 : size_t new_size;
26360 :
26361 :
26362 : new_data = wrapper5->data.mem.buffer;
26363 : new_size = wrapper5->data.mem.length;
26364 : dirty = new_data != NULL;
26365 :
26366 :
26367 :
26368 :
26369 :
26370 :
26371 :
26372 : if (dirty)
26373 : {
26374 : /* The buffer is dirty. */
26375 : if (view5.readonly)
26376 : {
26377 : Py_XDECREF(resultobj);
26378 : resultobj = NULL;
26379 : PyErr_SetString(PyExc_ValueError,
26380 : "cannot update read-only buffer");
26381 : }
26382 :
26383 : /* See if we need to truncate the buffer. */
26384 : if (resultobj && view5.len != new_size)
26385 : {
26386 : if (bytesio5 == NULL)
26387 : {
26388 : Py_XDECREF(resultobj);
26389 : resultobj = NULL;
26390 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26391 : }
26392 : else
26393 : {
26394 : PyObject *retval;
26395 : PyBuffer_Release(&view5);
26396 : assert(view5.obj == NULL);
26397 : retval = PyObject_CallMethod(bytesio5, "truncate",
26398 : "l", (long) new_size);
26399 : if (retval == NULL)
26400 : {
26401 : Py_XDECREF(resultobj);
26402 : resultobj = NULL;
26403 : }
26404 : else
26405 : {
26406 : Py_DECREF(retval);
26407 :
26408 : retval = PyObject_CallMethod(bytesio5,
26409 : "getbuffer", NULL);
26410 : if (retval == NULL
26411 : || PyObject_GetBuffer(retval, &view5,
26412 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26413 : {
26414 : Py_XDECREF(resultobj);
26415 : resultobj = NULL;
26416 : }
26417 :
26418 : Py_XDECREF(retval);
26419 :
26420 : if (resultobj && view5.len
26421 : != new_size)
26422 : {
26423 : Py_XDECREF(resultobj);
26424 : resultobj = NULL;
26425 : PyErr_Format(PyExc_ValueError,
26426 : "Expected buffer of length %zu, got %zi",
26427 : new_size,
26428 : view5.len);
26429 : }
26430 : }
26431 : }
26432 : }
26433 : if (resultobj)
26434 : memcpy(view5.buf, new_data, new_size);
26435 : }
26436 :
26437 :
26438 :
26439 : }
26440 :
26441 : /* Free the temporary wrapper, if any. */
26442 0 : if (wrapper5)
26443 0 : gpgme_data_release(wrapper5);
26444 0 : Py_XDECREF (bytesio5);
26445 : if (have_view5 && view5.buf)
26446 : PyBuffer_Release(&view5);
26447 : }
26448 : return NULL;
26449 : }
26450 :
26451 :
26452 4 : SWIGINTERN PyObject *_wrap_gpgme_op_edit(PyObject *self, PyObject *args) {
26453 4 : PyObject *resultobj = 0;
26454 4 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26455 4 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
26456 4 : gpgme_edit_cb_t arg3 = (gpgme_edit_cb_t) 0 ;
26457 4 : void *arg4 = (void *) 0 ;
26458 4 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
26459 4 : void *argp1 = 0 ;
26460 4 : int res1 = 0 ;
26461 4 : void *argp2 = 0 ;
26462 4 : int res2 = 0 ;
26463 4 : gpgme_data_t wrapper5 = NULL ;
26464 4 : PyObject *bytesio5 = NULL ;
26465 : Py_buffer view5 ;
26466 4 : int have_view5 = 0 ;
26467 4 : PyObject * obj0 = 0 ;
26468 4 : PyObject * obj1 = 0 ;
26469 4 : PyObject * obj2 = 0 ;
26470 4 : PyObject * obj3 = 0 ;
26471 : gpgme_error_t result;
26472 :
26473 4 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_edit",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26474 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
26475 4 : if (!SWIG_IsOK(res1)) {
26476 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_edit" "', argument " "1"" of type '" "gpgme_ctx_t""'");
26477 : }
26478 4 : arg1 = (gpgme_ctx_t)(argp1);
26479 4 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
26480 4 : if (!SWIG_IsOK(res2)) {
26481 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_edit" "', argument " "2"" of type '" "gpgme_key_t""'");
26482 : }
26483 4 : arg2 = (gpgme_key_t)(argp2);
26484 : {
26485 4 : if (! PyTuple_Check(obj2))
26486 0 : return PyErr_Format(PyExc_TypeError, "edit callback must be a tuple");
26487 4 : if (PyTuple_Size(obj2) != 2 && PyTuple_Size(obj2) != 3)
26488 0 : return PyErr_Format(PyExc_TypeError,
26489 : "edit callback must be a tuple of size 2 or 3");
26490 :
26491 4 : arg3 = (gpgme_edit_cb_t) _pyme_edit_cb;
26492 4 : arg4 = obj2;
26493 : }
26494 : {
26495 : /* If we create a temporary wrapper5 object, we will store it in
26496 : wrapperN, where N is 5. Here in this fragment, SWIG will
26497 : automatically append 5. */
26498 : memset(&view5, 0, sizeof view5);
26499 4 : if (obj3 == Py_None)
26500 0 : arg5 = NULL;
26501 : else {
26502 : PyObject *pypointer;
26503 4 : pypointer = _pyme_obj2gpgme_data_t(obj3, 5, &wrapper5,
26504 : &bytesio5, &view5);
26505 4 : if (pypointer == NULL)
26506 : return NULL;
26507 4 : have_view5 = !! view5.obj;
26508 :
26509 : /* input = obj3, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
26510 :
26511 : // Following code is from swig's python.swg
26512 :
26513 4 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
26514 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
26515 0 : Py_DECREF(pypointer);
26516 : return NULL;
26517 : }
26518 4 : Py_DECREF(pypointer);
26519 : }
26520 : }
26521 4 : result = gpgme_op_edit(arg1,arg2,arg3,arg4,arg5);
26522 : {
26523 4 : resultobj = PyLong_FromLong(result);
26524 : }
26525 : {
26526 : /* See whether we need to update the Python buffer. */
26527 4 : if (resultobj && wrapper5 && view5.buf)
26528 : {
26529 : int dirty;
26530 0 : char *new_data = NULL;
26531 : size_t new_size;
26532 :
26533 :
26534 0 : new_data = wrapper5->data.mem.buffer;
26535 0 : new_size = wrapper5->data.mem.length;
26536 0 : dirty = new_data != NULL;
26537 :
26538 :
26539 :
26540 :
26541 :
26542 :
26543 :
26544 0 : if (dirty)
26545 : {
26546 : /* The buffer is dirty. */
26547 0 : if (view5.readonly)
26548 : {
26549 0 : Py_XDECREF(resultobj);
26550 0 : resultobj = NULL;
26551 0 : PyErr_SetString(PyExc_ValueError,
26552 : "cannot update read-only buffer");
26553 : }
26554 :
26555 : /* See if we need to truncate the buffer. */
26556 0 : if (resultobj && view5.len != new_size)
26557 : {
26558 0 : if (bytesio5 == NULL)
26559 : {
26560 0 : Py_XDECREF(resultobj);
26561 0 : resultobj = NULL;
26562 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26563 : }
26564 : else
26565 : {
26566 : PyObject *retval;
26567 0 : PyBuffer_Release(&view5);
26568 : assert(view5.obj == NULL);
26569 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
26570 : "l", (long) new_size);
26571 0 : if (retval == NULL)
26572 : {
26573 0 : Py_XDECREF(resultobj);
26574 : resultobj = NULL;
26575 : }
26576 : else
26577 : {
26578 0 : Py_DECREF(retval);
26579 :
26580 0 : retval = PyObject_CallMethod(bytesio5,
26581 : "getbuffer", NULL);
26582 0 : if (retval == NULL
26583 0 : || PyObject_GetBuffer(retval, &view5,
26584 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26585 : {
26586 0 : Py_XDECREF(resultobj);
26587 : resultobj = NULL;
26588 : }
26589 :
26590 0 : Py_XDECREF(retval);
26591 :
26592 0 : if (resultobj && view5.len
26593 0 : != new_size)
26594 : {
26595 0 : Py_XDECREF(resultobj);
26596 0 : resultobj = NULL;
26597 0 : PyErr_Format(PyExc_ValueError,
26598 : "Expected buffer of length %zu, got %zi",
26599 : new_size,
26600 : view5.len);
26601 : }
26602 : }
26603 : }
26604 : }
26605 0 : if (resultobj)
26606 0 : memcpy(view5.buf, new_data, new_size);
26607 : }
26608 :
26609 :
26610 :
26611 : }
26612 :
26613 : /* Free the temporary wrapper, if any. */
26614 4 : if (wrapper5)
26615 0 : gpgme_data_release(wrapper5);
26616 4 : Py_XDECREF (bytesio5);
26617 4 : if (have_view5 && view5.buf)
26618 0 : PyBuffer_Release(&view5);
26619 : }
26620 4 : return resultobj;
26621 : fail:
26622 : {
26623 : /* See whether we need to update the Python buffer. */
26624 : if (resultobj && wrapper5 && view5.buf)
26625 : {
26626 : int dirty;
26627 : char *new_data = NULL;
26628 : size_t new_size;
26629 :
26630 :
26631 : new_data = wrapper5->data.mem.buffer;
26632 : new_size = wrapper5->data.mem.length;
26633 : dirty = new_data != NULL;
26634 :
26635 :
26636 :
26637 :
26638 :
26639 :
26640 :
26641 : if (dirty)
26642 : {
26643 : /* The buffer is dirty. */
26644 : if (view5.readonly)
26645 : {
26646 : Py_XDECREF(resultobj);
26647 : resultobj = NULL;
26648 : PyErr_SetString(PyExc_ValueError,
26649 : "cannot update read-only buffer");
26650 : }
26651 :
26652 : /* See if we need to truncate the buffer. */
26653 : if (resultobj && view5.len != new_size)
26654 : {
26655 : if (bytesio5 == NULL)
26656 : {
26657 : Py_XDECREF(resultobj);
26658 : resultobj = NULL;
26659 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26660 : }
26661 : else
26662 : {
26663 : PyObject *retval;
26664 : PyBuffer_Release(&view5);
26665 : assert(view5.obj == NULL);
26666 : retval = PyObject_CallMethod(bytesio5, "truncate",
26667 : "l", (long) new_size);
26668 : if (retval == NULL)
26669 : {
26670 : Py_XDECREF(resultobj);
26671 : resultobj = NULL;
26672 : }
26673 : else
26674 : {
26675 : Py_DECREF(retval);
26676 :
26677 : retval = PyObject_CallMethod(bytesio5,
26678 : "getbuffer", NULL);
26679 : if (retval == NULL
26680 : || PyObject_GetBuffer(retval, &view5,
26681 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26682 : {
26683 : Py_XDECREF(resultobj);
26684 : resultobj = NULL;
26685 : }
26686 :
26687 : Py_XDECREF(retval);
26688 :
26689 : if (resultobj && view5.len
26690 : != new_size)
26691 : {
26692 : Py_XDECREF(resultobj);
26693 : resultobj = NULL;
26694 : PyErr_Format(PyExc_ValueError,
26695 : "Expected buffer of length %zu, got %zi",
26696 : new_size,
26697 : view5.len);
26698 : }
26699 : }
26700 : }
26701 : }
26702 : if (resultobj)
26703 : memcpy(view5.buf, new_data, new_size);
26704 : }
26705 :
26706 :
26707 :
26708 : }
26709 :
26710 : /* Free the temporary wrapper, if any. */
26711 0 : if (wrapper5)
26712 0 : gpgme_data_release(wrapper5);
26713 0 : Py_XDECREF (bytesio5);
26714 : if (have_view5 && view5.buf)
26715 : PyBuffer_Release(&view5);
26716 : }
26717 : return NULL;
26718 : }
26719 :
26720 :
26721 0 : SWIGINTERN PyObject *_wrap_gpgme_op_card_edit_start(PyObject *self, PyObject *args) {
26722 0 : PyObject *resultobj = 0;
26723 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26724 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
26725 0 : gpgme_edit_cb_t arg3 = (gpgme_edit_cb_t) 0 ;
26726 0 : void *arg4 = (void *) 0 ;
26727 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
26728 0 : void *argp1 = 0 ;
26729 0 : int res1 = 0 ;
26730 0 : void *argp2 = 0 ;
26731 0 : int res2 = 0 ;
26732 0 : gpgme_data_t wrapper5 = NULL ;
26733 0 : PyObject *bytesio5 = NULL ;
26734 : Py_buffer view5 ;
26735 0 : int have_view5 = 0 ;
26736 0 : PyObject * obj0 = 0 ;
26737 0 : PyObject * obj1 = 0 ;
26738 0 : PyObject * obj2 = 0 ;
26739 0 : PyObject * obj3 = 0 ;
26740 : gpgme_error_t result;
26741 :
26742 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_card_edit_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26743 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
26744 0 : if (!SWIG_IsOK(res1)) {
26745 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_card_edit_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
26746 : }
26747 0 : arg1 = (gpgme_ctx_t)(argp1);
26748 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
26749 0 : if (!SWIG_IsOK(res2)) {
26750 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_card_edit_start" "', argument " "2"" of type '" "gpgme_key_t""'");
26751 : }
26752 0 : arg2 = (gpgme_key_t)(argp2);
26753 : {
26754 0 : if (! PyTuple_Check(obj2))
26755 0 : return PyErr_Format(PyExc_TypeError, "edit callback must be a tuple");
26756 0 : if (PyTuple_Size(obj2) != 2 && PyTuple_Size(obj2) != 3)
26757 0 : return PyErr_Format(PyExc_TypeError,
26758 : "edit callback must be a tuple of size 2 or 3");
26759 :
26760 0 : arg3 = (gpgme_edit_cb_t) _pyme_edit_cb;
26761 0 : arg4 = obj2;
26762 : }
26763 : {
26764 : /* If we create a temporary wrapper5 object, we will store it in
26765 : wrapperN, where N is 5. Here in this fragment, SWIG will
26766 : automatically append 5. */
26767 : memset(&view5, 0, sizeof view5);
26768 0 : if (obj3 == Py_None)
26769 0 : arg5 = NULL;
26770 : else {
26771 : PyObject *pypointer;
26772 0 : pypointer = _pyme_obj2gpgme_data_t(obj3, 5, &wrapper5,
26773 : &bytesio5, &view5);
26774 0 : if (pypointer == NULL)
26775 : return NULL;
26776 0 : have_view5 = !! view5.obj;
26777 :
26778 : /* input = obj3, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
26779 :
26780 : // Following code is from swig's python.swg
26781 :
26782 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
26783 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
26784 0 : Py_DECREF(pypointer);
26785 : return NULL;
26786 : }
26787 0 : Py_DECREF(pypointer);
26788 : }
26789 : }
26790 0 : result = gpgme_op_card_edit_start(arg1,arg2,arg3,arg4,arg5);
26791 : {
26792 0 : resultobj = PyLong_FromLong(result);
26793 : }
26794 : {
26795 : /* See whether we need to update the Python buffer. */
26796 0 : if (resultobj && wrapper5 && view5.buf)
26797 : {
26798 : int dirty;
26799 0 : char *new_data = NULL;
26800 : size_t new_size;
26801 :
26802 :
26803 0 : new_data = wrapper5->data.mem.buffer;
26804 0 : new_size = wrapper5->data.mem.length;
26805 0 : dirty = new_data != NULL;
26806 :
26807 :
26808 :
26809 :
26810 :
26811 :
26812 :
26813 0 : if (dirty)
26814 : {
26815 : /* The buffer is dirty. */
26816 0 : if (view5.readonly)
26817 : {
26818 0 : Py_XDECREF(resultobj);
26819 0 : resultobj = NULL;
26820 0 : PyErr_SetString(PyExc_ValueError,
26821 : "cannot update read-only buffer");
26822 : }
26823 :
26824 : /* See if we need to truncate the buffer. */
26825 0 : if (resultobj && view5.len != new_size)
26826 : {
26827 0 : if (bytesio5 == NULL)
26828 : {
26829 0 : Py_XDECREF(resultobj);
26830 0 : resultobj = NULL;
26831 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26832 : }
26833 : else
26834 : {
26835 : PyObject *retval;
26836 0 : PyBuffer_Release(&view5);
26837 : assert(view5.obj == NULL);
26838 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
26839 : "l", (long) new_size);
26840 0 : if (retval == NULL)
26841 : {
26842 0 : Py_XDECREF(resultobj);
26843 : resultobj = NULL;
26844 : }
26845 : else
26846 : {
26847 0 : Py_DECREF(retval);
26848 :
26849 0 : retval = PyObject_CallMethod(bytesio5,
26850 : "getbuffer", NULL);
26851 0 : if (retval == NULL
26852 0 : || PyObject_GetBuffer(retval, &view5,
26853 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26854 : {
26855 0 : Py_XDECREF(resultobj);
26856 : resultobj = NULL;
26857 : }
26858 :
26859 0 : Py_XDECREF(retval);
26860 :
26861 0 : if (resultobj && view5.len
26862 0 : != new_size)
26863 : {
26864 0 : Py_XDECREF(resultobj);
26865 0 : resultobj = NULL;
26866 0 : PyErr_Format(PyExc_ValueError,
26867 : "Expected buffer of length %zu, got %zi",
26868 : new_size,
26869 : view5.len);
26870 : }
26871 : }
26872 : }
26873 : }
26874 0 : if (resultobj)
26875 0 : memcpy(view5.buf, new_data, new_size);
26876 : }
26877 :
26878 :
26879 :
26880 : }
26881 :
26882 : /* Free the temporary wrapper, if any. */
26883 0 : if (wrapper5)
26884 0 : gpgme_data_release(wrapper5);
26885 0 : Py_XDECREF (bytesio5);
26886 0 : if (have_view5 && view5.buf)
26887 0 : PyBuffer_Release(&view5);
26888 : }
26889 0 : return resultobj;
26890 : fail:
26891 : {
26892 : /* See whether we need to update the Python buffer. */
26893 : if (resultobj && wrapper5 && view5.buf)
26894 : {
26895 : int dirty;
26896 : char *new_data = NULL;
26897 : size_t new_size;
26898 :
26899 :
26900 : new_data = wrapper5->data.mem.buffer;
26901 : new_size = wrapper5->data.mem.length;
26902 : dirty = new_data != NULL;
26903 :
26904 :
26905 :
26906 :
26907 :
26908 :
26909 :
26910 : if (dirty)
26911 : {
26912 : /* The buffer is dirty. */
26913 : if (view5.readonly)
26914 : {
26915 : Py_XDECREF(resultobj);
26916 : resultobj = NULL;
26917 : PyErr_SetString(PyExc_ValueError,
26918 : "cannot update read-only buffer");
26919 : }
26920 :
26921 : /* See if we need to truncate the buffer. */
26922 : if (resultobj && view5.len != new_size)
26923 : {
26924 : if (bytesio5 == NULL)
26925 : {
26926 : Py_XDECREF(resultobj);
26927 : resultobj = NULL;
26928 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26929 : }
26930 : else
26931 : {
26932 : PyObject *retval;
26933 : PyBuffer_Release(&view5);
26934 : assert(view5.obj == NULL);
26935 : retval = PyObject_CallMethod(bytesio5, "truncate",
26936 : "l", (long) new_size);
26937 : if (retval == NULL)
26938 : {
26939 : Py_XDECREF(resultobj);
26940 : resultobj = NULL;
26941 : }
26942 : else
26943 : {
26944 : Py_DECREF(retval);
26945 :
26946 : retval = PyObject_CallMethod(bytesio5,
26947 : "getbuffer", NULL);
26948 : if (retval == NULL
26949 : || PyObject_GetBuffer(retval, &view5,
26950 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26951 : {
26952 : Py_XDECREF(resultobj);
26953 : resultobj = NULL;
26954 : }
26955 :
26956 : Py_XDECREF(retval);
26957 :
26958 : if (resultobj && view5.len
26959 : != new_size)
26960 : {
26961 : Py_XDECREF(resultobj);
26962 : resultobj = NULL;
26963 : PyErr_Format(PyExc_ValueError,
26964 : "Expected buffer of length %zu, got %zi",
26965 : new_size,
26966 : view5.len);
26967 : }
26968 : }
26969 : }
26970 : }
26971 : if (resultobj)
26972 : memcpy(view5.buf, new_data, new_size);
26973 : }
26974 :
26975 :
26976 :
26977 : }
26978 :
26979 : /* Free the temporary wrapper, if any. */
26980 0 : if (wrapper5)
26981 0 : gpgme_data_release(wrapper5);
26982 0 : Py_XDECREF (bytesio5);
26983 : if (have_view5 && view5.buf)
26984 : PyBuffer_Release(&view5);
26985 : }
26986 : return NULL;
26987 : }
26988 :
26989 :
26990 0 : SWIGINTERN PyObject *_wrap_gpgme_op_card_edit(PyObject *self, PyObject *args) {
26991 0 : PyObject *resultobj = 0;
26992 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26993 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
26994 0 : gpgme_edit_cb_t arg3 = (gpgme_edit_cb_t) 0 ;
26995 0 : void *arg4 = (void *) 0 ;
26996 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
26997 0 : void *argp1 = 0 ;
26998 0 : int res1 = 0 ;
26999 0 : void *argp2 = 0 ;
27000 0 : int res2 = 0 ;
27001 0 : gpgme_data_t wrapper5 = NULL ;
27002 0 : PyObject *bytesio5 = NULL ;
27003 : Py_buffer view5 ;
27004 0 : int have_view5 = 0 ;
27005 0 : PyObject * obj0 = 0 ;
27006 0 : PyObject * obj1 = 0 ;
27007 0 : PyObject * obj2 = 0 ;
27008 0 : PyObject * obj3 = 0 ;
27009 : gpgme_error_t result;
27010 :
27011 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_card_edit",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27012 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
27013 0 : if (!SWIG_IsOK(res1)) {
27014 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_card_edit" "', argument " "1"" of type '" "gpgme_ctx_t""'");
27015 : }
27016 0 : arg1 = (gpgme_ctx_t)(argp1);
27017 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
27018 0 : if (!SWIG_IsOK(res2)) {
27019 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_card_edit" "', argument " "2"" of type '" "gpgme_key_t""'");
27020 : }
27021 0 : arg2 = (gpgme_key_t)(argp2);
27022 : {
27023 0 : if (! PyTuple_Check(obj2))
27024 0 : return PyErr_Format(PyExc_TypeError, "edit callback must be a tuple");
27025 0 : if (PyTuple_Size(obj2) != 2 && PyTuple_Size(obj2) != 3)
27026 0 : return PyErr_Format(PyExc_TypeError,
27027 : "edit callback must be a tuple of size 2 or 3");
27028 :
27029 0 : arg3 = (gpgme_edit_cb_t) _pyme_edit_cb;
27030 0 : arg4 = obj2;
27031 : }
27032 : {
27033 : /* If we create a temporary wrapper5 object, we will store it in
27034 : wrapperN, where N is 5. Here in this fragment, SWIG will
27035 : automatically append 5. */
27036 : memset(&view5, 0, sizeof view5);
27037 0 : if (obj3 == Py_None)
27038 0 : arg5 = NULL;
27039 : else {
27040 : PyObject *pypointer;
27041 0 : pypointer = _pyme_obj2gpgme_data_t(obj3, 5, &wrapper5,
27042 : &bytesio5, &view5);
27043 0 : if (pypointer == NULL)
27044 : return NULL;
27045 0 : have_view5 = !! view5.obj;
27046 :
27047 : /* input = obj3, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
27048 :
27049 : // Following code is from swig's python.swg
27050 :
27051 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
27052 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
27053 0 : Py_DECREF(pypointer);
27054 : return NULL;
27055 : }
27056 0 : Py_DECREF(pypointer);
27057 : }
27058 : }
27059 0 : result = gpgme_op_card_edit(arg1,arg2,arg3,arg4,arg5);
27060 : {
27061 0 : resultobj = PyLong_FromLong(result);
27062 : }
27063 : {
27064 : /* See whether we need to update the Python buffer. */
27065 0 : if (resultobj && wrapper5 && view5.buf)
27066 : {
27067 : int dirty;
27068 0 : char *new_data = NULL;
27069 : size_t new_size;
27070 :
27071 :
27072 0 : new_data = wrapper5->data.mem.buffer;
27073 0 : new_size = wrapper5->data.mem.length;
27074 0 : dirty = new_data != NULL;
27075 :
27076 :
27077 :
27078 :
27079 :
27080 :
27081 :
27082 0 : if (dirty)
27083 : {
27084 : /* The buffer is dirty. */
27085 0 : if (view5.readonly)
27086 : {
27087 0 : Py_XDECREF(resultobj);
27088 0 : resultobj = NULL;
27089 0 : PyErr_SetString(PyExc_ValueError,
27090 : "cannot update read-only buffer");
27091 : }
27092 :
27093 : /* See if we need to truncate the buffer. */
27094 0 : if (resultobj && view5.len != new_size)
27095 : {
27096 0 : if (bytesio5 == NULL)
27097 : {
27098 0 : Py_XDECREF(resultobj);
27099 0 : resultobj = NULL;
27100 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27101 : }
27102 : else
27103 : {
27104 : PyObject *retval;
27105 0 : PyBuffer_Release(&view5);
27106 : assert(view5.obj == NULL);
27107 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
27108 : "l", (long) new_size);
27109 0 : if (retval == NULL)
27110 : {
27111 0 : Py_XDECREF(resultobj);
27112 : resultobj = NULL;
27113 : }
27114 : else
27115 : {
27116 0 : Py_DECREF(retval);
27117 :
27118 0 : retval = PyObject_CallMethod(bytesio5,
27119 : "getbuffer", NULL);
27120 0 : if (retval == NULL
27121 0 : || PyObject_GetBuffer(retval, &view5,
27122 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27123 : {
27124 0 : Py_XDECREF(resultobj);
27125 : resultobj = NULL;
27126 : }
27127 :
27128 0 : Py_XDECREF(retval);
27129 :
27130 0 : if (resultobj && view5.len
27131 0 : != new_size)
27132 : {
27133 0 : Py_XDECREF(resultobj);
27134 0 : resultobj = NULL;
27135 0 : PyErr_Format(PyExc_ValueError,
27136 : "Expected buffer of length %zu, got %zi",
27137 : new_size,
27138 : view5.len);
27139 : }
27140 : }
27141 : }
27142 : }
27143 0 : if (resultobj)
27144 0 : memcpy(view5.buf, new_data, new_size);
27145 : }
27146 :
27147 :
27148 :
27149 : }
27150 :
27151 : /* Free the temporary wrapper, if any. */
27152 0 : if (wrapper5)
27153 0 : gpgme_data_release(wrapper5);
27154 0 : Py_XDECREF (bytesio5);
27155 0 : if (have_view5 && view5.buf)
27156 0 : PyBuffer_Release(&view5);
27157 : }
27158 0 : return resultobj;
27159 : fail:
27160 : {
27161 : /* See whether we need to update the Python buffer. */
27162 : if (resultobj && wrapper5 && view5.buf)
27163 : {
27164 : int dirty;
27165 : char *new_data = NULL;
27166 : size_t new_size;
27167 :
27168 :
27169 : new_data = wrapper5->data.mem.buffer;
27170 : new_size = wrapper5->data.mem.length;
27171 : dirty = new_data != NULL;
27172 :
27173 :
27174 :
27175 :
27176 :
27177 :
27178 :
27179 : if (dirty)
27180 : {
27181 : /* The buffer is dirty. */
27182 : if (view5.readonly)
27183 : {
27184 : Py_XDECREF(resultobj);
27185 : resultobj = NULL;
27186 : PyErr_SetString(PyExc_ValueError,
27187 : "cannot update read-only buffer");
27188 : }
27189 :
27190 : /* See if we need to truncate the buffer. */
27191 : if (resultobj && view5.len != new_size)
27192 : {
27193 : if (bytesio5 == NULL)
27194 : {
27195 : Py_XDECREF(resultobj);
27196 : resultobj = NULL;
27197 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27198 : }
27199 : else
27200 : {
27201 : PyObject *retval;
27202 : PyBuffer_Release(&view5);
27203 : assert(view5.obj == NULL);
27204 : retval = PyObject_CallMethod(bytesio5, "truncate",
27205 : "l", (long) new_size);
27206 : if (retval == NULL)
27207 : {
27208 : Py_XDECREF(resultobj);
27209 : resultobj = NULL;
27210 : }
27211 : else
27212 : {
27213 : Py_DECREF(retval);
27214 :
27215 : retval = PyObject_CallMethod(bytesio5,
27216 : "getbuffer", NULL);
27217 : if (retval == NULL
27218 : || PyObject_GetBuffer(retval, &view5,
27219 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27220 : {
27221 : Py_XDECREF(resultobj);
27222 : resultobj = NULL;
27223 : }
27224 :
27225 : Py_XDECREF(retval);
27226 :
27227 : if (resultobj && view5.len
27228 : != new_size)
27229 : {
27230 : Py_XDECREF(resultobj);
27231 : resultobj = NULL;
27232 : PyErr_Format(PyExc_ValueError,
27233 : "Expected buffer of length %zu, got %zi",
27234 : new_size,
27235 : view5.len);
27236 : }
27237 : }
27238 : }
27239 : }
27240 : if (resultobj)
27241 : memcpy(view5.buf, new_data, new_size);
27242 : }
27243 :
27244 :
27245 :
27246 : }
27247 :
27248 : /* Free the temporary wrapper, if any. */
27249 0 : if (wrapper5)
27250 0 : gpgme_data_release(wrapper5);
27251 0 : Py_XDECREF (bytesio5);
27252 : if (have_view5 && view5.buf)
27253 : PyBuffer_Release(&view5);
27254 : }
27255 : return NULL;
27256 : }
27257 :
27258 :
27259 0 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result_truncated_set(PyObject *self, PyObject *args) {
27260 0 : PyObject *resultobj = 0;
27261 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
27262 : unsigned int arg2 ;
27263 0 : void *argp1 = 0 ;
27264 0 : int res1 = 0 ;
27265 : unsigned int val2 ;
27266 0 : int ecode2 = 0 ;
27267 0 : PyObject * obj1 = 0 ;
27268 :
27269 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_keylist_result_truncated_set",&obj1)) SWIG_fail;
27270 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
27271 0 : if (!SWIG_IsOK(res1)) {
27272 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result_truncated_set" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
27273 : }
27274 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
27275 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
27276 0 : if (!SWIG_IsOK(ecode2)) {
27277 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_keylist_result_truncated_set" "', argument " "2"" of type '" "unsigned int""'");
27278 : }
27279 0 : arg2 = (unsigned int)(val2);
27280 0 : if (arg1) (arg1)->truncated = arg2;
27281 0 : resultobj = SWIG_Py_Void();
27282 0 : return resultobj;
27283 : fail:
27284 : return NULL;
27285 : }
27286 :
27287 :
27288 2 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result_truncated_get(PyObject *self, PyObject *args) {
27289 2 : PyObject *resultobj = 0;
27290 2 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
27291 2 : void *argp1 = 0 ;
27292 2 : int res1 = 0 ;
27293 : unsigned int result;
27294 :
27295 2 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
27296 2 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
27297 2 : if (!SWIG_IsOK(res1)) {
27298 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result_truncated_get" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
27299 : }
27300 2 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
27301 2 : result = (unsigned int) ((arg1)->truncated);
27302 2 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
27303 2 : return resultobj;
27304 : fail:
27305 : return NULL;
27306 : }
27307 :
27308 :
27309 0 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result__unused_set(PyObject *self, PyObject *args) {
27310 0 : PyObject *resultobj = 0;
27311 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
27312 : unsigned int arg2 ;
27313 0 : void *argp1 = 0 ;
27314 0 : int res1 = 0 ;
27315 : unsigned int val2 ;
27316 0 : int ecode2 = 0 ;
27317 0 : PyObject * obj1 = 0 ;
27318 :
27319 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_keylist_result__unused_set",&obj1)) SWIG_fail;
27320 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
27321 0 : if (!SWIG_IsOK(res1)) {
27322 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result__unused_set" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
27323 : }
27324 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
27325 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
27326 0 : if (!SWIG_IsOK(ecode2)) {
27327 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_keylist_result__unused_set" "', argument " "2"" of type '" "unsigned int""'");
27328 : }
27329 0 : arg2 = (unsigned int)(val2);
27330 0 : if (arg1) (arg1)->_unused = arg2;
27331 0 : resultobj = SWIG_Py_Void();
27332 0 : return resultobj;
27333 : fail:
27334 : return NULL;
27335 : }
27336 :
27337 :
27338 0 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result__unused_get(PyObject *self, PyObject *args) {
27339 0 : PyObject *resultobj = 0;
27340 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
27341 0 : void *argp1 = 0 ;
27342 0 : int res1 = 0 ;
27343 : unsigned int result;
27344 :
27345 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
27346 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
27347 0 : if (!SWIG_IsOK(res1)) {
27348 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result__unused_get" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
27349 : }
27350 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
27351 0 : result = (unsigned int) ((arg1)->_unused);
27352 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
27353 0 : return resultobj;
27354 : fail:
27355 : return NULL;
27356 : }
27357 :
27358 :
27359 0 : SWIGINTERN int _wrap_new__gpgme_op_keylist_result(PyObject *self, PyObject *args) {
27360 0 : PyObject *resultobj = 0;
27361 0 : struct _gpgme_op_keylist_result *result = 0 ;
27362 :
27363 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
27364 0 : result = (struct _gpgme_op_keylist_result *)calloc(1, sizeof(struct _gpgme_op_keylist_result));
27365 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_keylist_result, SWIG_BUILTIN_INIT | 0 );
27366 0 : return resultobj == Py_None ? -1 : 0;
27367 : fail:
27368 : return -1;
27369 : }
27370 :
27371 :
27372 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_keylist_result(PyObject *self, PyObject *args) {
27373 0 : PyObject *resultobj = 0;
27374 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
27375 0 : void *argp1 = 0 ;
27376 0 : int res1 = 0 ;
27377 :
27378 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
27379 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, SWIG_POINTER_DISOWN | 0 );
27380 0 : if (!SWIG_IsOK(res1)) {
27381 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_keylist_result" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
27382 : }
27383 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
27384 0 : free((char *) arg1);
27385 0 : resultobj = SWIG_Py_Void();
27386 0 : return resultobj;
27387 : fail:
27388 : return NULL;
27389 : }
27390 :
27391 :
27392 1 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_result(PyObject *self, PyObject *args) {
27393 1 : PyObject *resultobj = 0;
27394 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
27395 1 : void *argp1 = 0 ;
27396 1 : int res1 = 0 ;
27397 1 : PyObject * obj0 = 0 ;
27398 : gpgme_keylist_result_t result;
27399 :
27400 1 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_keylist_result",&obj0)) SWIG_fail;
27401 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
27402 1 : if (!SWIG_IsOK(res1)) {
27403 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
27404 : }
27405 1 : arg1 = (gpgme_ctx_t)(argp1);
27406 1 : result = (gpgme_keylist_result_t)gpgme_op_keylist_result(arg1);
27407 : {
27408 : PyObject *fragile;
27409 1 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_keylist_result,
27410 : 0 );
27411 1 : resultobj = _pyme_wrap_result(fragile, "KeylistResult");
27412 1 : Py_DECREF(fragile);
27413 : }
27414 1 : return resultobj;
27415 : fail:
27416 : return NULL;
27417 : }
27418 :
27419 :
27420 3 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_start(PyObject *self, PyObject *args) {
27421 3 : PyObject *resultobj = 0;
27422 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
27423 3 : char *arg2 = (char *) 0 ;
27424 : int arg3 ;
27425 3 : void *argp1 = 0 ;
27426 3 : int res1 = 0 ;
27427 : int val3 ;
27428 3 : int ecode3 = 0 ;
27429 3 : PyObject * obj0 = 0 ;
27430 3 : PyObject * obj1 = 0 ;
27431 3 : PyObject * obj2 = 0 ;
27432 : gpgme_error_t result;
27433 :
27434 3 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_keylist_start",&obj0,&obj1,&obj2)) SWIG_fail;
27435 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
27436 3 : if (!SWIG_IsOK(res1)) {
27437 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
27438 : }
27439 3 : arg1 = (gpgme_ctx_t)(argp1);
27440 : {
27441 3 : if (obj1 == Py_None)
27442 : arg2 = NULL;
27443 1 : else if (PyUnicode_Check(obj1))
27444 1 : arg2 = PyUnicode_AsUTF8(obj1);
27445 0 : else if (PyBytes_Check(obj1))
27446 0 : arg2 = PyBytes_AsString(obj1);
27447 : else {
27448 0 : PyErr_Format(PyExc_TypeError,
27449 : "arg %d: expected str, bytes, or None, got %s",
27450 : 2, obj1->ob_type->tp_name);
27451 0 : return NULL;
27452 : }
27453 : }
27454 3 : ecode3 = SWIG_AsVal_int(obj2, &val3);
27455 3 : if (!SWIG_IsOK(ecode3)) {
27456 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_keylist_start" "', argument " "3"" of type '" "int""'");
27457 : }
27458 3 : arg3 = (int)(val3);
27459 3 : result = gpgme_op_keylist_start(arg1,(char const *)arg2,arg3);
27460 : {
27461 3 : resultobj = PyLong_FromLong(result);
27462 : }
27463 3 : return resultobj;
27464 : fail:
27465 : return NULL;
27466 : }
27467 :
27468 :
27469 0 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_ext_start(PyObject *self, PyObject *args) {
27470 0 : PyObject *resultobj = 0;
27471 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
27472 : char **arg2 ;
27473 : int arg3 ;
27474 : int arg4 ;
27475 0 : void *argp1 = 0 ;
27476 0 : int res1 = 0 ;
27477 0 : void *vector2 = NULL ;
27478 : int val3 ;
27479 0 : int ecode3 = 0 ;
27480 : int val4 ;
27481 0 : int ecode4 = 0 ;
27482 0 : PyObject * obj0 = 0 ;
27483 0 : PyObject * obj1 = 0 ;
27484 0 : PyObject * obj2 = 0 ;
27485 0 : PyObject * obj3 = 0 ;
27486 : gpgme_error_t result;
27487 :
27488 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_keylist_ext_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27489 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
27490 0 : if (!SWIG_IsOK(res1)) {
27491 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_ext_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
27492 : }
27493 0 : arg1 = (gpgme_ctx_t)(argp1);
27494 : {
27495 : /* Check if is a list */
27496 0 : if (PyList_Check(obj1)) {
27497 0 : size_t i, size = PyList_Size(obj1);
27498 0 : arg2 = (char **) (vector2 = malloc((size+1) * sizeof(char *)));
27499 :
27500 0 : for (i = 0; i < size; i++) {
27501 0 : PyObject *o = PyList_GetItem(obj1,i);
27502 0 : if (PyUnicode_Check(o))
27503 0 : arg2[i] = PyUnicode_AsUTF8(o);
27504 0 : else if (PyString_Check(o))
27505 0 : arg2[i] = PyString_AsString(o);
27506 : else {
27507 0 : PyErr_Format(PyExc_TypeError,
27508 : "arg %d: list must contain only str or bytes, got %s "
27509 : "at position %d",
27510 0 : 2, o->ob_type->tp_name, i);
27511 0 : free(arg2);
27512 0 : return NULL;
27513 : }
27514 : }
27515 0 : arg2[i] = NULL;
27516 : } else {
27517 0 : PyErr_Format(PyExc_TypeError,
27518 : "arg %d: expected a list of str or bytes, got %s",
27519 : 2, obj1->ob_type->tp_name);
27520 0 : return NULL;
27521 : }
27522 : }
27523 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
27524 0 : if (!SWIG_IsOK(ecode3)) {
27525 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_keylist_ext_start" "', argument " "3"" of type '" "int""'");
27526 : }
27527 0 : arg3 = (int)(val3);
27528 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
27529 0 : if (!SWIG_IsOK(ecode4)) {
27530 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_keylist_ext_start" "', argument " "4"" of type '" "int""'");
27531 : }
27532 0 : arg4 = (int)(val4);
27533 0 : result = gpgme_op_keylist_ext_start(arg1,(char const *(*))arg2,arg3,arg4);
27534 : {
27535 0 : resultobj = PyLong_FromLong(result);
27536 : }
27537 : {
27538 0 : free(vector2);
27539 : }
27540 0 : return resultobj;
27541 : fail:
27542 : {
27543 0 : free(vector2);
27544 : }
27545 0 : return NULL;
27546 : }
27547 :
27548 :
27549 56 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_next(PyObject *self, PyObject *args) {
27550 56 : PyObject *resultobj = 0;
27551 56 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
27552 56 : gpgme_key_t *arg2 = (gpgme_key_t *) 0 ;
27553 56 : void *argp1 = 0 ;
27554 56 : int res1 = 0 ;
27555 56 : void *argp2 = 0 ;
27556 56 : int res2 = 0 ;
27557 56 : PyObject * obj0 = 0 ;
27558 56 : PyObject * obj1 = 0 ;
27559 : gpgme_error_t result;
27560 :
27561 56 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_keylist_next",&obj0,&obj1)) SWIG_fail;
27562 56 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
27563 56 : if (!SWIG_IsOK(res1)) {
27564 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_next" "', argument " "1"" of type '" "gpgme_ctx_t""'");
27565 : }
27566 56 : arg1 = (gpgme_ctx_t)(argp1);
27567 56 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
27568 56 : if (!SWIG_IsOK(res2)) {
27569 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_keylist_next" "', argument " "2"" of type '" "gpgme_key_t *""'");
27570 : }
27571 56 : arg2 = (gpgme_key_t *)(argp2);
27572 56 : result = gpgme_op_keylist_next(arg1,arg2);
27573 : {
27574 56 : resultobj = PyLong_FromLong(result);
27575 : }
27576 56 : return resultobj;
27577 : fail:
27578 : return NULL;
27579 : }
27580 :
27581 :
27582 2 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_end(PyObject *self, PyObject *args) {
27583 2 : PyObject *resultobj = 0;
27584 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
27585 2 : void *argp1 = 0 ;
27586 2 : int res1 = 0 ;
27587 2 : PyObject * obj0 = 0 ;
27588 : gpgme_error_t result;
27589 :
27590 2 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_keylist_end",&obj0)) SWIG_fail;
27591 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
27592 2 : if (!SWIG_IsOK(res1)) {
27593 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_end" "', argument " "1"" of type '" "gpgme_ctx_t""'");
27594 : }
27595 2 : arg1 = (gpgme_ctx_t)(argp1);
27596 2 : result = gpgme_op_keylist_end(arg1);
27597 : {
27598 2 : resultobj = PyLong_FromLong(result);
27599 : }
27600 2 : return resultobj;
27601 : fail:
27602 : return NULL;
27603 : }
27604 :
27605 :
27606 0 : SWIGINTERN PyObject *_wrap_gpgme_op_passwd_start(PyObject *self, PyObject *args) {
27607 0 : PyObject *resultobj = 0;
27608 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
27609 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
27610 : unsigned int arg3 ;
27611 0 : void *argp1 = 0 ;
27612 0 : int res1 = 0 ;
27613 0 : void *argp2 = 0 ;
27614 0 : int res2 = 0 ;
27615 : unsigned int val3 ;
27616 0 : int ecode3 = 0 ;
27617 0 : PyObject * obj0 = 0 ;
27618 0 : PyObject * obj1 = 0 ;
27619 0 : PyObject * obj2 = 0 ;
27620 : gpgme_error_t result;
27621 :
27622 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_passwd_start",&obj0,&obj1,&obj2)) SWIG_fail;
27623 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
27624 0 : if (!SWIG_IsOK(res1)) {
27625 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_passwd_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
27626 : }
27627 0 : arg1 = (gpgme_ctx_t)(argp1);
27628 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
27629 0 : if (!SWIG_IsOK(res2)) {
27630 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_passwd_start" "', argument " "2"" of type '" "gpgme_key_t""'");
27631 : }
27632 0 : arg2 = (gpgme_key_t)(argp2);
27633 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
27634 0 : if (!SWIG_IsOK(ecode3)) {
27635 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_passwd_start" "', argument " "3"" of type '" "unsigned int""'");
27636 : }
27637 0 : arg3 = (unsigned int)(val3);
27638 0 : result = gpgme_op_passwd_start(arg1,arg2,arg3);
27639 : {
27640 0 : resultobj = PyLong_FromLong(result);
27641 : }
27642 0 : return resultobj;
27643 : fail:
27644 : return NULL;
27645 : }
27646 :
27647 :
27648 0 : SWIGINTERN PyObject *_wrap_gpgme_op_passwd(PyObject *self, PyObject *args) {
27649 0 : PyObject *resultobj = 0;
27650 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
27651 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
27652 : unsigned int arg3 ;
27653 0 : void *argp1 = 0 ;
27654 0 : int res1 = 0 ;
27655 0 : void *argp2 = 0 ;
27656 0 : int res2 = 0 ;
27657 : unsigned int val3 ;
27658 0 : int ecode3 = 0 ;
27659 0 : PyObject * obj0 = 0 ;
27660 0 : PyObject * obj1 = 0 ;
27661 0 : PyObject * obj2 = 0 ;
27662 : gpgme_error_t result;
27663 :
27664 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_passwd",&obj0,&obj1,&obj2)) SWIG_fail;
27665 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
27666 0 : if (!SWIG_IsOK(res1)) {
27667 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_passwd" "', argument " "1"" of type '" "gpgme_ctx_t""'");
27668 : }
27669 0 : arg1 = (gpgme_ctx_t)(argp1);
27670 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
27671 0 : if (!SWIG_IsOK(res2)) {
27672 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_passwd" "', argument " "2"" of type '" "gpgme_key_t""'");
27673 : }
27674 0 : arg2 = (gpgme_key_t)(argp2);
27675 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
27676 0 : if (!SWIG_IsOK(ecode3)) {
27677 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_passwd" "', argument " "3"" of type '" "unsigned int""'");
27678 : }
27679 0 : arg3 = (unsigned int)(val3);
27680 0 : result = gpgme_op_passwd(arg1,arg2,arg3);
27681 : {
27682 0 : resultobj = PyLong_FromLong(result);
27683 : }
27684 0 : return resultobj;
27685 : fail:
27686 : return NULL;
27687 : }
27688 :
27689 :
27690 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__refs_set(PyObject *self, PyObject *args) {
27691 0 : PyObject *resultobj = 0;
27692 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27693 : unsigned int arg2 ;
27694 0 : void *argp1 = 0 ;
27695 0 : int res1 = 0 ;
27696 : unsigned int val2 ;
27697 0 : int ecode2 = 0 ;
27698 0 : PyObject * obj1 = 0 ;
27699 :
27700 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__refs_set",&obj1)) SWIG_fail;
27701 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
27702 0 : if (!SWIG_IsOK(res1)) {
27703 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__refs_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
27704 : }
27705 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
27706 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
27707 0 : if (!SWIG_IsOK(ecode2)) {
27708 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_trust_item__refs_set" "', argument " "2"" of type '" "unsigned int""'");
27709 : }
27710 0 : arg2 = (unsigned int)(val2);
27711 0 : if (arg1) (arg1)->_refs = arg2;
27712 0 : resultobj = SWIG_Py_Void();
27713 0 : return resultobj;
27714 : fail:
27715 : return NULL;
27716 : }
27717 :
27718 :
27719 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__refs_get(PyObject *self, PyObject *args) {
27720 0 : PyObject *resultobj = 0;
27721 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27722 0 : void *argp1 = 0 ;
27723 0 : int res1 = 0 ;
27724 : unsigned int result;
27725 :
27726 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
27727 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
27728 0 : if (!SWIG_IsOK(res1)) {
27729 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__refs_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
27730 : }
27731 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
27732 0 : result = (unsigned int) ((arg1)->_refs);
27733 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
27734 0 : return resultobj;
27735 : fail:
27736 : return NULL;
27737 : }
27738 :
27739 :
27740 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_keyid_set(PyObject *self, PyObject *args) {
27741 0 : PyObject *resultobj = 0;
27742 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27743 0 : char *arg2 = (char *) 0 ;
27744 0 : void *argp1 = 0 ;
27745 0 : int res1 = 0 ;
27746 : int res2 ;
27747 0 : char *buf2 = 0 ;
27748 0 : int alloc2 = 0 ;
27749 0 : PyObject * obj1 = 0 ;
27750 :
27751 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_keyid_set",&obj1)) SWIG_fail;
27752 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
27753 0 : if (!SWIG_IsOK(res1)) {
27754 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_keyid_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
27755 : }
27756 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
27757 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
27758 0 : if (!SWIG_IsOK(res2)) {
27759 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_keyid_set" "', argument " "2"" of type '" "char *""'");
27760 : }
27761 0 : arg2 = (char *)(buf2);
27762 0 : if (arg1->keyid) free((char*)arg1->keyid);
27763 0 : if (arg2) {
27764 0 : size_t size = strlen((const char *)(arg2)) + 1;
27765 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
27766 : } else {
27767 0 : arg1->keyid = 0;
27768 : }
27769 0 : resultobj = SWIG_Py_Void();
27770 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27771 : return resultobj;
27772 : fail:
27773 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27774 : return NULL;
27775 : }
27776 :
27777 :
27778 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_keyid_get(PyObject *self, PyObject *args) {
27779 0 : PyObject *resultobj = 0;
27780 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27781 0 : void *argp1 = 0 ;
27782 0 : int res1 = 0 ;
27783 0 : char *result = 0 ;
27784 :
27785 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
27786 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
27787 0 : if (!SWIG_IsOK(res1)) {
27788 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_keyid_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
27789 : }
27790 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
27791 0 : result = (char *) ((arg1)->keyid);
27792 0 : resultobj = SWIG_FromCharPtr((const char *)result);
27793 0 : return resultobj;
27794 : fail:
27795 : return NULL;
27796 : }
27797 :
27798 :
27799 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__keyid_set(PyObject *self, PyObject *args) {
27800 0 : PyObject *resultobj = 0;
27801 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27802 : char *arg2 ;
27803 0 : void *argp1 = 0 ;
27804 0 : int res1 = 0 ;
27805 : char temp2[16+1] ;
27806 : int res2 ;
27807 0 : PyObject * obj1 = 0 ;
27808 :
27809 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__keyid_set",&obj1)) SWIG_fail;
27810 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
27811 0 : if (!SWIG_IsOK(res1)) {
27812 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__keyid_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
27813 : }
27814 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
27815 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
27816 0 : if (!SWIG_IsOK(res2)) {
27817 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
27818 : }
27819 0 : arg2 = (char *)(temp2);
27820 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
27821 : else memset(arg1->_keyid,0,16+1*sizeof(char));
27822 0 : resultobj = SWIG_Py_Void();
27823 0 : return resultobj;
27824 : fail:
27825 : return NULL;
27826 : }
27827 :
27828 :
27829 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__keyid_get(PyObject *self, PyObject *args) {
27830 0 : PyObject *resultobj = 0;
27831 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27832 0 : void *argp1 = 0 ;
27833 0 : int res1 = 0 ;
27834 0 : char *result = 0 ;
27835 :
27836 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
27837 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
27838 0 : if (!SWIG_IsOK(res1)) {
27839 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__keyid_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
27840 : }
27841 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
27842 0 : result = (char *)(char *) ((arg1)->_keyid);
27843 : {
27844 0 : size_t size = 16+1;
27845 :
27846 0 : while (size && (result[size - 1] == '\0')) --size;
27847 :
27848 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
27849 : }
27850 0 : return resultobj;
27851 : fail:
27852 : return NULL;
27853 : }
27854 :
27855 :
27856 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_type_set(PyObject *self, PyObject *args) {
27857 0 : PyObject *resultobj = 0;
27858 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27859 : int arg2 ;
27860 0 : void *argp1 = 0 ;
27861 0 : int res1 = 0 ;
27862 : int val2 ;
27863 0 : int ecode2 = 0 ;
27864 0 : PyObject * obj1 = 0 ;
27865 :
27866 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_type_set",&obj1)) SWIG_fail;
27867 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
27868 0 : if (!SWIG_IsOK(res1)) {
27869 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_type_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
27870 : }
27871 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
27872 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27873 0 : if (!SWIG_IsOK(ecode2)) {
27874 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_trust_item_type_set" "', argument " "2"" of type '" "int""'");
27875 : }
27876 0 : arg2 = (int)(val2);
27877 0 : if (arg1) (arg1)->type = arg2;
27878 0 : resultobj = SWIG_Py_Void();
27879 0 : return resultobj;
27880 : fail:
27881 : return NULL;
27882 : }
27883 :
27884 :
27885 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_type_get(PyObject *self, PyObject *args) {
27886 0 : PyObject *resultobj = 0;
27887 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27888 0 : void *argp1 = 0 ;
27889 0 : int res1 = 0 ;
27890 : int result;
27891 :
27892 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
27893 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
27894 0 : if (!SWIG_IsOK(res1)) {
27895 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_type_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
27896 : }
27897 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
27898 0 : result = (int) ((arg1)->type);
27899 0 : resultobj = SWIG_From_int((int)(result));
27900 0 : return resultobj;
27901 : fail:
27902 : return NULL;
27903 : }
27904 :
27905 :
27906 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_level_set(PyObject *self, PyObject *args) {
27907 0 : PyObject *resultobj = 0;
27908 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27909 : int arg2 ;
27910 0 : void *argp1 = 0 ;
27911 0 : int res1 = 0 ;
27912 : int val2 ;
27913 0 : int ecode2 = 0 ;
27914 0 : PyObject * obj1 = 0 ;
27915 :
27916 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_level_set",&obj1)) SWIG_fail;
27917 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
27918 0 : if (!SWIG_IsOK(res1)) {
27919 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_level_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
27920 : }
27921 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
27922 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27923 0 : if (!SWIG_IsOK(ecode2)) {
27924 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_trust_item_level_set" "', argument " "2"" of type '" "int""'");
27925 : }
27926 0 : arg2 = (int)(val2);
27927 0 : if (arg1) (arg1)->level = arg2;
27928 0 : resultobj = SWIG_Py_Void();
27929 0 : return resultobj;
27930 : fail:
27931 : return NULL;
27932 : }
27933 :
27934 :
27935 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_level_get(PyObject *self, PyObject *args) {
27936 0 : PyObject *resultobj = 0;
27937 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27938 0 : void *argp1 = 0 ;
27939 0 : int res1 = 0 ;
27940 : int result;
27941 :
27942 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
27943 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
27944 0 : if (!SWIG_IsOK(res1)) {
27945 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_level_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
27946 : }
27947 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
27948 0 : result = (int) ((arg1)->level);
27949 0 : resultobj = SWIG_From_int((int)(result));
27950 0 : return resultobj;
27951 : fail:
27952 : return NULL;
27953 : }
27954 :
27955 :
27956 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_owner_trust_set(PyObject *self, PyObject *args) {
27957 0 : PyObject *resultobj = 0;
27958 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27959 0 : char *arg2 = (char *) 0 ;
27960 0 : void *argp1 = 0 ;
27961 0 : int res1 = 0 ;
27962 : int res2 ;
27963 0 : char *buf2 = 0 ;
27964 0 : int alloc2 = 0 ;
27965 0 : PyObject * obj1 = 0 ;
27966 :
27967 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_owner_trust_set",&obj1)) SWIG_fail;
27968 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
27969 0 : if (!SWIG_IsOK(res1)) {
27970 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_owner_trust_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
27971 : }
27972 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
27973 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
27974 0 : if (!SWIG_IsOK(res2)) {
27975 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_owner_trust_set" "', argument " "2"" of type '" "char *""'");
27976 : }
27977 0 : arg2 = (char *)(buf2);
27978 0 : if (arg1->owner_trust) free((char*)arg1->owner_trust);
27979 0 : if (arg2) {
27980 0 : size_t size = strlen((const char *)(arg2)) + 1;
27981 0 : arg1->owner_trust = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
27982 : } else {
27983 0 : arg1->owner_trust = 0;
27984 : }
27985 0 : resultobj = SWIG_Py_Void();
27986 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27987 : return resultobj;
27988 : fail:
27989 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27990 : return NULL;
27991 : }
27992 :
27993 :
27994 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_owner_trust_get(PyObject *self, PyObject *args) {
27995 0 : PyObject *resultobj = 0;
27996 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
27997 0 : void *argp1 = 0 ;
27998 0 : int res1 = 0 ;
27999 0 : char *result = 0 ;
28000 :
28001 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
28002 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
28003 0 : if (!SWIG_IsOK(res1)) {
28004 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_owner_trust_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
28005 : }
28006 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
28007 0 : result = (char *) ((arg1)->owner_trust);
28008 0 : resultobj = SWIG_FromCharPtr((const char *)result);
28009 0 : return resultobj;
28010 : fail:
28011 : return NULL;
28012 : }
28013 :
28014 :
28015 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__owner_trust_set(PyObject *self, PyObject *args) {
28016 0 : PyObject *resultobj = 0;
28017 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
28018 : char *arg2 ;
28019 0 : void *argp1 = 0 ;
28020 0 : int res1 = 0 ;
28021 : char temp2[2] ;
28022 : int res2 ;
28023 0 : PyObject * obj1 = 0 ;
28024 :
28025 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__owner_trust_set",&obj1)) SWIG_fail;
28026 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
28027 0 : if (!SWIG_IsOK(res1)) {
28028 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__owner_trust_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
28029 : }
28030 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
28031 0 : res2 = SWIG_AsCharArray(obj1, temp2, 2);
28032 0 : if (!SWIG_IsOK(res2)) {
28033 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item__owner_trust_set" "', argument " "2"" of type '" "char [2]""'");
28034 : }
28035 0 : arg2 = (char *)(temp2);
28036 0 : if (arg2) memcpy(arg1->_owner_trust,arg2,2*sizeof(char));
28037 : else memset(arg1->_owner_trust,0,2*sizeof(char));
28038 0 : resultobj = SWIG_Py_Void();
28039 0 : return resultobj;
28040 : fail:
28041 : return NULL;
28042 : }
28043 :
28044 :
28045 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__owner_trust_get(PyObject *self, PyObject *args) {
28046 0 : PyObject *resultobj = 0;
28047 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
28048 0 : void *argp1 = 0 ;
28049 0 : int res1 = 0 ;
28050 0 : char *result = 0 ;
28051 :
28052 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
28053 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
28054 0 : if (!SWIG_IsOK(res1)) {
28055 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__owner_trust_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
28056 : }
28057 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
28058 0 : result = (char *)(char *) ((arg1)->_owner_trust);
28059 : {
28060 0 : size_t size = 2;
28061 :
28062 0 : while (size && (result[size - 1] == '\0')) --size;
28063 :
28064 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
28065 : }
28066 0 : return resultobj;
28067 : fail:
28068 : return NULL;
28069 : }
28070 :
28071 :
28072 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_validity_set(PyObject *self, PyObject *args) {
28073 0 : PyObject *resultobj = 0;
28074 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
28075 0 : char *arg2 = (char *) 0 ;
28076 0 : void *argp1 = 0 ;
28077 0 : int res1 = 0 ;
28078 : int res2 ;
28079 0 : char *buf2 = 0 ;
28080 0 : int alloc2 = 0 ;
28081 0 : PyObject * obj1 = 0 ;
28082 :
28083 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_validity_set",&obj1)) SWIG_fail;
28084 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
28085 0 : if (!SWIG_IsOK(res1)) {
28086 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_validity_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
28087 : }
28088 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
28089 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28090 0 : if (!SWIG_IsOK(res2)) {
28091 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_validity_set" "', argument " "2"" of type '" "char *""'");
28092 : }
28093 0 : arg2 = (char *)(buf2);
28094 0 : if (arg1->validity) free((char*)arg1->validity);
28095 0 : if (arg2) {
28096 0 : size_t size = strlen((const char *)(arg2)) + 1;
28097 0 : arg1->validity = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
28098 : } else {
28099 0 : arg1->validity = 0;
28100 : }
28101 0 : resultobj = SWIG_Py_Void();
28102 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
28103 : return resultobj;
28104 : fail:
28105 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
28106 : return NULL;
28107 : }
28108 :
28109 :
28110 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_validity_get(PyObject *self, PyObject *args) {
28111 0 : PyObject *resultobj = 0;
28112 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
28113 0 : void *argp1 = 0 ;
28114 0 : int res1 = 0 ;
28115 0 : char *result = 0 ;
28116 :
28117 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
28118 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
28119 0 : if (!SWIG_IsOK(res1)) {
28120 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_validity_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
28121 : }
28122 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
28123 0 : result = (char *) ((arg1)->validity);
28124 0 : resultobj = SWIG_FromCharPtr((const char *)result);
28125 0 : return resultobj;
28126 : fail:
28127 : return NULL;
28128 : }
28129 :
28130 :
28131 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__validity_set(PyObject *self, PyObject *args) {
28132 0 : PyObject *resultobj = 0;
28133 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
28134 : char *arg2 ;
28135 0 : void *argp1 = 0 ;
28136 0 : int res1 = 0 ;
28137 : char temp2[2] ;
28138 : int res2 ;
28139 0 : PyObject * obj1 = 0 ;
28140 :
28141 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__validity_set",&obj1)) SWIG_fail;
28142 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
28143 0 : if (!SWIG_IsOK(res1)) {
28144 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__validity_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
28145 : }
28146 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
28147 0 : res2 = SWIG_AsCharArray(obj1, temp2, 2);
28148 0 : if (!SWIG_IsOK(res2)) {
28149 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item__validity_set" "', argument " "2"" of type '" "char [2]""'");
28150 : }
28151 0 : arg2 = (char *)(temp2);
28152 0 : if (arg2) memcpy(arg1->_validity,arg2,2*sizeof(char));
28153 : else memset(arg1->_validity,0,2*sizeof(char));
28154 0 : resultobj = SWIG_Py_Void();
28155 0 : return resultobj;
28156 : fail:
28157 : return NULL;
28158 : }
28159 :
28160 :
28161 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__validity_get(PyObject *self, PyObject *args) {
28162 0 : PyObject *resultobj = 0;
28163 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
28164 0 : void *argp1 = 0 ;
28165 0 : int res1 = 0 ;
28166 0 : char *result = 0 ;
28167 :
28168 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
28169 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
28170 0 : if (!SWIG_IsOK(res1)) {
28171 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__validity_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
28172 : }
28173 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
28174 0 : result = (char *)(char *) ((arg1)->_validity);
28175 : {
28176 0 : size_t size = 2;
28177 :
28178 0 : while (size && (result[size - 1] == '\0')) --size;
28179 :
28180 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
28181 : }
28182 0 : return resultobj;
28183 : fail:
28184 : return NULL;
28185 : }
28186 :
28187 :
28188 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_name_set(PyObject *self, PyObject *args) {
28189 0 : PyObject *resultobj = 0;
28190 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
28191 0 : char *arg2 = (char *) 0 ;
28192 0 : void *argp1 = 0 ;
28193 0 : int res1 = 0 ;
28194 : int res2 ;
28195 0 : char *buf2 = 0 ;
28196 0 : int alloc2 = 0 ;
28197 0 : PyObject * obj1 = 0 ;
28198 :
28199 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_name_set",&obj1)) SWIG_fail;
28200 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
28201 0 : if (!SWIG_IsOK(res1)) {
28202 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_name_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
28203 : }
28204 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
28205 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28206 0 : if (!SWIG_IsOK(res2)) {
28207 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_name_set" "', argument " "2"" of type '" "char *""'");
28208 : }
28209 0 : arg2 = (char *)(buf2);
28210 0 : if (arg1->name) free((char*)arg1->name);
28211 0 : if (arg2) {
28212 0 : size_t size = strlen((const char *)(arg2)) + 1;
28213 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
28214 : } else {
28215 0 : arg1->name = 0;
28216 : }
28217 0 : resultobj = SWIG_Py_Void();
28218 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
28219 : return resultobj;
28220 : fail:
28221 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
28222 : return NULL;
28223 : }
28224 :
28225 :
28226 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_name_get(PyObject *self, PyObject *args) {
28227 0 : PyObject *resultobj = 0;
28228 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
28229 0 : void *argp1 = 0 ;
28230 0 : int res1 = 0 ;
28231 0 : char *result = 0 ;
28232 :
28233 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
28234 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
28235 0 : if (!SWIG_IsOK(res1)) {
28236 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_name_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
28237 : }
28238 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
28239 0 : result = (char *) ((arg1)->name);
28240 0 : resultobj = SWIG_FromCharPtr((const char *)result);
28241 0 : return resultobj;
28242 : fail:
28243 : return NULL;
28244 : }
28245 :
28246 :
28247 0 : SWIGINTERN int _wrap_new__gpgme_trust_item(PyObject *self, PyObject *args) {
28248 0 : PyObject *resultobj = 0;
28249 0 : struct _gpgme_trust_item *result = 0 ;
28250 :
28251 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
28252 0 : result = (struct _gpgme_trust_item *)calloc(1, sizeof(struct _gpgme_trust_item));
28253 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_trust_item, SWIG_BUILTIN_INIT | 0 );
28254 0 : return resultobj == Py_None ? -1 : 0;
28255 : fail:
28256 : return -1;
28257 : }
28258 :
28259 :
28260 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_trust_item(PyObject *self, PyObject *args) {
28261 0 : PyObject *resultobj = 0;
28262 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
28263 0 : void *argp1 = 0 ;
28264 0 : int res1 = 0 ;
28265 :
28266 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
28267 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_trust_item, SWIG_POINTER_DISOWN | 0 );
28268 0 : if (!SWIG_IsOK(res1)) {
28269 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_trust_item" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
28270 : }
28271 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
28272 0 : free((char *) arg1);
28273 0 : resultobj = SWIG_Py_Void();
28274 0 : return resultobj;
28275 : fail:
28276 : return NULL;
28277 : }
28278 :
28279 :
28280 2 : SWIGINTERN PyObject *_wrap_gpgme_op_trustlist_start(PyObject *self, PyObject *args) {
28281 2 : PyObject *resultobj = 0;
28282 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
28283 2 : char *arg2 = (char *) 0 ;
28284 : int arg3 ;
28285 2 : void *argp1 = 0 ;
28286 2 : int res1 = 0 ;
28287 : int val3 ;
28288 2 : int ecode3 = 0 ;
28289 2 : PyObject * obj0 = 0 ;
28290 2 : PyObject * obj1 = 0 ;
28291 2 : PyObject * obj2 = 0 ;
28292 : gpgme_error_t result;
28293 :
28294 2 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_trustlist_start",&obj0,&obj1,&obj2)) SWIG_fail;
28295 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
28296 2 : if (!SWIG_IsOK(res1)) {
28297 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_trustlist_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
28298 : }
28299 2 : arg1 = (gpgme_ctx_t)(argp1);
28300 : {
28301 2 : if (obj1 == Py_None)
28302 : arg2 = NULL;
28303 2 : else if (PyUnicode_Check(obj1))
28304 2 : arg2 = PyUnicode_AsUTF8(obj1);
28305 0 : else if (PyBytes_Check(obj1))
28306 0 : arg2 = PyBytes_AsString(obj1);
28307 : else {
28308 0 : PyErr_Format(PyExc_TypeError,
28309 : "arg %d: expected str, bytes, or None, got %s",
28310 : 2, obj1->ob_type->tp_name);
28311 0 : return NULL;
28312 : }
28313 : }
28314 2 : ecode3 = SWIG_AsVal_int(obj2, &val3);
28315 2 : if (!SWIG_IsOK(ecode3)) {
28316 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_trustlist_start" "', argument " "3"" of type '" "int""'");
28317 : }
28318 2 : arg3 = (int)(val3);
28319 2 : result = gpgme_op_trustlist_start(arg1,(char const *)arg2,arg3);
28320 : {
28321 2 : resultobj = PyLong_FromLong(result);
28322 : }
28323 2 : return resultobj;
28324 : fail:
28325 : return NULL;
28326 : }
28327 :
28328 :
28329 2 : SWIGINTERN PyObject *_wrap_gpgme_op_trustlist_next(PyObject *self, PyObject *args) {
28330 2 : PyObject *resultobj = 0;
28331 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
28332 2 : gpgme_trust_item_t *arg2 = (gpgme_trust_item_t *) 0 ;
28333 2 : void *argp1 = 0 ;
28334 2 : int res1 = 0 ;
28335 2 : void *argp2 = 0 ;
28336 2 : int res2 = 0 ;
28337 2 : PyObject * obj0 = 0 ;
28338 2 : PyObject * obj1 = 0 ;
28339 : gpgme_error_t result;
28340 :
28341 2 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_trustlist_next",&obj0,&obj1)) SWIG_fail;
28342 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
28343 2 : if (!SWIG_IsOK(res1)) {
28344 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_trustlist_next" "', argument " "1"" of type '" "gpgme_ctx_t""'");
28345 : }
28346 2 : arg1 = (gpgme_ctx_t)(argp1);
28347 2 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
28348 2 : if (!SWIG_IsOK(res2)) {
28349 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_trustlist_next" "', argument " "2"" of type '" "gpgme_trust_item_t *""'");
28350 : }
28351 2 : arg2 = (gpgme_trust_item_t *)(argp2);
28352 2 : result = gpgme_op_trustlist_next(arg1,arg2);
28353 : {
28354 2 : resultobj = PyLong_FromLong(result);
28355 : }
28356 2 : return resultobj;
28357 : fail:
28358 : return NULL;
28359 : }
28360 :
28361 :
28362 2 : SWIGINTERN PyObject *_wrap_gpgme_op_trustlist_end(PyObject *self, PyObject *args) {
28363 2 : PyObject *resultobj = 0;
28364 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
28365 2 : void *argp1 = 0 ;
28366 2 : int res1 = 0 ;
28367 2 : PyObject * obj0 = 0 ;
28368 : gpgme_error_t result;
28369 :
28370 2 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_trustlist_end",&obj0)) SWIG_fail;
28371 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
28372 2 : if (!SWIG_IsOK(res1)) {
28373 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_trustlist_end" "', argument " "1"" of type '" "gpgme_ctx_t""'");
28374 : }
28375 2 : arg1 = (gpgme_ctx_t)(argp1);
28376 2 : result = gpgme_op_trustlist_end(arg1);
28377 : {
28378 2 : resultobj = PyLong_FromLong(result);
28379 : }
28380 2 : return resultobj;
28381 : fail:
28382 : return NULL;
28383 : }
28384 :
28385 :
28386 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_ref(PyObject *self, PyObject *args) {
28387 0 : PyObject *resultobj = 0;
28388 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
28389 0 : void *argp1 = 0 ;
28390 0 : int res1 = 0 ;
28391 0 : PyObject * obj0 = 0 ;
28392 :
28393 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_trust_item_ref",&obj0)) SWIG_fail;
28394 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
28395 0 : if (!SWIG_IsOK(res1)) {
28396 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_ref" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
28397 : }
28398 0 : arg1 = (gpgme_trust_item_t)(argp1);
28399 0 : gpgme_trust_item_ref(arg1);
28400 0 : resultobj = SWIG_Py_Void();
28401 0 : return resultobj;
28402 : fail:
28403 : return NULL;
28404 : }
28405 :
28406 :
28407 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_unref(PyObject *self, PyObject *args) {
28408 0 : PyObject *resultobj = 0;
28409 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
28410 0 : void *argp1 = 0 ;
28411 0 : int res1 = 0 ;
28412 0 : PyObject * obj0 = 0 ;
28413 :
28414 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_trust_item_unref",&obj0)) SWIG_fail;
28415 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
28416 0 : if (!SWIG_IsOK(res1)) {
28417 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_unref" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
28418 : }
28419 0 : arg1 = (gpgme_trust_item_t)(argp1);
28420 0 : gpgme_trust_item_unref(arg1);
28421 0 : resultobj = SWIG_Py_Void();
28422 0 : return resultobj;
28423 : fail:
28424 : return NULL;
28425 : }
28426 :
28427 :
28428 0 : SWIGINTERN PyObject *_wrap_gpgme_op_getauditlog_start(PyObject *self, PyObject *args) {
28429 0 : PyObject *resultobj = 0;
28430 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
28431 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
28432 : unsigned int arg3 ;
28433 0 : void *argp1 = 0 ;
28434 0 : int res1 = 0 ;
28435 0 : void *argp2 = 0 ;
28436 0 : int res2 = 0 ;
28437 : unsigned int val3 ;
28438 0 : int ecode3 = 0 ;
28439 0 : PyObject * obj0 = 0 ;
28440 0 : PyObject * obj1 = 0 ;
28441 0 : PyObject * obj2 = 0 ;
28442 : gpgme_error_t result;
28443 :
28444 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_getauditlog_start",&obj0,&obj1,&obj2)) SWIG_fail;
28445 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
28446 0 : if (!SWIG_IsOK(res1)) {
28447 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_getauditlog_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
28448 : }
28449 0 : arg1 = (gpgme_ctx_t)(argp1);
28450 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data, 0 | 0 );
28451 0 : if (!SWIG_IsOK(res2)) {
28452 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_getauditlog_start" "', argument " "2"" of type '" "gpgme_data_t""'");
28453 : }
28454 0 : arg2 = (gpgme_data_t)(argp2);
28455 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
28456 0 : if (!SWIG_IsOK(ecode3)) {
28457 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_getauditlog_start" "', argument " "3"" of type '" "unsigned int""'");
28458 : }
28459 0 : arg3 = (unsigned int)(val3);
28460 0 : result = gpgme_op_getauditlog_start(arg1,arg2,arg3);
28461 : {
28462 0 : resultobj = PyLong_FromLong(result);
28463 : }
28464 0 : return resultobj;
28465 : fail:
28466 : return NULL;
28467 : }
28468 :
28469 :
28470 0 : SWIGINTERN PyObject *_wrap_gpgme_op_getauditlog(PyObject *self, PyObject *args) {
28471 0 : PyObject *resultobj = 0;
28472 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
28473 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
28474 : unsigned int arg3 ;
28475 0 : void *argp1 = 0 ;
28476 0 : int res1 = 0 ;
28477 0 : void *argp2 = 0 ;
28478 0 : int res2 = 0 ;
28479 : unsigned int val3 ;
28480 0 : int ecode3 = 0 ;
28481 0 : PyObject * obj0 = 0 ;
28482 0 : PyObject * obj1 = 0 ;
28483 0 : PyObject * obj2 = 0 ;
28484 : gpgme_error_t result;
28485 :
28486 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_getauditlog",&obj0,&obj1,&obj2)) SWIG_fail;
28487 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
28488 0 : if (!SWIG_IsOK(res1)) {
28489 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_getauditlog" "', argument " "1"" of type '" "gpgme_ctx_t""'");
28490 : }
28491 0 : arg1 = (gpgme_ctx_t)(argp1);
28492 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data, 0 | 0 );
28493 0 : if (!SWIG_IsOK(res2)) {
28494 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_getauditlog" "', argument " "2"" of type '" "gpgme_data_t""'");
28495 : }
28496 0 : arg2 = (gpgme_data_t)(argp2);
28497 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
28498 0 : if (!SWIG_IsOK(ecode3)) {
28499 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_getauditlog" "', argument " "3"" of type '" "unsigned int""'");
28500 : }
28501 0 : arg3 = (unsigned int)(val3);
28502 0 : result = gpgme_op_getauditlog(arg1,arg2,arg3);
28503 : {
28504 0 : resultobj = PyLong_FromLong(result);
28505 : }
28506 0 : return resultobj;
28507 : fail:
28508 : return NULL;
28509 : }
28510 :
28511 :
28512 0 : SWIGINTERN PyObject *_wrap_gpgme_op_spawn_start(PyObject *self, PyObject *args) {
28513 0 : PyObject *resultobj = 0;
28514 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
28515 0 : char *arg2 = (char *) 0 ;
28516 : char **arg3 ;
28517 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
28518 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
28519 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
28520 : unsigned int arg7 ;
28521 0 : void *argp1 = 0 ;
28522 0 : int res1 = 0 ;
28523 0 : void *vector3 = NULL ;
28524 0 : void *argp4 = 0 ;
28525 0 : int res4 = 0 ;
28526 0 : void *argp5 = 0 ;
28527 0 : int res5 = 0 ;
28528 0 : void *argp6 = 0 ;
28529 0 : int res6 = 0 ;
28530 : unsigned int val7 ;
28531 0 : int ecode7 = 0 ;
28532 0 : PyObject * obj0 = 0 ;
28533 0 : PyObject * obj1 = 0 ;
28534 0 : PyObject * obj2 = 0 ;
28535 0 : PyObject * obj3 = 0 ;
28536 0 : PyObject * obj4 = 0 ;
28537 0 : PyObject * obj5 = 0 ;
28538 0 : PyObject * obj6 = 0 ;
28539 : gpgme_error_t result;
28540 :
28541 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:gpgme_op_spawn_start",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
28542 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
28543 0 : if (!SWIG_IsOK(res1)) {
28544 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_spawn_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
28545 : }
28546 0 : arg1 = (gpgme_ctx_t)(argp1);
28547 : {
28548 0 : if (obj1 == Py_None)
28549 : arg2 = NULL;
28550 0 : else if (PyUnicode_Check(obj1))
28551 0 : arg2 = PyUnicode_AsUTF8(obj1);
28552 0 : else if (PyBytes_Check(obj1))
28553 0 : arg2 = PyBytes_AsString(obj1);
28554 : else {
28555 0 : PyErr_Format(PyExc_TypeError,
28556 : "arg %d: expected str, bytes, or None, got %s",
28557 : 2, obj1->ob_type->tp_name);
28558 0 : return NULL;
28559 : }
28560 : }
28561 : {
28562 : /* Check if is a list */
28563 0 : if (PyList_Check(obj2)) {
28564 0 : size_t i, size = PyList_Size(obj2);
28565 0 : arg3 = (char **) (vector3 = malloc((size+1) * sizeof(char *)));
28566 :
28567 0 : for (i = 0; i < size; i++) {
28568 0 : PyObject *o = PyList_GetItem(obj2,i);
28569 0 : if (PyUnicode_Check(o))
28570 0 : arg3[i] = PyUnicode_AsUTF8(o);
28571 0 : else if (PyString_Check(o))
28572 0 : arg3[i] = PyString_AsString(o);
28573 : else {
28574 0 : PyErr_Format(PyExc_TypeError,
28575 : "arg %d: list must contain only str or bytes, got %s "
28576 : "at position %d",
28577 0 : 3, o->ob_type->tp_name, i);
28578 0 : free(arg3);
28579 0 : return NULL;
28580 : }
28581 : }
28582 0 : arg3[i] = NULL;
28583 : } else {
28584 0 : PyErr_Format(PyExc_TypeError,
28585 : "arg %d: expected a list of str or bytes, got %s",
28586 : 3, obj2->ob_type->tp_name);
28587 0 : return NULL;
28588 : }
28589 : }
28590 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_gpgme_data, 0 | 0 );
28591 0 : if (!SWIG_IsOK(res4)) {
28592 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_op_spawn_start" "', argument " "4"" of type '" "gpgme_data_t""'");
28593 : }
28594 0 : arg4 = (gpgme_data_t)(argp4);
28595 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpgme_data, 0 | 0 );
28596 0 : if (!SWIG_IsOK(res5)) {
28597 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_spawn_start" "', argument " "5"" of type '" "gpgme_data_t""'");
28598 : }
28599 0 : arg5 = (gpgme_data_t)(argp5);
28600 0 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_gpgme_data, 0 | 0 );
28601 0 : if (!SWIG_IsOK(res6)) {
28602 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gpgme_op_spawn_start" "', argument " "6"" of type '" "gpgme_data_t""'");
28603 : }
28604 0 : arg6 = (gpgme_data_t)(argp6);
28605 0 : ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
28606 0 : if (!SWIG_IsOK(ecode7)) {
28607 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gpgme_op_spawn_start" "', argument " "7"" of type '" "unsigned int""'");
28608 : }
28609 0 : arg7 = (unsigned int)(val7);
28610 0 : result = gpgme_op_spawn_start(arg1,(char const *)arg2,(char const *(*))arg3,arg4,arg5,arg6,arg7);
28611 : {
28612 0 : resultobj = PyLong_FromLong(result);
28613 : }
28614 : {
28615 0 : free(vector3);
28616 : }
28617 0 : return resultobj;
28618 : fail:
28619 : {
28620 0 : free(vector3);
28621 : }
28622 0 : return NULL;
28623 : }
28624 :
28625 :
28626 0 : SWIGINTERN PyObject *_wrap_gpgme_op_spawn(PyObject *self, PyObject *args) {
28627 0 : PyObject *resultobj = 0;
28628 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
28629 0 : char *arg2 = (char *) 0 ;
28630 : char **arg3 ;
28631 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
28632 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
28633 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
28634 : unsigned int arg7 ;
28635 0 : void *argp1 = 0 ;
28636 0 : int res1 = 0 ;
28637 0 : void *vector3 = NULL ;
28638 0 : void *argp4 = 0 ;
28639 0 : int res4 = 0 ;
28640 0 : void *argp5 = 0 ;
28641 0 : int res5 = 0 ;
28642 0 : void *argp6 = 0 ;
28643 0 : int res6 = 0 ;
28644 : unsigned int val7 ;
28645 0 : int ecode7 = 0 ;
28646 0 : PyObject * obj0 = 0 ;
28647 0 : PyObject * obj1 = 0 ;
28648 0 : PyObject * obj2 = 0 ;
28649 0 : PyObject * obj3 = 0 ;
28650 0 : PyObject * obj4 = 0 ;
28651 0 : PyObject * obj5 = 0 ;
28652 0 : PyObject * obj6 = 0 ;
28653 : gpgme_error_t result;
28654 :
28655 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:gpgme_op_spawn",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
28656 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
28657 0 : if (!SWIG_IsOK(res1)) {
28658 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_spawn" "', argument " "1"" of type '" "gpgme_ctx_t""'");
28659 : }
28660 0 : arg1 = (gpgme_ctx_t)(argp1);
28661 : {
28662 0 : if (obj1 == Py_None)
28663 : arg2 = NULL;
28664 0 : else if (PyUnicode_Check(obj1))
28665 0 : arg2 = PyUnicode_AsUTF8(obj1);
28666 0 : else if (PyBytes_Check(obj1))
28667 0 : arg2 = PyBytes_AsString(obj1);
28668 : else {
28669 0 : PyErr_Format(PyExc_TypeError,
28670 : "arg %d: expected str, bytes, or None, got %s",
28671 : 2, obj1->ob_type->tp_name);
28672 0 : return NULL;
28673 : }
28674 : }
28675 : {
28676 : /* Check if is a list */
28677 0 : if (PyList_Check(obj2)) {
28678 0 : size_t i, size = PyList_Size(obj2);
28679 0 : arg3 = (char **) (vector3 = malloc((size+1) * sizeof(char *)));
28680 :
28681 0 : for (i = 0; i < size; i++) {
28682 0 : PyObject *o = PyList_GetItem(obj2,i);
28683 0 : if (PyUnicode_Check(o))
28684 0 : arg3[i] = PyUnicode_AsUTF8(o);
28685 0 : else if (PyString_Check(o))
28686 0 : arg3[i] = PyString_AsString(o);
28687 : else {
28688 0 : PyErr_Format(PyExc_TypeError,
28689 : "arg %d: list must contain only str or bytes, got %s "
28690 : "at position %d",
28691 0 : 3, o->ob_type->tp_name, i);
28692 0 : free(arg3);
28693 0 : return NULL;
28694 : }
28695 : }
28696 0 : arg3[i] = NULL;
28697 : } else {
28698 0 : PyErr_Format(PyExc_TypeError,
28699 : "arg %d: expected a list of str or bytes, got %s",
28700 : 3, obj2->ob_type->tp_name);
28701 0 : return NULL;
28702 : }
28703 : }
28704 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_gpgme_data, 0 | 0 );
28705 0 : if (!SWIG_IsOK(res4)) {
28706 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_op_spawn" "', argument " "4"" of type '" "gpgme_data_t""'");
28707 : }
28708 0 : arg4 = (gpgme_data_t)(argp4);
28709 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpgme_data, 0 | 0 );
28710 0 : if (!SWIG_IsOK(res5)) {
28711 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_spawn" "', argument " "5"" of type '" "gpgme_data_t""'");
28712 : }
28713 0 : arg5 = (gpgme_data_t)(argp5);
28714 0 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_gpgme_data, 0 | 0 );
28715 0 : if (!SWIG_IsOK(res6)) {
28716 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gpgme_op_spawn" "', argument " "6"" of type '" "gpgme_data_t""'");
28717 : }
28718 0 : arg6 = (gpgme_data_t)(argp6);
28719 0 : ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
28720 0 : if (!SWIG_IsOK(ecode7)) {
28721 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gpgme_op_spawn" "', argument " "7"" of type '" "unsigned int""'");
28722 : }
28723 0 : arg7 = (unsigned int)(val7);
28724 0 : result = gpgme_op_spawn(arg1,(char const *)arg2,(char const *(*))arg3,arg4,arg5,arg6,arg7);
28725 : {
28726 0 : resultobj = PyLong_FromLong(result);
28727 : }
28728 : {
28729 0 : free(vector3);
28730 : }
28731 0 : return resultobj;
28732 : fail:
28733 : {
28734 0 : free(vector3);
28735 : }
28736 0 : return NULL;
28737 : }
28738 :
28739 :
28740 0 : SWIGINTERN PyObject *_wrap_gpgme_op_assuan_transact_start(PyObject *self, PyObject *args) {
28741 0 : PyObject *resultobj = 0;
28742 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
28743 0 : char *arg2 = (char *) 0 ;
28744 0 : gpgme_assuan_data_cb_t arg3 = (gpgme_assuan_data_cb_t) 0 ;
28745 0 : void *arg4 = (void *) 0 ;
28746 0 : gpgme_assuan_inquire_cb_t arg5 = (gpgme_assuan_inquire_cb_t) 0 ;
28747 0 : void *arg6 = (void *) 0 ;
28748 0 : gpgme_assuan_status_cb_t arg7 = (gpgme_assuan_status_cb_t) 0 ;
28749 0 : void *arg8 = (void *) 0 ;
28750 0 : void *argp1 = 0 ;
28751 0 : int res1 = 0 ;
28752 0 : PyObject * obj0 = 0 ;
28753 0 : PyObject * obj1 = 0 ;
28754 0 : PyObject * obj2 = 0 ;
28755 0 : PyObject * obj3 = 0 ;
28756 0 : PyObject * obj4 = 0 ;
28757 : gpgme_error_t result;
28758 :
28759 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_assuan_transact_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
28760 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
28761 0 : if (!SWIG_IsOK(res1)) {
28762 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_assuan_transact_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
28763 : }
28764 0 : arg1 = (gpgme_ctx_t)(argp1);
28765 : {
28766 0 : if (obj1 == Py_None)
28767 : arg2 = NULL;
28768 0 : else if (PyUnicode_Check(obj1))
28769 0 : arg2 = PyUnicode_AsUTF8(obj1);
28770 0 : else if (PyBytes_Check(obj1))
28771 0 : arg2 = PyBytes_AsString(obj1);
28772 : else {
28773 0 : PyErr_Format(PyExc_TypeError,
28774 : "arg %d: expected str, bytes, or None, got %s",
28775 : 2, obj1->ob_type->tp_name);
28776 0 : return NULL;
28777 : }
28778 : }
28779 : {
28780 0 : if (obj2 == Py_None)
28781 : arg3 = arg4 = NULL;
28782 : else
28783 : {
28784 0 : if (! PyTuple_Check(obj2))
28785 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
28786 0 : if (PyTuple_Size(obj2) != 2)
28787 0 : return PyErr_Format(PyExc_TypeError,
28788 : "callback must be a tuple of size 2");
28789 0 : if (! PyCallable_Check(PyTuple_GetItem(obj2, 1)))
28790 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
28791 0 : arg3 = _pyme_assuan_data_cb;
28792 0 : arg4 = obj2;
28793 : }
28794 : }
28795 : {
28796 0 : if (obj3 == Py_None)
28797 : arg5 = arg6 = NULL;
28798 : else
28799 : {
28800 0 : if (! PyTuple_Check(obj3))
28801 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
28802 0 : if (PyTuple_Size(obj3) != 2)
28803 0 : return PyErr_Format(PyExc_TypeError,
28804 : "callback must be a tuple of size 2");
28805 0 : if (! PyCallable_Check(PyTuple_GetItem(obj3, 1)))
28806 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
28807 0 : arg5 = _pyme_assuan_inquire_cb;
28808 0 : arg6 = obj3;
28809 : }
28810 : }
28811 : {
28812 0 : if (obj4 == Py_None)
28813 : arg7 = arg8 = NULL;
28814 : else
28815 : {
28816 0 : if (! PyTuple_Check(obj4))
28817 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
28818 0 : if (PyTuple_Size(obj4) != 2)
28819 0 : return PyErr_Format(PyExc_TypeError,
28820 : "callback must be a tuple of size 2");
28821 0 : if (! PyCallable_Check(PyTuple_GetItem(obj4, 1)))
28822 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
28823 0 : arg7 = _pyme_assuan_status_cb;
28824 0 : arg8 = obj4;
28825 : }
28826 : }
28827 0 : result = gpgme_op_assuan_transact_start(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
28828 : {
28829 0 : resultobj = PyLong_FromLong(result);
28830 : }
28831 0 : return resultobj;
28832 : fail:
28833 : return NULL;
28834 : }
28835 :
28836 :
28837 8 : SWIGINTERN PyObject *_wrap_gpgme_op_assuan_transact_ext(PyObject *self, PyObject *args) {
28838 8 : PyObject *resultobj = 0;
28839 8 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
28840 8 : char *arg2 = (char *) 0 ;
28841 8 : gpgme_assuan_data_cb_t arg3 = (gpgme_assuan_data_cb_t) 0 ;
28842 8 : void *arg4 = (void *) 0 ;
28843 8 : gpgme_assuan_inquire_cb_t arg5 = (gpgme_assuan_inquire_cb_t) 0 ;
28844 8 : void *arg6 = (void *) 0 ;
28845 8 : gpgme_assuan_status_cb_t arg7 = (gpgme_assuan_status_cb_t) 0 ;
28846 8 : void *arg8 = (void *) 0 ;
28847 8 : gpgme_error_t *arg9 = (gpgme_error_t *) 0 ;
28848 8 : void *argp1 = 0 ;
28849 8 : int res1 = 0 ;
28850 8 : void *argp9 = 0 ;
28851 8 : int res9 = 0 ;
28852 8 : PyObject * obj0 = 0 ;
28853 8 : PyObject * obj1 = 0 ;
28854 8 : PyObject * obj2 = 0 ;
28855 8 : PyObject * obj3 = 0 ;
28856 8 : PyObject * obj4 = 0 ;
28857 8 : PyObject * obj5 = 0 ;
28858 : gpgme_error_t result;
28859 :
28860 8 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_assuan_transact_ext",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
28861 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
28862 8 : if (!SWIG_IsOK(res1)) {
28863 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_assuan_transact_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
28864 : }
28865 8 : arg1 = (gpgme_ctx_t)(argp1);
28866 : {
28867 8 : if (obj1 == Py_None)
28868 : arg2 = NULL;
28869 8 : else if (PyUnicode_Check(obj1))
28870 8 : arg2 = PyUnicode_AsUTF8(obj1);
28871 0 : else if (PyBytes_Check(obj1))
28872 0 : arg2 = PyBytes_AsString(obj1);
28873 : else {
28874 0 : PyErr_Format(PyExc_TypeError,
28875 : "arg %d: expected str, bytes, or None, got %s",
28876 : 2, obj1->ob_type->tp_name);
28877 0 : return NULL;
28878 : }
28879 : }
28880 : {
28881 8 : if (obj2 == Py_None)
28882 : arg3 = arg4 = NULL;
28883 : else
28884 : {
28885 2 : if (! PyTuple_Check(obj2))
28886 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
28887 2 : if (PyTuple_Size(obj2) != 2)
28888 0 : return PyErr_Format(PyExc_TypeError,
28889 : "callback must be a tuple of size 2");
28890 2 : if (! PyCallable_Check(PyTuple_GetItem(obj2, 1)))
28891 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
28892 2 : arg3 = _pyme_assuan_data_cb;
28893 2 : arg4 = obj2;
28894 : }
28895 : }
28896 : {
28897 8 : if (obj3 == Py_None)
28898 : arg5 = arg6 = NULL;
28899 : else
28900 : {
28901 0 : if (! PyTuple_Check(obj3))
28902 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
28903 0 : if (PyTuple_Size(obj3) != 2)
28904 0 : return PyErr_Format(PyExc_TypeError,
28905 : "callback must be a tuple of size 2");
28906 0 : if (! PyCallable_Check(PyTuple_GetItem(obj3, 1)))
28907 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
28908 0 : arg5 = _pyme_assuan_inquire_cb;
28909 0 : arg6 = obj3;
28910 : }
28911 : }
28912 : {
28913 8 : if (obj4 == Py_None)
28914 : arg7 = arg8 = NULL;
28915 : else
28916 : {
28917 1 : if (! PyTuple_Check(obj4))
28918 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
28919 1 : if (PyTuple_Size(obj4) != 2)
28920 0 : return PyErr_Format(PyExc_TypeError,
28921 : "callback must be a tuple of size 2");
28922 1 : if (! PyCallable_Check(PyTuple_GetItem(obj4, 1)))
28923 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
28924 1 : arg7 = _pyme_assuan_status_cb;
28925 1 : arg8 = obj4;
28926 : }
28927 : }
28928 8 : res9 = SWIG_ConvertPtr(obj5, &argp9,SWIGTYPE_p_gpg_error_t, 0 | 0 );
28929 8 : if (!SWIG_IsOK(res9)) {
28930 0 : SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "gpgme_op_assuan_transact_ext" "', argument " "9"" of type '" "gpgme_error_t *""'");
28931 : }
28932 8 : arg9 = (gpgme_error_t *)(argp9);
28933 8 : result = gpgme_op_assuan_transact_ext(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
28934 : {
28935 8 : resultobj = PyLong_FromLong(result);
28936 : }
28937 8 : return resultobj;
28938 : fail:
28939 : return NULL;
28940 : }
28941 :
28942 :
28943 0 : SWIGINTERN int _wrap_new__gpgme_op_assuan_result(PyObject *self, PyObject *args) {
28944 0 : PyObject *resultobj = 0;
28945 0 : struct _gpgme_op_assuan_result *result = 0 ;
28946 :
28947 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
28948 0 : result = (struct _gpgme_op_assuan_result *)calloc(1, sizeof(struct _gpgme_op_assuan_result));
28949 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_assuan_result, SWIG_BUILTIN_INIT | 0 );
28950 0 : return resultobj == Py_None ? -1 : 0;
28951 : fail:
28952 : return -1;
28953 : }
28954 :
28955 :
28956 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_assuan_result(PyObject *self, PyObject *args) {
28957 0 : PyObject *resultobj = 0;
28958 0 : struct _gpgme_op_assuan_result *arg1 = (struct _gpgme_op_assuan_result *) 0 ;
28959 0 : void *argp1 = 0 ;
28960 0 : int res1 = 0 ;
28961 :
28962 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
28963 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_assuan_result, SWIG_POINTER_DISOWN | 0 );
28964 0 : if (!SWIG_IsOK(res1)) {
28965 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_assuan_result" "', argument " "1"" of type '" "struct _gpgme_op_assuan_result *""'");
28966 : }
28967 0 : arg1 = (struct _gpgme_op_assuan_result *)(argp1);
28968 0 : free((char *) arg1);
28969 0 : resultobj = SWIG_Py_Void();
28970 0 : return resultobj;
28971 : fail:
28972 : return NULL;
28973 : }
28974 :
28975 :
28976 0 : SWIGINTERN PyObject *_wrap__gpgme_op_vfs_mount_result_mount_dir_set(PyObject *self, PyObject *args) {
28977 0 : PyObject *resultobj = 0;
28978 0 : struct _gpgme_op_vfs_mount_result *arg1 = (struct _gpgme_op_vfs_mount_result *) 0 ;
28979 0 : char *arg2 = (char *) 0 ;
28980 0 : void *argp1 = 0 ;
28981 0 : int res1 = 0 ;
28982 : int res2 ;
28983 0 : char *buf2 = 0 ;
28984 0 : int alloc2 = 0 ;
28985 0 : PyObject * obj1 = 0 ;
28986 :
28987 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_vfs_mount_result_mount_dir_set",&obj1)) SWIG_fail;
28988 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_vfs_mount_result, 0 | 0 );
28989 0 : if (!SWIG_IsOK(res1)) {
28990 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_vfs_mount_result_mount_dir_set" "', argument " "1"" of type '" "struct _gpgme_op_vfs_mount_result *""'");
28991 : }
28992 0 : arg1 = (struct _gpgme_op_vfs_mount_result *)(argp1);
28993 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28994 0 : if (!SWIG_IsOK(res2)) {
28995 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_vfs_mount_result_mount_dir_set" "', argument " "2"" of type '" "char *""'");
28996 : }
28997 0 : arg2 = (char *)(buf2);
28998 0 : if (arg1->mount_dir) free((char*)arg1->mount_dir);
28999 0 : if (arg2) {
29000 0 : size_t size = strlen((const char *)(arg2)) + 1;
29001 0 : arg1->mount_dir = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
29002 : } else {
29003 0 : arg1->mount_dir = 0;
29004 : }
29005 0 : resultobj = SWIG_Py_Void();
29006 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29007 : return resultobj;
29008 : fail:
29009 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29010 : return NULL;
29011 : }
29012 :
29013 :
29014 0 : SWIGINTERN PyObject *_wrap__gpgme_op_vfs_mount_result_mount_dir_get(PyObject *self, PyObject *args) {
29015 0 : PyObject *resultobj = 0;
29016 0 : struct _gpgme_op_vfs_mount_result *arg1 = (struct _gpgme_op_vfs_mount_result *) 0 ;
29017 0 : void *argp1 = 0 ;
29018 0 : int res1 = 0 ;
29019 0 : char *result = 0 ;
29020 :
29021 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29022 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_vfs_mount_result, 0 | 0 );
29023 0 : if (!SWIG_IsOK(res1)) {
29024 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_vfs_mount_result_mount_dir_get" "', argument " "1"" of type '" "struct _gpgme_op_vfs_mount_result *""'");
29025 : }
29026 0 : arg1 = (struct _gpgme_op_vfs_mount_result *)(argp1);
29027 0 : result = (char *) ((arg1)->mount_dir);
29028 0 : resultobj = SWIG_FromCharPtr((const char *)result);
29029 0 : return resultobj;
29030 : fail:
29031 : return NULL;
29032 : }
29033 :
29034 :
29035 0 : SWIGINTERN int _wrap_new__gpgme_op_vfs_mount_result(PyObject *self, PyObject *args) {
29036 0 : PyObject *resultobj = 0;
29037 0 : struct _gpgme_op_vfs_mount_result *result = 0 ;
29038 :
29039 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29040 0 : result = (struct _gpgme_op_vfs_mount_result *)calloc(1, sizeof(struct _gpgme_op_vfs_mount_result));
29041 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_vfs_mount_result, SWIG_BUILTIN_INIT | 0 );
29042 0 : return resultobj == Py_None ? -1 : 0;
29043 : fail:
29044 : return -1;
29045 : }
29046 :
29047 :
29048 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_vfs_mount_result(PyObject *self, PyObject *args) {
29049 0 : PyObject *resultobj = 0;
29050 0 : struct _gpgme_op_vfs_mount_result *arg1 = (struct _gpgme_op_vfs_mount_result *) 0 ;
29051 0 : void *argp1 = 0 ;
29052 0 : int res1 = 0 ;
29053 :
29054 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29055 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__gpgme_op_vfs_mount_result, SWIG_POINTER_DISOWN | 0 );
29056 0 : if (!SWIG_IsOK(res1)) {
29057 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_vfs_mount_result" "', argument " "1"" of type '" "struct _gpgme_op_vfs_mount_result *""'");
29058 : }
29059 0 : arg1 = (struct _gpgme_op_vfs_mount_result *)(argp1);
29060 0 : free((char *) arg1);
29061 0 : resultobj = SWIG_Py_Void();
29062 0 : return resultobj;
29063 : fail:
29064 : return NULL;
29065 : }
29066 :
29067 :
29068 0 : SWIGINTERN PyObject *_wrap_gpgme_op_vfs_mount_result(PyObject *self, PyObject *args) {
29069 0 : PyObject *resultobj = 0;
29070 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29071 0 : void *argp1 = 0 ;
29072 0 : int res1 = 0 ;
29073 0 : PyObject * obj0 = 0 ;
29074 : gpgme_vfs_mount_result_t result;
29075 :
29076 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_vfs_mount_result",&obj0)) SWIG_fail;
29077 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29078 0 : if (!SWIG_IsOK(res1)) {
29079 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_vfs_mount_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
29080 : }
29081 0 : arg1 = (gpgme_ctx_t)(argp1);
29082 0 : result = (gpgme_vfs_mount_result_t)gpgme_op_vfs_mount_result(arg1);
29083 : {
29084 : PyObject *fragile;
29085 0 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_vfs_mount_result,
29086 : 0 );
29087 0 : resultobj = _pyme_wrap_result(fragile, "VFSMountResult");
29088 0 : Py_DECREF(fragile);
29089 : }
29090 0 : return resultobj;
29091 : fail:
29092 : return NULL;
29093 : }
29094 :
29095 :
29096 0 : SWIGINTERN PyObject *_wrap_gpgme_op_vfs_mount(PyObject *self, PyObject *args) {
29097 0 : PyObject *resultobj = 0;
29098 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29099 0 : char *arg2 = (char *) 0 ;
29100 0 : char *arg3 = (char *) 0 ;
29101 : unsigned int arg4 ;
29102 0 : gpgme_error_t *arg5 = (gpgme_error_t *) 0 ;
29103 0 : void *argp1 = 0 ;
29104 0 : int res1 = 0 ;
29105 : unsigned int val4 ;
29106 0 : int ecode4 = 0 ;
29107 0 : void *argp5 = 0 ;
29108 0 : int res5 = 0 ;
29109 0 : PyObject * obj0 = 0 ;
29110 0 : PyObject * obj1 = 0 ;
29111 0 : PyObject * obj2 = 0 ;
29112 0 : PyObject * obj3 = 0 ;
29113 0 : PyObject * obj4 = 0 ;
29114 : gpgme_error_t result;
29115 :
29116 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_vfs_mount",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29117 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29118 0 : if (!SWIG_IsOK(res1)) {
29119 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_vfs_mount" "', argument " "1"" of type '" "gpgme_ctx_t""'");
29120 : }
29121 0 : arg1 = (gpgme_ctx_t)(argp1);
29122 : {
29123 0 : if (obj1 == Py_None)
29124 : arg2 = NULL;
29125 0 : else if (PyUnicode_Check(obj1))
29126 0 : arg2 = PyUnicode_AsUTF8(obj1);
29127 0 : else if (PyBytes_Check(obj1))
29128 0 : arg2 = PyBytes_AsString(obj1);
29129 : else {
29130 0 : PyErr_Format(PyExc_TypeError,
29131 : "arg %d: expected str, bytes, or None, got %s",
29132 : 2, obj1->ob_type->tp_name);
29133 0 : return NULL;
29134 : }
29135 : }
29136 : {
29137 0 : if (obj2 == Py_None)
29138 : arg3 = NULL;
29139 0 : else if (PyUnicode_Check(obj2))
29140 0 : arg3 = PyUnicode_AsUTF8(obj2);
29141 0 : else if (PyBytes_Check(obj2))
29142 0 : arg3 = PyBytes_AsString(obj2);
29143 : else {
29144 0 : PyErr_Format(PyExc_TypeError,
29145 : "arg %d: expected str, bytes, or None, got %s",
29146 : 3, obj2->ob_type->tp_name);
29147 0 : return NULL;
29148 : }
29149 : }
29150 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
29151 0 : if (!SWIG_IsOK(ecode4)) {
29152 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_vfs_mount" "', argument " "4"" of type '" "unsigned int""'");
29153 : }
29154 0 : arg4 = (unsigned int)(val4);
29155 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpg_error_t, 0 | 0 );
29156 0 : if (!SWIG_IsOK(res5)) {
29157 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_vfs_mount" "', argument " "5"" of type '" "gpgme_error_t *""'");
29158 : }
29159 0 : arg5 = (gpgme_error_t *)(argp5);
29160 0 : result = gpgme_op_vfs_mount(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
29161 : {
29162 0 : resultobj = PyLong_FromLong(result);
29163 : }
29164 0 : return resultobj;
29165 : fail:
29166 : return NULL;
29167 : }
29168 :
29169 :
29170 0 : SWIGINTERN PyObject *_wrap_gpgme_op_vfs_create(PyObject *self, PyObject *args) {
29171 0 : PyObject *resultobj = 0;
29172 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29173 : gpgme_key_t *arg2 ;
29174 0 : char *arg3 = (char *) 0 ;
29175 : unsigned int arg4 ;
29176 0 : gpgme_error_t *arg5 = (gpgme_error_t *) 0 ;
29177 0 : void *argp1 = 0 ;
29178 0 : int res1 = 0 ;
29179 : unsigned int val4 ;
29180 0 : int ecode4 = 0 ;
29181 0 : void *argp5 = 0 ;
29182 0 : int res5 = 0 ;
29183 0 : PyObject * obj0 = 0 ;
29184 0 : PyObject * obj1 = 0 ;
29185 0 : PyObject * obj2 = 0 ;
29186 0 : PyObject * obj3 = 0 ;
29187 0 : PyObject * obj4 = 0 ;
29188 : gpgme_error_t result;
29189 :
29190 : {
29191 0 : arg2 = NULL;
29192 : }
29193 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_vfs_create",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29194 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29195 0 : if (!SWIG_IsOK(res1)) {
29196 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_vfs_create" "', argument " "1"" of type '" "gpgme_ctx_t""'");
29197 : }
29198 0 : arg1 = (gpgme_ctx_t)(argp1);
29199 : {
29200 0 : int i, numb = 0;
29201 0 : if (!PySequence_Check(obj1)) {
29202 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
29203 : 2);
29204 0 : return NULL;
29205 : }
29206 0 : if((numb = PySequence_Length(obj1)) != 0) {
29207 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
29208 0 : for(i=0; i<numb; i++) {
29209 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
29210 :
29211 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
29212 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
29213 :
29214 : // Following code is from swig's python.swg
29215 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
29216 0 : Py_DECREF(pypointer);
29217 : return NULL;
29218 : }
29219 0 : Py_DECREF(pypointer);
29220 : }
29221 0 : arg2[numb] = NULL;
29222 : }
29223 : }
29224 : {
29225 0 : if (obj2 == Py_None)
29226 : arg3 = NULL;
29227 0 : else if (PyUnicode_Check(obj2))
29228 0 : arg3 = PyUnicode_AsUTF8(obj2);
29229 0 : else if (PyBytes_Check(obj2))
29230 0 : arg3 = PyBytes_AsString(obj2);
29231 : else {
29232 0 : PyErr_Format(PyExc_TypeError,
29233 : "arg %d: expected str, bytes, or None, got %s",
29234 : 3, obj2->ob_type->tp_name);
29235 0 : return NULL;
29236 : }
29237 : }
29238 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
29239 0 : if (!SWIG_IsOK(ecode4)) {
29240 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_vfs_create" "', argument " "4"" of type '" "unsigned int""'");
29241 : }
29242 0 : arg4 = (unsigned int)(val4);
29243 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpg_error_t, 0 | 0 );
29244 0 : if (!SWIG_IsOK(res5)) {
29245 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_vfs_create" "', argument " "5"" of type '" "gpgme_error_t *""'");
29246 : }
29247 0 : arg5 = (gpgme_error_t *)(argp5);
29248 0 : result = gpgme_op_vfs_create(arg1,arg2,(char const *)arg3,arg4,arg5);
29249 : {
29250 0 : resultobj = PyLong_FromLong(result);
29251 : }
29252 : {
29253 0 : if (arg2) free(arg2);
29254 : }
29255 0 : return resultobj;
29256 : fail:
29257 : {
29258 0 : if (arg2) free(arg2);
29259 : }
29260 : return NULL;
29261 : }
29262 :
29263 :
29264 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_no_arg_set(PyObject *self, PyObject *args) {
29265 0 : PyObject *resultobj = 0;
29266 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
29267 : unsigned int arg2 ;
29268 0 : void *argp1 = 0 ;
29269 0 : int res1 = 0 ;
29270 : unsigned int val2 ;
29271 0 : int ecode2 = 0 ;
29272 0 : PyObject * obj1 = 0 ;
29273 :
29274 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_no_arg_set",&obj1)) SWIG_fail;
29275 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
29276 0 : if (!SWIG_IsOK(res1)) {
29277 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_no_arg_set" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
29278 : }
29279 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
29280 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
29281 0 : if (!SWIG_IsOK(ecode2)) {
29282 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_no_arg_set" "', argument " "2"" of type '" "unsigned int""'");
29283 : }
29284 0 : arg2 = (unsigned int)(val2);
29285 0 : if (arg1) (arg1)->no_arg = arg2;
29286 0 : resultobj = SWIG_Py_Void();
29287 0 : return resultobj;
29288 : fail:
29289 : return NULL;
29290 : }
29291 :
29292 :
29293 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_no_arg_get(PyObject *self, PyObject *args) {
29294 0 : PyObject *resultobj = 0;
29295 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
29296 0 : void *argp1 = 0 ;
29297 0 : int res1 = 0 ;
29298 : unsigned int result;
29299 :
29300 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29301 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
29302 0 : if (!SWIG_IsOK(res1)) {
29303 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_no_arg_get" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
29304 : }
29305 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
29306 0 : result = (unsigned int) ((arg1)->no_arg);
29307 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
29308 0 : return resultobj;
29309 : fail:
29310 : return NULL;
29311 : }
29312 :
29313 :
29314 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_get(PyObject *self, PyObject *args) {
29315 0 : PyObject *resultobj = 0;
29316 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
29317 0 : void *argp1 = 0 ;
29318 0 : int res1 = 0 ;
29319 0 : gpgme_conf_arg_value *result = 0 ;
29320 :
29321 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29322 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
29323 0 : if (!SWIG_IsOK(res1)) {
29324 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_get" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
29325 : }
29326 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
29327 0 : result = (gpgme_conf_arg_value *)& ((arg1)->value);
29328 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
29329 0 : return resultobj;
29330 : fail:
29331 : return NULL;
29332 : }
29333 :
29334 :
29335 0 : SWIGINTERN int _wrap_new_gpgme_conf_arg(PyObject *self, PyObject *args) {
29336 0 : PyObject *resultobj = 0;
29337 0 : struct gpgme_conf_arg *result = 0 ;
29338 :
29339 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29340 0 : result = (struct gpgme_conf_arg *)calloc(1, sizeof(struct gpgme_conf_arg));
29341 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_arg, SWIG_BUILTIN_INIT | 0 );
29342 0 : return resultobj == Py_None ? -1 : 0;
29343 : fail:
29344 : return -1;
29345 : }
29346 :
29347 :
29348 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_arg(PyObject *self, PyObject *args) {
29349 0 : PyObject *resultobj = 0;
29350 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
29351 0 : void *argp1 = 0 ;
29352 0 : int res1 = 0 ;
29353 :
29354 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29355 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
29356 0 : if (!SWIG_IsOK(res1)) {
29357 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_arg" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
29358 : }
29359 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
29360 0 : free((char *) arg1);
29361 0 : resultobj = SWIG_Py_Void();
29362 0 : return resultobj;
29363 : fail:
29364 : return NULL;
29365 : }
29366 :
29367 :
29368 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_count_set(PyObject *self, PyObject *args) {
29369 0 : PyObject *resultobj = 0;
29370 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
29371 : unsigned int arg2 ;
29372 0 : void *argp1 = 0 ;
29373 0 : int res1 = 0 ;
29374 : unsigned int val2 ;
29375 0 : int ecode2 = 0 ;
29376 0 : PyObject * obj1 = 0 ;
29377 :
29378 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_count_set",&obj1)) SWIG_fail;
29379 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
29380 0 : if (!SWIG_IsOK(res1)) {
29381 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_count_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
29382 : }
29383 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
29384 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
29385 0 : if (!SWIG_IsOK(ecode2)) {
29386 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_value_count_set" "', argument " "2"" of type '" "unsigned int""'");
29387 : }
29388 0 : arg2 = (unsigned int)(val2);
29389 0 : if (arg1) (arg1)->count = arg2;
29390 0 : resultobj = SWIG_Py_Void();
29391 0 : return resultobj;
29392 : fail:
29393 : return NULL;
29394 : }
29395 :
29396 :
29397 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_count_get(PyObject *self, PyObject *args) {
29398 0 : PyObject *resultobj = 0;
29399 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
29400 0 : void *argp1 = 0 ;
29401 0 : int res1 = 0 ;
29402 : unsigned int result;
29403 :
29404 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29405 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
29406 0 : if (!SWIG_IsOK(res1)) {
29407 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_count_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
29408 : }
29409 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
29410 0 : result = (unsigned int) ((arg1)->count);
29411 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
29412 0 : return resultobj;
29413 : fail:
29414 : return NULL;
29415 : }
29416 :
29417 :
29418 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_uint32_set(PyObject *self, PyObject *args) {
29419 0 : PyObject *resultobj = 0;
29420 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
29421 : unsigned int arg2 ;
29422 0 : void *argp1 = 0 ;
29423 0 : int res1 = 0 ;
29424 : unsigned int val2 ;
29425 0 : int ecode2 = 0 ;
29426 0 : PyObject * obj1 = 0 ;
29427 :
29428 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_uint32_set",&obj1)) SWIG_fail;
29429 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
29430 0 : if (!SWIG_IsOK(res1)) {
29431 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_uint32_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
29432 : }
29433 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
29434 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
29435 0 : if (!SWIG_IsOK(ecode2)) {
29436 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_value_uint32_set" "', argument " "2"" of type '" "unsigned int""'");
29437 : }
29438 0 : arg2 = (unsigned int)(val2);
29439 0 : if (arg1) (arg1)->uint32 = arg2;
29440 0 : resultobj = SWIG_Py_Void();
29441 0 : return resultobj;
29442 : fail:
29443 : return NULL;
29444 : }
29445 :
29446 :
29447 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_uint32_get(PyObject *self, PyObject *args) {
29448 0 : PyObject *resultobj = 0;
29449 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
29450 0 : void *argp1 = 0 ;
29451 0 : int res1 = 0 ;
29452 : unsigned int result;
29453 :
29454 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29455 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
29456 0 : if (!SWIG_IsOK(res1)) {
29457 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_uint32_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
29458 : }
29459 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
29460 0 : result = (unsigned int) ((arg1)->uint32);
29461 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
29462 0 : return resultobj;
29463 : fail:
29464 : return NULL;
29465 : }
29466 :
29467 :
29468 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_int32_set(PyObject *self, PyObject *args) {
29469 0 : PyObject *resultobj = 0;
29470 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
29471 : int arg2 ;
29472 0 : void *argp1 = 0 ;
29473 0 : int res1 = 0 ;
29474 : int val2 ;
29475 0 : int ecode2 = 0 ;
29476 0 : PyObject * obj1 = 0 ;
29477 :
29478 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_int32_set",&obj1)) SWIG_fail;
29479 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
29480 0 : if (!SWIG_IsOK(res1)) {
29481 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_int32_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
29482 : }
29483 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
29484 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
29485 0 : if (!SWIG_IsOK(ecode2)) {
29486 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_value_int32_set" "', argument " "2"" of type '" "int""'");
29487 : }
29488 0 : arg2 = (int)(val2);
29489 0 : if (arg1) (arg1)->int32 = arg2;
29490 0 : resultobj = SWIG_Py_Void();
29491 0 : return resultobj;
29492 : fail:
29493 : return NULL;
29494 : }
29495 :
29496 :
29497 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_int32_get(PyObject *self, PyObject *args) {
29498 0 : PyObject *resultobj = 0;
29499 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
29500 0 : void *argp1 = 0 ;
29501 0 : int res1 = 0 ;
29502 : int result;
29503 :
29504 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29505 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
29506 0 : if (!SWIG_IsOK(res1)) {
29507 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_int32_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
29508 : }
29509 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
29510 0 : result = (int) ((arg1)->int32);
29511 0 : resultobj = SWIG_From_int((int)(result));
29512 0 : return resultobj;
29513 : fail:
29514 : return NULL;
29515 : }
29516 :
29517 :
29518 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_string_set(PyObject *self, PyObject *args) {
29519 0 : PyObject *resultobj = 0;
29520 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
29521 0 : char *arg2 = (char *) 0 ;
29522 0 : void *argp1 = 0 ;
29523 0 : int res1 = 0 ;
29524 : int res2 ;
29525 0 : char *buf2 = 0 ;
29526 0 : int alloc2 = 0 ;
29527 0 : PyObject * obj1 = 0 ;
29528 :
29529 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_string_set",&obj1)) SWIG_fail;
29530 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
29531 0 : if (!SWIG_IsOK(res1)) {
29532 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_string_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
29533 : }
29534 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
29535 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29536 0 : if (!SWIG_IsOK(res2)) {
29537 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_arg_value_string_set" "', argument " "2"" of type '" "char *""'");
29538 : }
29539 0 : arg2 = (char *)(buf2);
29540 0 : if (arg1->string) free((char*)arg1->string);
29541 0 : if (arg2) {
29542 0 : size_t size = strlen((const char *)(arg2)) + 1;
29543 0 : arg1->string = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
29544 : } else {
29545 0 : arg1->string = 0;
29546 : }
29547 0 : resultobj = SWIG_Py_Void();
29548 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29549 : return resultobj;
29550 : fail:
29551 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29552 : return NULL;
29553 : }
29554 :
29555 :
29556 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_string_get(PyObject *self, PyObject *args) {
29557 0 : PyObject *resultobj = 0;
29558 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
29559 0 : void *argp1 = 0 ;
29560 0 : int res1 = 0 ;
29561 0 : char *result = 0 ;
29562 :
29563 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29564 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
29565 0 : if (!SWIG_IsOK(res1)) {
29566 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_string_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
29567 : }
29568 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
29569 0 : result = (char *) ((arg1)->string);
29570 0 : resultobj = SWIG_FromCharPtr((const char *)result);
29571 0 : return resultobj;
29572 : fail:
29573 : return NULL;
29574 : }
29575 :
29576 :
29577 0 : SWIGINTERN int _wrap_new_gpgme_conf_arg_value(PyObject *self, PyObject *args) {
29578 0 : PyObject *resultobj = 0;
29579 0 : gpgme_conf_arg_value *result = 0 ;
29580 :
29581 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29582 0 : result = (gpgme_conf_arg_value *)calloc(1, sizeof(gpgme_conf_arg_value));
29583 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_arg_value, SWIG_BUILTIN_INIT | 0 );
29584 0 : return resultobj == Py_None ? -1 : 0;
29585 : fail:
29586 : return -1;
29587 : }
29588 :
29589 :
29590 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_arg_value(PyObject *self, PyObject *args) {
29591 0 : PyObject *resultobj = 0;
29592 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
29593 0 : void *argp1 = 0 ;
29594 0 : int res1 = 0 ;
29595 :
29596 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29597 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, SWIG_POINTER_DISOWN | 0 );
29598 0 : if (!SWIG_IsOK(res1)) {
29599 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_arg_value" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
29600 : }
29601 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
29602 0 : free((char *) arg1);
29603 0 : resultobj = SWIG_Py_Void();
29604 0 : return resultobj;
29605 : fail:
29606 : return NULL;
29607 : }
29608 :
29609 :
29610 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_name_set(PyObject *self, PyObject *args) {
29611 0 : PyObject *resultobj = 0;
29612 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29613 0 : char *arg2 = (char *) 0 ;
29614 0 : void *argp1 = 0 ;
29615 0 : int res1 = 0 ;
29616 : int res2 ;
29617 0 : char *buf2 = 0 ;
29618 0 : int alloc2 = 0 ;
29619 0 : PyObject * obj1 = 0 ;
29620 :
29621 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_name_set",&obj1)) SWIG_fail;
29622 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29623 0 : if (!SWIG_IsOK(res1)) {
29624 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_name_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29625 : }
29626 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29627 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29628 0 : if (!SWIG_IsOK(res2)) {
29629 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_name_set" "', argument " "2"" of type '" "char *""'");
29630 : }
29631 0 : arg2 = (char *)(buf2);
29632 0 : if (arg1->name) free((char*)arg1->name);
29633 0 : if (arg2) {
29634 0 : size_t size = strlen((const char *)(arg2)) + 1;
29635 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
29636 : } else {
29637 0 : arg1->name = 0;
29638 : }
29639 0 : resultobj = SWIG_Py_Void();
29640 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29641 : return resultobj;
29642 : fail:
29643 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29644 : return NULL;
29645 : }
29646 :
29647 :
29648 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_name_get(PyObject *self, PyObject *args) {
29649 0 : PyObject *resultobj = 0;
29650 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29651 0 : void *argp1 = 0 ;
29652 0 : int res1 = 0 ;
29653 0 : char *result = 0 ;
29654 :
29655 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29656 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29657 0 : if (!SWIG_IsOK(res1)) {
29658 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_name_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29659 : }
29660 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29661 0 : result = (char *) ((arg1)->name);
29662 0 : resultobj = SWIG_FromCharPtr((const char *)result);
29663 0 : return resultobj;
29664 : fail:
29665 : return NULL;
29666 : }
29667 :
29668 :
29669 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_flags_set(PyObject *self, PyObject *args) {
29670 0 : PyObject *resultobj = 0;
29671 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29672 : unsigned int arg2 ;
29673 0 : void *argp1 = 0 ;
29674 0 : int res1 = 0 ;
29675 : unsigned int val2 ;
29676 0 : int ecode2 = 0 ;
29677 0 : PyObject * obj1 = 0 ;
29678 :
29679 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_flags_set",&obj1)) SWIG_fail;
29680 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29681 0 : if (!SWIG_IsOK(res1)) {
29682 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_flags_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29683 : }
29684 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29685 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
29686 0 : if (!SWIG_IsOK(ecode2)) {
29687 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_flags_set" "', argument " "2"" of type '" "unsigned int""'");
29688 : }
29689 0 : arg2 = (unsigned int)(val2);
29690 0 : if (arg1) (arg1)->flags = arg2;
29691 0 : resultobj = SWIG_Py_Void();
29692 0 : return resultobj;
29693 : fail:
29694 : return NULL;
29695 : }
29696 :
29697 :
29698 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_flags_get(PyObject *self, PyObject *args) {
29699 0 : PyObject *resultobj = 0;
29700 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29701 0 : void *argp1 = 0 ;
29702 0 : int res1 = 0 ;
29703 : unsigned int result;
29704 :
29705 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29706 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29707 0 : if (!SWIG_IsOK(res1)) {
29708 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_flags_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29709 : }
29710 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29711 0 : result = (unsigned int) ((arg1)->flags);
29712 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
29713 0 : return resultobj;
29714 : fail:
29715 : return NULL;
29716 : }
29717 :
29718 :
29719 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_level_set(PyObject *self, PyObject *args) {
29720 0 : PyObject *resultobj = 0;
29721 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29722 : gpgme_conf_level_t arg2 ;
29723 0 : void *argp1 = 0 ;
29724 0 : int res1 = 0 ;
29725 : int val2 ;
29726 0 : int ecode2 = 0 ;
29727 0 : PyObject * obj1 = 0 ;
29728 :
29729 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_level_set",&obj1)) SWIG_fail;
29730 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29731 0 : if (!SWIG_IsOK(res1)) {
29732 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_level_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29733 : }
29734 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29735 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
29736 0 : if (!SWIG_IsOK(ecode2)) {
29737 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_level_set" "', argument " "2"" of type '" "gpgme_conf_level_t""'");
29738 : }
29739 0 : arg2 = (gpgme_conf_level_t)(val2);
29740 0 : if (arg1) (arg1)->level = arg2;
29741 0 : resultobj = SWIG_Py_Void();
29742 0 : return resultobj;
29743 : fail:
29744 : return NULL;
29745 : }
29746 :
29747 :
29748 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_level_get(PyObject *self, PyObject *args) {
29749 0 : PyObject *resultobj = 0;
29750 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29751 0 : void *argp1 = 0 ;
29752 0 : int res1 = 0 ;
29753 : gpgme_conf_level_t result;
29754 :
29755 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29756 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29757 0 : if (!SWIG_IsOK(res1)) {
29758 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_level_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29759 : }
29760 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29761 0 : result = (gpgme_conf_level_t) ((arg1)->level);
29762 0 : resultobj = SWIG_From_int((int)(result));
29763 0 : return resultobj;
29764 : fail:
29765 : return NULL;
29766 : }
29767 :
29768 :
29769 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_description_set(PyObject *self, PyObject *args) {
29770 0 : PyObject *resultobj = 0;
29771 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29772 0 : char *arg2 = (char *) 0 ;
29773 0 : void *argp1 = 0 ;
29774 0 : int res1 = 0 ;
29775 : int res2 ;
29776 0 : char *buf2 = 0 ;
29777 0 : int alloc2 = 0 ;
29778 0 : PyObject * obj1 = 0 ;
29779 :
29780 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_description_set",&obj1)) SWIG_fail;
29781 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29782 0 : if (!SWIG_IsOK(res1)) {
29783 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_description_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29784 : }
29785 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29786 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29787 0 : if (!SWIG_IsOK(res2)) {
29788 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_description_set" "', argument " "2"" of type '" "char *""'");
29789 : }
29790 0 : arg2 = (char *)(buf2);
29791 0 : if (arg1->description) free((char*)arg1->description);
29792 0 : if (arg2) {
29793 0 : size_t size = strlen((const char *)(arg2)) + 1;
29794 0 : arg1->description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
29795 : } else {
29796 0 : arg1->description = 0;
29797 : }
29798 0 : resultobj = SWIG_Py_Void();
29799 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29800 : return resultobj;
29801 : fail:
29802 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29803 : return NULL;
29804 : }
29805 :
29806 :
29807 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_description_get(PyObject *self, PyObject *args) {
29808 0 : PyObject *resultobj = 0;
29809 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29810 0 : void *argp1 = 0 ;
29811 0 : int res1 = 0 ;
29812 0 : char *result = 0 ;
29813 :
29814 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29815 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29816 0 : if (!SWIG_IsOK(res1)) {
29817 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_description_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29818 : }
29819 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29820 0 : result = (char *) ((arg1)->description);
29821 0 : resultobj = SWIG_FromCharPtr((const char *)result);
29822 0 : return resultobj;
29823 : fail:
29824 : return NULL;
29825 : }
29826 :
29827 :
29828 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_type_set(PyObject *self, PyObject *args) {
29829 0 : PyObject *resultobj = 0;
29830 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29831 : gpgme_conf_type_t arg2 ;
29832 0 : void *argp1 = 0 ;
29833 0 : int res1 = 0 ;
29834 : int val2 ;
29835 0 : int ecode2 = 0 ;
29836 0 : PyObject * obj1 = 0 ;
29837 :
29838 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_type_set",&obj1)) SWIG_fail;
29839 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29840 0 : if (!SWIG_IsOK(res1)) {
29841 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_type_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29842 : }
29843 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29844 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
29845 0 : if (!SWIG_IsOK(ecode2)) {
29846 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_type_set" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
29847 : }
29848 0 : arg2 = (gpgme_conf_type_t)(val2);
29849 0 : if (arg1) (arg1)->type = arg2;
29850 0 : resultobj = SWIG_Py_Void();
29851 0 : return resultobj;
29852 : fail:
29853 : return NULL;
29854 : }
29855 :
29856 :
29857 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_type_get(PyObject *self, PyObject *args) {
29858 0 : PyObject *resultobj = 0;
29859 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29860 0 : void *argp1 = 0 ;
29861 0 : int res1 = 0 ;
29862 : gpgme_conf_type_t result;
29863 :
29864 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29865 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29866 0 : if (!SWIG_IsOK(res1)) {
29867 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_type_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29868 : }
29869 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29870 0 : result = (gpgme_conf_type_t) ((arg1)->type);
29871 0 : resultobj = SWIG_From_int((int)(result));
29872 0 : return resultobj;
29873 : fail:
29874 : return NULL;
29875 : }
29876 :
29877 :
29878 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_alt_type_set(PyObject *self, PyObject *args) {
29879 0 : PyObject *resultobj = 0;
29880 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29881 : gpgme_conf_type_t arg2 ;
29882 0 : void *argp1 = 0 ;
29883 0 : int res1 = 0 ;
29884 : int val2 ;
29885 0 : int ecode2 = 0 ;
29886 0 : PyObject * obj1 = 0 ;
29887 :
29888 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_alt_type_set",&obj1)) SWIG_fail;
29889 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29890 0 : if (!SWIG_IsOK(res1)) {
29891 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_alt_type_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29892 : }
29893 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29894 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
29895 0 : if (!SWIG_IsOK(ecode2)) {
29896 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_alt_type_set" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
29897 : }
29898 0 : arg2 = (gpgme_conf_type_t)(val2);
29899 0 : if (arg1) (arg1)->alt_type = arg2;
29900 0 : resultobj = SWIG_Py_Void();
29901 0 : return resultobj;
29902 : fail:
29903 : return NULL;
29904 : }
29905 :
29906 :
29907 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_alt_type_get(PyObject *self, PyObject *args) {
29908 0 : PyObject *resultobj = 0;
29909 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29910 0 : void *argp1 = 0 ;
29911 0 : int res1 = 0 ;
29912 : gpgme_conf_type_t result;
29913 :
29914 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29915 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29916 0 : if (!SWIG_IsOK(res1)) {
29917 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_alt_type_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29918 : }
29919 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29920 0 : result = (gpgme_conf_type_t) ((arg1)->alt_type);
29921 0 : resultobj = SWIG_From_int((int)(result));
29922 0 : return resultobj;
29923 : fail:
29924 : return NULL;
29925 : }
29926 :
29927 :
29928 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_argname_set(PyObject *self, PyObject *args) {
29929 0 : PyObject *resultobj = 0;
29930 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29931 0 : char *arg2 = (char *) 0 ;
29932 0 : void *argp1 = 0 ;
29933 0 : int res1 = 0 ;
29934 : int res2 ;
29935 0 : char *buf2 = 0 ;
29936 0 : int alloc2 = 0 ;
29937 0 : PyObject * obj1 = 0 ;
29938 :
29939 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_argname_set",&obj1)) SWIG_fail;
29940 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29941 0 : if (!SWIG_IsOK(res1)) {
29942 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_argname_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29943 : }
29944 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29945 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29946 0 : if (!SWIG_IsOK(res2)) {
29947 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_argname_set" "', argument " "2"" of type '" "char *""'");
29948 : }
29949 0 : arg2 = (char *)(buf2);
29950 0 : if (arg1->argname) free((char*)arg1->argname);
29951 0 : if (arg2) {
29952 0 : size_t size = strlen((const char *)(arg2)) + 1;
29953 0 : arg1->argname = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
29954 : } else {
29955 0 : arg1->argname = 0;
29956 : }
29957 0 : resultobj = SWIG_Py_Void();
29958 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29959 : return resultobj;
29960 : fail:
29961 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29962 : return NULL;
29963 : }
29964 :
29965 :
29966 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_argname_get(PyObject *self, PyObject *args) {
29967 0 : PyObject *resultobj = 0;
29968 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29969 0 : void *argp1 = 0 ;
29970 0 : int res1 = 0 ;
29971 0 : char *result = 0 ;
29972 :
29973 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
29974 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29975 0 : if (!SWIG_IsOK(res1)) {
29976 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_argname_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
29977 : }
29978 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
29979 0 : result = (char *) ((arg1)->argname);
29980 0 : resultobj = SWIG_FromCharPtr((const char *)result);
29981 0 : return resultobj;
29982 : fail:
29983 : return NULL;
29984 : }
29985 :
29986 :
29987 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_value_set(PyObject *self, PyObject *args) {
29988 0 : PyObject *resultobj = 0;
29989 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
29990 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
29991 0 : void *argp1 = 0 ;
29992 0 : int res1 = 0 ;
29993 0 : void *argp2 = 0 ;
29994 0 : int res2 = 0 ;
29995 0 : PyObject * obj1 = 0 ;
29996 :
29997 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_default_value_set",&obj1)) SWIG_fail;
29998 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
29999 0 : if (!SWIG_IsOK(res1)) {
30000 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30001 : }
30002 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30003 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
30004 0 : if (!SWIG_IsOK(res2)) {
30005 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_default_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
30006 : }
30007 0 : arg2 = (gpgme_conf_arg_t)(argp2);
30008 0 : if (arg1) (arg1)->default_value = arg2;
30009 0 : resultobj = SWIG_Py_Void();
30010 0 : return resultobj;
30011 : fail:
30012 : return NULL;
30013 : }
30014 :
30015 :
30016 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_value_get(PyObject *self, PyObject *args) {
30017 0 : PyObject *resultobj = 0;
30018 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30019 0 : void *argp1 = 0 ;
30020 0 : int res1 = 0 ;
30021 : gpgme_conf_arg_t result;
30022 :
30023 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30024 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30025 0 : if (!SWIG_IsOK(res1)) {
30026 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30027 : }
30028 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30029 0 : result = (gpgme_conf_arg_t) ((arg1)->default_value);
30030 : {
30031 : int i;
30032 0 : int size = 0;
30033 : gpgme_conf_arg_t curr;
30034 0 : for (curr = result; curr != NULL; curr = curr->next) {
30035 0 : size++;
30036 : }
30037 0 : resultobj = PyList_New(size);
30038 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
30039 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
30040 0 : PyList_SetItem(resultobj, i, o);
30041 : }
30042 : }
30043 : return resultobj;
30044 : fail:
30045 : return NULL;
30046 : }
30047 :
30048 :
30049 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_description_set(PyObject *self, PyObject *args) {
30050 0 : PyObject *resultobj = 0;
30051 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30052 0 : char *arg2 = (char *) 0 ;
30053 0 : void *argp1 = 0 ;
30054 0 : int res1 = 0 ;
30055 : int res2 ;
30056 0 : char *buf2 = 0 ;
30057 0 : int alloc2 = 0 ;
30058 0 : PyObject * obj1 = 0 ;
30059 :
30060 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_default_description_set",&obj1)) SWIG_fail;
30061 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30062 0 : if (!SWIG_IsOK(res1)) {
30063 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_description_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30064 : }
30065 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30066 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30067 0 : if (!SWIG_IsOK(res2)) {
30068 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_default_description_set" "', argument " "2"" of type '" "char *""'");
30069 : }
30070 0 : arg2 = (char *)(buf2);
30071 0 : if (arg1->default_description) free((char*)arg1->default_description);
30072 0 : if (arg2) {
30073 0 : size_t size = strlen((const char *)(arg2)) + 1;
30074 0 : arg1->default_description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
30075 : } else {
30076 0 : arg1->default_description = 0;
30077 : }
30078 0 : resultobj = SWIG_Py_Void();
30079 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30080 : return resultobj;
30081 : fail:
30082 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30083 : return NULL;
30084 : }
30085 :
30086 :
30087 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_description_get(PyObject *self, PyObject *args) {
30088 0 : PyObject *resultobj = 0;
30089 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30090 0 : void *argp1 = 0 ;
30091 0 : int res1 = 0 ;
30092 0 : char *result = 0 ;
30093 :
30094 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30095 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30096 0 : if (!SWIG_IsOK(res1)) {
30097 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_description_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30098 : }
30099 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30100 0 : result = (char *) ((arg1)->default_description);
30101 0 : resultobj = SWIG_FromCharPtr((const char *)result);
30102 0 : return resultobj;
30103 : fail:
30104 : return NULL;
30105 : }
30106 :
30107 :
30108 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_value_set(PyObject *self, PyObject *args) {
30109 0 : PyObject *resultobj = 0;
30110 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30111 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
30112 0 : void *argp1 = 0 ;
30113 0 : int res1 = 0 ;
30114 0 : void *argp2 = 0 ;
30115 0 : int res2 = 0 ;
30116 0 : PyObject * obj1 = 0 ;
30117 :
30118 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_no_arg_value_set",&obj1)) SWIG_fail;
30119 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30120 0 : if (!SWIG_IsOK(res1)) {
30121 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30122 : }
30123 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30124 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
30125 0 : if (!SWIG_IsOK(res2)) {
30126 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_no_arg_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
30127 : }
30128 0 : arg2 = (gpgme_conf_arg_t)(argp2);
30129 0 : if (arg1) (arg1)->no_arg_value = arg2;
30130 0 : resultobj = SWIG_Py_Void();
30131 0 : return resultobj;
30132 : fail:
30133 : return NULL;
30134 : }
30135 :
30136 :
30137 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_value_get(PyObject *self, PyObject *args) {
30138 0 : PyObject *resultobj = 0;
30139 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30140 0 : void *argp1 = 0 ;
30141 0 : int res1 = 0 ;
30142 : gpgme_conf_arg_t result;
30143 :
30144 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30145 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30146 0 : if (!SWIG_IsOK(res1)) {
30147 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30148 : }
30149 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30150 0 : result = (gpgme_conf_arg_t) ((arg1)->no_arg_value);
30151 : {
30152 : int i;
30153 0 : int size = 0;
30154 : gpgme_conf_arg_t curr;
30155 0 : for (curr = result; curr != NULL; curr = curr->next) {
30156 0 : size++;
30157 : }
30158 0 : resultobj = PyList_New(size);
30159 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
30160 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
30161 0 : PyList_SetItem(resultobj, i, o);
30162 : }
30163 : }
30164 : return resultobj;
30165 : fail:
30166 : return NULL;
30167 : }
30168 :
30169 :
30170 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_description_set(PyObject *self, PyObject *args) {
30171 0 : PyObject *resultobj = 0;
30172 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30173 0 : char *arg2 = (char *) 0 ;
30174 0 : void *argp1 = 0 ;
30175 0 : int res1 = 0 ;
30176 : int res2 ;
30177 0 : char *buf2 = 0 ;
30178 0 : int alloc2 = 0 ;
30179 0 : PyObject * obj1 = 0 ;
30180 :
30181 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_no_arg_description_set",&obj1)) SWIG_fail;
30182 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30183 0 : if (!SWIG_IsOK(res1)) {
30184 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_description_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30185 : }
30186 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30187 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30188 0 : if (!SWIG_IsOK(res2)) {
30189 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_no_arg_description_set" "', argument " "2"" of type '" "char *""'");
30190 : }
30191 0 : arg2 = (char *)(buf2);
30192 0 : if (arg1->no_arg_description) free((char*)arg1->no_arg_description);
30193 0 : if (arg2) {
30194 0 : size_t size = strlen((const char *)(arg2)) + 1;
30195 0 : arg1->no_arg_description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
30196 : } else {
30197 0 : arg1->no_arg_description = 0;
30198 : }
30199 0 : resultobj = SWIG_Py_Void();
30200 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30201 : return resultobj;
30202 : fail:
30203 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30204 : return NULL;
30205 : }
30206 :
30207 :
30208 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_description_get(PyObject *self, PyObject *args) {
30209 0 : PyObject *resultobj = 0;
30210 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30211 0 : void *argp1 = 0 ;
30212 0 : int res1 = 0 ;
30213 0 : char *result = 0 ;
30214 :
30215 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30216 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30217 0 : if (!SWIG_IsOK(res1)) {
30218 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_description_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30219 : }
30220 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30221 0 : result = (char *) ((arg1)->no_arg_description);
30222 0 : resultobj = SWIG_FromCharPtr((const char *)result);
30223 0 : return resultobj;
30224 : fail:
30225 : return NULL;
30226 : }
30227 :
30228 :
30229 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_value_set(PyObject *self, PyObject *args) {
30230 0 : PyObject *resultobj = 0;
30231 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30232 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
30233 0 : void *argp1 = 0 ;
30234 0 : int res1 = 0 ;
30235 0 : void *argp2 = 0 ;
30236 0 : int res2 = 0 ;
30237 0 : PyObject * obj1 = 0 ;
30238 :
30239 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_value_set",&obj1)) SWIG_fail;
30240 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30241 0 : if (!SWIG_IsOK(res1)) {
30242 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30243 : }
30244 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30245 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
30246 0 : if (!SWIG_IsOK(res2)) {
30247 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
30248 : }
30249 0 : arg2 = (gpgme_conf_arg_t)(argp2);
30250 0 : if (arg1) (arg1)->value = arg2;
30251 0 : resultobj = SWIG_Py_Void();
30252 0 : return resultobj;
30253 : fail:
30254 : return NULL;
30255 : }
30256 :
30257 :
30258 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_value_get(PyObject *self, PyObject *args) {
30259 0 : PyObject *resultobj = 0;
30260 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30261 0 : void *argp1 = 0 ;
30262 0 : int res1 = 0 ;
30263 : gpgme_conf_arg_t result;
30264 :
30265 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30266 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30267 0 : if (!SWIG_IsOK(res1)) {
30268 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30269 : }
30270 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30271 0 : result = (gpgme_conf_arg_t) ((arg1)->value);
30272 : {
30273 : int i;
30274 0 : int size = 0;
30275 : gpgme_conf_arg_t curr;
30276 0 : for (curr = result; curr != NULL; curr = curr->next) {
30277 0 : size++;
30278 : }
30279 0 : resultobj = PyList_New(size);
30280 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
30281 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
30282 0 : PyList_SetItem(resultobj, i, o);
30283 : }
30284 : }
30285 : return resultobj;
30286 : fail:
30287 : return NULL;
30288 : }
30289 :
30290 :
30291 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_change_value_set(PyObject *self, PyObject *args) {
30292 0 : PyObject *resultobj = 0;
30293 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30294 : int arg2 ;
30295 0 : void *argp1 = 0 ;
30296 0 : int res1 = 0 ;
30297 : int val2 ;
30298 0 : int ecode2 = 0 ;
30299 0 : PyObject * obj1 = 0 ;
30300 :
30301 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_change_value_set",&obj1)) SWIG_fail;
30302 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30303 0 : if (!SWIG_IsOK(res1)) {
30304 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_change_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30305 : }
30306 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30307 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
30308 0 : if (!SWIG_IsOK(ecode2)) {
30309 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_change_value_set" "', argument " "2"" of type '" "int""'");
30310 : }
30311 0 : arg2 = (int)(val2);
30312 0 : if (arg1) (arg1)->change_value = arg2;
30313 0 : resultobj = SWIG_Py_Void();
30314 0 : return resultobj;
30315 : fail:
30316 : return NULL;
30317 : }
30318 :
30319 :
30320 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_change_value_get(PyObject *self, PyObject *args) {
30321 0 : PyObject *resultobj = 0;
30322 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30323 0 : void *argp1 = 0 ;
30324 0 : int res1 = 0 ;
30325 : int result;
30326 :
30327 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30328 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30329 0 : if (!SWIG_IsOK(res1)) {
30330 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_change_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30331 : }
30332 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30333 0 : result = (int) ((arg1)->change_value);
30334 0 : resultobj = SWIG_From_int((int)(result));
30335 0 : return resultobj;
30336 : fail:
30337 : return NULL;
30338 : }
30339 :
30340 :
30341 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_new_value_set(PyObject *self, PyObject *args) {
30342 0 : PyObject *resultobj = 0;
30343 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30344 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
30345 0 : void *argp1 = 0 ;
30346 0 : int res1 = 0 ;
30347 0 : void *argp2 = 0 ;
30348 0 : int res2 = 0 ;
30349 0 : PyObject * obj1 = 0 ;
30350 :
30351 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_new_value_set",&obj1)) SWIG_fail;
30352 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30353 0 : if (!SWIG_IsOK(res1)) {
30354 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_new_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30355 : }
30356 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30357 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
30358 0 : if (!SWIG_IsOK(res2)) {
30359 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_new_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
30360 : }
30361 0 : arg2 = (gpgme_conf_arg_t)(argp2);
30362 0 : if (arg1) (arg1)->new_value = arg2;
30363 0 : resultobj = SWIG_Py_Void();
30364 0 : return resultobj;
30365 : fail:
30366 : return NULL;
30367 : }
30368 :
30369 :
30370 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_new_value_get(PyObject *self, PyObject *args) {
30371 0 : PyObject *resultobj = 0;
30372 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30373 0 : void *argp1 = 0 ;
30374 0 : int res1 = 0 ;
30375 : gpgme_conf_arg_t result;
30376 :
30377 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30378 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30379 0 : if (!SWIG_IsOK(res1)) {
30380 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_new_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30381 : }
30382 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30383 0 : result = (gpgme_conf_arg_t) ((arg1)->new_value);
30384 : {
30385 : int i;
30386 0 : int size = 0;
30387 : gpgme_conf_arg_t curr;
30388 0 : for (curr = result; curr != NULL; curr = curr->next) {
30389 0 : size++;
30390 : }
30391 0 : resultobj = PyList_New(size);
30392 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
30393 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
30394 0 : PyList_SetItem(resultobj, i, o);
30395 : }
30396 : }
30397 : return resultobj;
30398 : fail:
30399 : return NULL;
30400 : }
30401 :
30402 :
30403 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_user_data_set(PyObject *self, PyObject *args) {
30404 0 : PyObject *resultobj = 0;
30405 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30406 0 : void *arg2 = (void *) 0 ;
30407 0 : void *argp1 = 0 ;
30408 0 : int res1 = 0 ;
30409 : int res2 ;
30410 0 : PyObject * obj1 = 0 ;
30411 :
30412 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_user_data_set",&obj1)) SWIG_fail;
30413 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30414 0 : if (!SWIG_IsOK(res1)) {
30415 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_user_data_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30416 : }
30417 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30418 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
30419 0 : if (!SWIG_IsOK(res2)) {
30420 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_user_data_set" "', argument " "2"" of type '" "void *""'");
30421 : }
30422 0 : if (arg1) (arg1)->user_data = arg2;
30423 0 : resultobj = SWIG_Py_Void();
30424 0 : return resultobj;
30425 : fail:
30426 : return NULL;
30427 : }
30428 :
30429 :
30430 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_user_data_get(PyObject *self, PyObject *args) {
30431 0 : PyObject *resultobj = 0;
30432 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30433 0 : void *argp1 = 0 ;
30434 0 : int res1 = 0 ;
30435 0 : void *result = 0 ;
30436 :
30437 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30438 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30439 0 : if (!SWIG_IsOK(res1)) {
30440 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_user_data_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30441 : }
30442 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30443 0 : result = (void *) ((arg1)->user_data);
30444 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
30445 0 : return resultobj;
30446 : fail:
30447 : return NULL;
30448 : }
30449 :
30450 :
30451 0 : SWIGINTERN int _wrap_new_gpgme_conf_opt(PyObject *self, PyObject *args) {
30452 0 : PyObject *resultobj = 0;
30453 0 : struct gpgme_conf_opt *result = 0 ;
30454 :
30455 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30456 0 : result = (struct gpgme_conf_opt *)calloc(1, sizeof(struct gpgme_conf_opt));
30457 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_opt, SWIG_BUILTIN_INIT | 0 );
30458 0 : return resultobj == Py_None ? -1 : 0;
30459 : fail:
30460 : return -1;
30461 : }
30462 :
30463 :
30464 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_opt(PyObject *self, PyObject *args) {
30465 0 : PyObject *resultobj = 0;
30466 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
30467 0 : void *argp1 = 0 ;
30468 0 : int res1 = 0 ;
30469 :
30470 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30471 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_opt, SWIG_POINTER_DISOWN | 0 );
30472 0 : if (!SWIG_IsOK(res1)) {
30473 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_opt" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
30474 : }
30475 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
30476 0 : free((char *) arg1);
30477 0 : resultobj = SWIG_Py_Void();
30478 0 : return resultobj;
30479 : fail:
30480 : return NULL;
30481 : }
30482 :
30483 :
30484 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp__last_opt_p_set(PyObject *self, PyObject *args) {
30485 0 : PyObject *resultobj = 0;
30486 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
30487 0 : gpgme_conf_opt_t *arg2 = (gpgme_conf_opt_t *) 0 ;
30488 0 : void *argp1 = 0 ;
30489 0 : int res1 = 0 ;
30490 0 : void *argp2 = 0 ;
30491 0 : int res2 = 0 ;
30492 0 : PyObject * obj1 = 0 ;
30493 :
30494 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp__last_opt_p_set",&obj1)) SWIG_fail;
30495 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30496 0 : if (!SWIG_IsOK(res1)) {
30497 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp__last_opt_p_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
30498 : }
30499 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
30500 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_gpgme_conf_opt, 0 | 0 );
30501 0 : if (!SWIG_IsOK(res2)) {
30502 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp__last_opt_p_set" "', argument " "2"" of type '" "gpgme_conf_opt_t *""'");
30503 : }
30504 0 : arg2 = (gpgme_conf_opt_t *)(argp2);
30505 0 : if (arg1) (arg1)->_last_opt_p = arg2;
30506 0 : resultobj = SWIG_Py_Void();
30507 0 : return resultobj;
30508 : fail:
30509 : return NULL;
30510 : }
30511 :
30512 :
30513 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp__last_opt_p_get(PyObject *self, PyObject *args) {
30514 0 : PyObject *resultobj = 0;
30515 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
30516 0 : void *argp1 = 0 ;
30517 0 : int res1 = 0 ;
30518 0 : gpgme_conf_opt_t *result = 0 ;
30519 :
30520 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30521 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30522 0 : if (!SWIG_IsOK(res1)) {
30523 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp__last_opt_p_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
30524 : }
30525 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
30526 0 : result = (gpgme_conf_opt_t *) ((arg1)->_last_opt_p);
30527 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_conf_opt, 0 | 0 );
30528 0 : return resultobj;
30529 : fail:
30530 : return NULL;
30531 : }
30532 :
30533 :
30534 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_name_set(PyObject *self, PyObject *args) {
30535 0 : PyObject *resultobj = 0;
30536 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
30537 0 : char *arg2 = (char *) 0 ;
30538 0 : void *argp1 = 0 ;
30539 0 : int res1 = 0 ;
30540 : int res2 ;
30541 0 : char *buf2 = 0 ;
30542 0 : int alloc2 = 0 ;
30543 0 : PyObject * obj1 = 0 ;
30544 :
30545 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_name_set",&obj1)) SWIG_fail;
30546 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30547 0 : if (!SWIG_IsOK(res1)) {
30548 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_name_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
30549 : }
30550 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
30551 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30552 0 : if (!SWIG_IsOK(res2)) {
30553 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_name_set" "', argument " "2"" of type '" "char *""'");
30554 : }
30555 0 : arg2 = (char *)(buf2);
30556 0 : if (arg1->name) free((char*)arg1->name);
30557 0 : if (arg2) {
30558 0 : size_t size = strlen((const char *)(arg2)) + 1;
30559 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
30560 : } else {
30561 0 : arg1->name = 0;
30562 : }
30563 0 : resultobj = SWIG_Py_Void();
30564 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30565 : return resultobj;
30566 : fail:
30567 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30568 : return NULL;
30569 : }
30570 :
30571 :
30572 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_name_get(PyObject *self, PyObject *args) {
30573 0 : PyObject *resultobj = 0;
30574 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
30575 0 : void *argp1 = 0 ;
30576 0 : int res1 = 0 ;
30577 0 : char *result = 0 ;
30578 :
30579 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30580 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30581 0 : if (!SWIG_IsOK(res1)) {
30582 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_name_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
30583 : }
30584 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
30585 0 : result = (char *) ((arg1)->name);
30586 0 : resultobj = SWIG_FromCharPtr((const char *)result);
30587 0 : return resultobj;
30588 : fail:
30589 : return NULL;
30590 : }
30591 :
30592 :
30593 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_description_set(PyObject *self, PyObject *args) {
30594 0 : PyObject *resultobj = 0;
30595 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
30596 0 : char *arg2 = (char *) 0 ;
30597 0 : void *argp1 = 0 ;
30598 0 : int res1 = 0 ;
30599 : int res2 ;
30600 0 : char *buf2 = 0 ;
30601 0 : int alloc2 = 0 ;
30602 0 : PyObject * obj1 = 0 ;
30603 :
30604 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_description_set",&obj1)) SWIG_fail;
30605 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30606 0 : if (!SWIG_IsOK(res1)) {
30607 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_description_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
30608 : }
30609 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
30610 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30611 0 : if (!SWIG_IsOK(res2)) {
30612 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_description_set" "', argument " "2"" of type '" "char *""'");
30613 : }
30614 0 : arg2 = (char *)(buf2);
30615 0 : if (arg1->description) free((char*)arg1->description);
30616 0 : if (arg2) {
30617 0 : size_t size = strlen((const char *)(arg2)) + 1;
30618 0 : arg1->description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
30619 : } else {
30620 0 : arg1->description = 0;
30621 : }
30622 0 : resultobj = SWIG_Py_Void();
30623 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30624 : return resultobj;
30625 : fail:
30626 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30627 : return NULL;
30628 : }
30629 :
30630 :
30631 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_description_get(PyObject *self, PyObject *args) {
30632 0 : PyObject *resultobj = 0;
30633 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
30634 0 : void *argp1 = 0 ;
30635 0 : int res1 = 0 ;
30636 0 : char *result = 0 ;
30637 :
30638 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30639 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30640 0 : if (!SWIG_IsOK(res1)) {
30641 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_description_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
30642 : }
30643 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
30644 0 : result = (char *) ((arg1)->description);
30645 0 : resultobj = SWIG_FromCharPtr((const char *)result);
30646 0 : return resultobj;
30647 : fail:
30648 : return NULL;
30649 : }
30650 :
30651 :
30652 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_program_name_set(PyObject *self, PyObject *args) {
30653 0 : PyObject *resultobj = 0;
30654 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
30655 0 : char *arg2 = (char *) 0 ;
30656 0 : void *argp1 = 0 ;
30657 0 : int res1 = 0 ;
30658 : int res2 ;
30659 0 : char *buf2 = 0 ;
30660 0 : int alloc2 = 0 ;
30661 0 : PyObject * obj1 = 0 ;
30662 :
30663 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_program_name_set",&obj1)) SWIG_fail;
30664 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30665 0 : if (!SWIG_IsOK(res1)) {
30666 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_program_name_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
30667 : }
30668 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
30669 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30670 0 : if (!SWIG_IsOK(res2)) {
30671 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_program_name_set" "', argument " "2"" of type '" "char *""'");
30672 : }
30673 0 : arg2 = (char *)(buf2);
30674 0 : if (arg1->program_name) free((char*)arg1->program_name);
30675 0 : if (arg2) {
30676 0 : size_t size = strlen((const char *)(arg2)) + 1;
30677 0 : arg1->program_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
30678 : } else {
30679 0 : arg1->program_name = 0;
30680 : }
30681 0 : resultobj = SWIG_Py_Void();
30682 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30683 : return resultobj;
30684 : fail:
30685 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30686 : return NULL;
30687 : }
30688 :
30689 :
30690 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_program_name_get(PyObject *self, PyObject *args) {
30691 0 : PyObject *resultobj = 0;
30692 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
30693 0 : void *argp1 = 0 ;
30694 0 : int res1 = 0 ;
30695 0 : char *result = 0 ;
30696 :
30697 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30698 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30699 0 : if (!SWIG_IsOK(res1)) {
30700 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_program_name_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
30701 : }
30702 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
30703 0 : result = (char *) ((arg1)->program_name);
30704 0 : resultobj = SWIG_FromCharPtr((const char *)result);
30705 0 : return resultobj;
30706 : fail:
30707 : return NULL;
30708 : }
30709 :
30710 :
30711 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_options_set(PyObject *self, PyObject *args) {
30712 0 : PyObject *resultobj = 0;
30713 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
30714 0 : struct gpgme_conf_opt *arg2 = (struct gpgme_conf_opt *) 0 ;
30715 0 : void *argp1 = 0 ;
30716 0 : int res1 = 0 ;
30717 0 : void *argp2 = 0 ;
30718 0 : int res2 = 0 ;
30719 0 : PyObject * obj1 = 0 ;
30720 :
30721 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_options_set",&obj1)) SWIG_fail;
30722 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30723 0 : if (!SWIG_IsOK(res1)) {
30724 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_options_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
30725 : }
30726 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
30727 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_opt, SWIG_POINTER_DISOWN | 0 );
30728 0 : if (!SWIG_IsOK(res2)) {
30729 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_options_set" "', argument " "2"" of type '" "struct gpgme_conf_opt *""'");
30730 : }
30731 0 : arg2 = (struct gpgme_conf_opt *)(argp2);
30732 0 : if (arg1) (arg1)->options = arg2;
30733 0 : resultobj = SWIG_Py_Void();
30734 0 : return resultobj;
30735 : fail:
30736 : return NULL;
30737 : }
30738 :
30739 :
30740 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_options_get(PyObject *self, PyObject *args) {
30741 0 : PyObject *resultobj = 0;
30742 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
30743 0 : void *argp1 = 0 ;
30744 0 : int res1 = 0 ;
30745 0 : struct gpgme_conf_opt *result = 0 ;
30746 :
30747 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30748 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30749 0 : if (!SWIG_IsOK(res1)) {
30750 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_options_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
30751 : }
30752 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
30753 0 : result = (struct gpgme_conf_opt *) ((arg1)->options);
30754 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30755 0 : return resultobj;
30756 : fail:
30757 : return NULL;
30758 : }
30759 :
30760 :
30761 0 : SWIGINTERN int _wrap_new_gpgme_conf_comp(PyObject *self, PyObject *args) {
30762 0 : PyObject *resultobj = 0;
30763 0 : struct gpgme_conf_comp *result = 0 ;
30764 :
30765 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30766 0 : result = (struct gpgme_conf_comp *)calloc(1, sizeof(struct gpgme_conf_comp));
30767 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_comp, SWIG_BUILTIN_INIT | 0 );
30768 0 : return resultobj == Py_None ? -1 : 0;
30769 : fail:
30770 : return -1;
30771 : }
30772 :
30773 :
30774 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_comp(PyObject *self, PyObject *args) {
30775 0 : PyObject *resultobj = 0;
30776 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
30777 0 : void *argp1 = 0 ;
30778 0 : int res1 = 0 ;
30779 :
30780 0 : if (args && PyTuple_Check(args) && PyTuple_GET_SIZE(args) > 0) SWIG_fail;
30781 0 : res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gpgme_conf_comp, SWIG_POINTER_DISOWN | 0 );
30782 0 : if (!SWIG_IsOK(res1)) {
30783 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_comp" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
30784 : }
30785 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
30786 0 : free((char *) arg1);
30787 0 : resultobj = SWIG_Py_Void();
30788 0 : return resultobj;
30789 : fail:
30790 : return NULL;
30791 : }
30792 :
30793 :
30794 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_new(PyObject *self, PyObject *args) {
30795 0 : PyObject *resultobj = 0;
30796 0 : gpgme_conf_arg_t *arg1 = (gpgme_conf_arg_t *) 0 ;
30797 : gpgme_conf_type_t arg2 ;
30798 0 : void *arg3 = (void *) 0 ;
30799 0 : void *argp1 = 0 ;
30800 0 : int res1 = 0 ;
30801 : int val2 ;
30802 0 : int ecode2 = 0 ;
30803 : int res3 ;
30804 0 : PyObject * obj0 = 0 ;
30805 0 : PyObject * obj1 = 0 ;
30806 0 : PyObject * obj2 = 0 ;
30807 : gpgme_error_t result;
30808 :
30809 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_conf_arg_new",&obj0,&obj1,&obj2)) SWIG_fail;
30810 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_conf_arg, 0 | 0 );
30811 0 : if (!SWIG_IsOK(res1)) {
30812 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_new" "', argument " "1"" of type '" "gpgme_conf_arg_t *""'");
30813 : }
30814 0 : arg1 = (gpgme_conf_arg_t *)(argp1);
30815 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
30816 0 : if (!SWIG_IsOK(ecode2)) {
30817 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_new" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
30818 : }
30819 0 : arg2 = (gpgme_conf_type_t)(val2);
30820 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
30821 0 : if (!SWIG_IsOK(res3)) {
30822 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_conf_arg_new" "', argument " "3"" of type '" "void const *""'");
30823 : }
30824 0 : result = gpgme_conf_arg_new(arg1,arg2,(void const *)arg3);
30825 : {
30826 0 : resultobj = PyLong_FromLong(result);
30827 : }
30828 0 : return resultobj;
30829 : fail:
30830 : return NULL;
30831 : }
30832 :
30833 :
30834 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_release(PyObject *self, PyObject *args) {
30835 0 : PyObject *resultobj = 0;
30836 0 : gpgme_conf_arg_t arg1 = (gpgme_conf_arg_t) 0 ;
30837 : gpgme_conf_type_t arg2 ;
30838 0 : void *argp1 = 0 ;
30839 0 : int res1 = 0 ;
30840 : int val2 ;
30841 0 : int ecode2 = 0 ;
30842 0 : PyObject * obj0 = 0 ;
30843 0 : PyObject * obj1 = 0 ;
30844 :
30845 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_release",&obj0,&obj1)) SWIG_fail;
30846 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
30847 0 : if (!SWIG_IsOK(res1)) {
30848 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_release" "', argument " "1"" of type '" "gpgme_conf_arg_t""'");
30849 : }
30850 0 : arg1 = (gpgme_conf_arg_t)(argp1);
30851 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
30852 0 : if (!SWIG_IsOK(ecode2)) {
30853 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_release" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
30854 : }
30855 0 : arg2 = (gpgme_conf_type_t)(val2);
30856 0 : gpgme_conf_arg_release(arg1,arg2);
30857 0 : resultobj = SWIG_Py_Void();
30858 0 : return resultobj;
30859 : fail:
30860 : return NULL;
30861 : }
30862 :
30863 :
30864 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_change(PyObject *self, PyObject *args) {
30865 0 : PyObject *resultobj = 0;
30866 0 : gpgme_conf_opt_t arg1 = (gpgme_conf_opt_t) 0 ;
30867 : int arg2 ;
30868 0 : gpgme_conf_arg_t arg3 = (gpgme_conf_arg_t) 0 ;
30869 0 : void *argp1 = 0 ;
30870 0 : int res1 = 0 ;
30871 : int val2 ;
30872 0 : int ecode2 = 0 ;
30873 0 : void *argp3 = 0 ;
30874 0 : int res3 = 0 ;
30875 0 : PyObject * obj0 = 0 ;
30876 0 : PyObject * obj1 = 0 ;
30877 0 : PyObject * obj2 = 0 ;
30878 : gpgme_error_t result;
30879 :
30880 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_conf_opt_change",&obj0,&obj1,&obj2)) SWIG_fail;
30881 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
30882 0 : if (!SWIG_IsOK(res1)) {
30883 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_change" "', argument " "1"" of type '" "gpgme_conf_opt_t""'");
30884 : }
30885 0 : arg1 = (gpgme_conf_opt_t)(argp1);
30886 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
30887 0 : if (!SWIG_IsOK(ecode2)) {
30888 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_change" "', argument " "2"" of type '" "int""'");
30889 : }
30890 0 : arg2 = (int)(val2);
30891 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
30892 0 : if (!SWIG_IsOK(res3)) {
30893 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_conf_opt_change" "', argument " "3"" of type '" "gpgme_conf_arg_t""'");
30894 : }
30895 0 : arg3 = (gpgme_conf_arg_t)(argp3);
30896 0 : result = gpgme_conf_opt_change(arg1,arg2,arg3);
30897 : {
30898 0 : resultobj = PyLong_FromLong(result);
30899 : }
30900 0 : return resultobj;
30901 : fail:
30902 : return NULL;
30903 : }
30904 :
30905 :
30906 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_release(PyObject *self, PyObject *args) {
30907 0 : PyObject *resultobj = 0;
30908 0 : gpgme_conf_comp_t arg1 = (gpgme_conf_comp_t) 0 ;
30909 0 : void *argp1 = 0 ;
30910 0 : int res1 = 0 ;
30911 0 : PyObject * obj0 = 0 ;
30912 :
30913 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_release",&obj0)) SWIG_fail;
30914 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30915 0 : if (!SWIG_IsOK(res1)) {
30916 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_release" "', argument " "1"" of type '" "gpgme_conf_comp_t""'");
30917 : }
30918 0 : arg1 = (gpgme_conf_comp_t)(argp1);
30919 0 : gpgme_conf_release(arg1);
30920 0 : resultobj = SWIG_Py_Void();
30921 0 : return resultobj;
30922 : fail:
30923 : return NULL;
30924 : }
30925 :
30926 :
30927 0 : SWIGINTERN PyObject *_wrap_gpgme_op_conf_load(PyObject *self, PyObject *args) {
30928 0 : PyObject *resultobj = 0;
30929 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30930 0 : gpgme_conf_comp_t *arg2 = (gpgme_conf_comp_t *) 0 ;
30931 0 : void *argp1 = 0 ;
30932 0 : int res1 = 0 ;
30933 0 : void *argp2 = 0 ;
30934 0 : int res2 = 0 ;
30935 0 : PyObject * obj0 = 0 ;
30936 0 : PyObject * obj1 = 0 ;
30937 : gpgme_error_t result;
30938 :
30939 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_conf_load",&obj0,&obj1)) SWIG_fail;
30940 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30941 0 : if (!SWIG_IsOK(res1)) {
30942 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_conf_load" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30943 : }
30944 0 : arg1 = (gpgme_ctx_t)(argp1);
30945 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_gpgme_conf_comp, 0 | 0 );
30946 0 : if (!SWIG_IsOK(res2)) {
30947 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_conf_load" "', argument " "2"" of type '" "gpgme_conf_comp_t *""'");
30948 : }
30949 0 : arg2 = (gpgme_conf_comp_t *)(argp2);
30950 0 : result = gpgme_op_conf_load(arg1,arg2);
30951 : {
30952 0 : resultobj = PyLong_FromLong(result);
30953 : }
30954 0 : return resultobj;
30955 : fail:
30956 : return NULL;
30957 : }
30958 :
30959 :
30960 0 : SWIGINTERN PyObject *_wrap_gpgme_op_conf_save(PyObject *self, PyObject *args) {
30961 0 : PyObject *resultobj = 0;
30962 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30963 0 : gpgme_conf_comp_t arg2 = (gpgme_conf_comp_t) 0 ;
30964 0 : void *argp1 = 0 ;
30965 0 : int res1 = 0 ;
30966 0 : void *argp2 = 0 ;
30967 0 : int res2 = 0 ;
30968 0 : PyObject * obj0 = 0 ;
30969 0 : PyObject * obj1 = 0 ;
30970 : gpgme_error_t result;
30971 :
30972 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_conf_save",&obj0,&obj1)) SWIG_fail;
30973 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30974 0 : if (!SWIG_IsOK(res1)) {
30975 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_conf_save" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30976 : }
30977 0 : arg1 = (gpgme_ctx_t)(argp1);
30978 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
30979 0 : if (!SWIG_IsOK(res2)) {
30980 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_conf_save" "', argument " "2"" of type '" "gpgme_conf_comp_t""'");
30981 : }
30982 0 : arg2 = (gpgme_conf_comp_t)(argp2);
30983 0 : result = gpgme_op_conf_save(arg1,arg2);
30984 : {
30985 0 : resultobj = PyLong_FromLong(result);
30986 : }
30987 0 : return resultobj;
30988 : fail:
30989 : return NULL;
30990 : }
30991 :
30992 :
30993 0 : SWIGINTERN PyObject *_wrap_gpgme_set_global_flag(PyObject *self, PyObject *args) {
30994 0 : PyObject *resultobj = 0;
30995 0 : char *arg1 = (char *) 0 ;
30996 0 : char *arg2 = (char *) 0 ;
30997 0 : PyObject * obj0 = 0 ;
30998 0 : PyObject * obj1 = 0 ;
30999 : int result;
31000 :
31001 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_global_flag",&obj0,&obj1)) SWIG_fail;
31002 : {
31003 0 : if (obj0 == Py_None)
31004 : arg1 = NULL;
31005 0 : else if (PyUnicode_Check(obj0))
31006 0 : arg1 = PyUnicode_AsUTF8(obj0);
31007 0 : else if (PyBytes_Check(obj0))
31008 0 : arg1 = PyBytes_AsString(obj0);
31009 : else {
31010 0 : PyErr_Format(PyExc_TypeError,
31011 : "arg %d: expected str, bytes, or None, got %s",
31012 : 1, obj0->ob_type->tp_name);
31013 0 : return NULL;
31014 : }
31015 : }
31016 : {
31017 0 : if (obj1 == Py_None)
31018 : arg2 = NULL;
31019 0 : else if (PyUnicode_Check(obj1))
31020 0 : arg2 = PyUnicode_AsUTF8(obj1);
31021 0 : else if (PyBytes_Check(obj1))
31022 0 : arg2 = PyBytes_AsString(obj1);
31023 : else {
31024 0 : PyErr_Format(PyExc_TypeError,
31025 : "arg %d: expected str, bytes, or None, got %s",
31026 : 2, obj1->ob_type->tp_name);
31027 0 : return NULL;
31028 : }
31029 : }
31030 0 : result = (int)gpgme_set_global_flag((char const *)arg1,(char const *)arg2);
31031 0 : resultobj = SWIG_From_int((int)(result));
31032 0 : return resultobj;
31033 : fail:
31034 : return NULL;
31035 : }
31036 :
31037 :
31038 23 : SWIGINTERN PyObject *_wrap_gpgme_check_version(PyObject *self, PyObject *args) {
31039 23 : PyObject *resultobj = 0;
31040 23 : char *arg1 = (char *) 0 ;
31041 23 : PyObject * obj0 = 0 ;
31042 23 : char *result = 0 ;
31043 :
31044 23 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_check_version",&obj0)) SWIG_fail;
31045 : {
31046 23 : if (obj0 == Py_None)
31047 : arg1 = NULL;
31048 0 : else if (PyUnicode_Check(obj0))
31049 0 : arg1 = PyUnicode_AsUTF8(obj0);
31050 0 : else if (PyBytes_Check(obj0))
31051 0 : arg1 = PyBytes_AsString(obj0);
31052 : else {
31053 0 : PyErr_Format(PyExc_TypeError,
31054 : "arg %d: expected str, bytes, or None, got %s",
31055 : 1, obj0->ob_type->tp_name);
31056 0 : return NULL;
31057 : }
31058 : }
31059 23 : result = (char *)gpgme_check_version((char const *)arg1);
31060 23 : resultobj = SWIG_FromCharPtr((const char *)result);
31061 23 : return resultobj;
31062 : fail:
31063 : return NULL;
31064 : }
31065 :
31066 :
31067 0 : SWIGINTERN PyObject *_wrap_gpgme_check_version_internal(PyObject *self, PyObject *args) {
31068 0 : PyObject *resultobj = 0;
31069 0 : char *arg1 = (char *) 0 ;
31070 : size_t arg2 ;
31071 : size_t val2 ;
31072 0 : int ecode2 = 0 ;
31073 0 : PyObject * obj0 = 0 ;
31074 0 : PyObject * obj1 = 0 ;
31075 0 : char *result = 0 ;
31076 :
31077 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_check_version_internal",&obj0,&obj1)) SWIG_fail;
31078 : {
31079 0 : if (obj0 == Py_None)
31080 : arg1 = NULL;
31081 0 : else if (PyUnicode_Check(obj0))
31082 0 : arg1 = PyUnicode_AsUTF8(obj0);
31083 0 : else if (PyBytes_Check(obj0))
31084 0 : arg1 = PyBytes_AsString(obj0);
31085 : else {
31086 0 : PyErr_Format(PyExc_TypeError,
31087 : "arg %d: expected str, bytes, or None, got %s",
31088 : 1, obj0->ob_type->tp_name);
31089 0 : return NULL;
31090 : }
31091 : }
31092 0 : ecode2 = SWIG_AsVal_size_t(obj1, &val2);
31093 0 : if (!SWIG_IsOK(ecode2)) {
31094 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_check_version_internal" "', argument " "2"" of type '" "size_t""'");
31095 : }
31096 0 : arg2 = (size_t)(val2);
31097 0 : result = (char *)gpgme_check_version_internal((char const *)arg1,arg2);
31098 0 : resultobj = SWIG_FromCharPtr((const char *)result);
31099 0 : return resultobj;
31100 : fail:
31101 : return NULL;
31102 : }
31103 :
31104 :
31105 0 : SWIGINTERN PyObject *_wrap_gpgme_get_dirinfo(PyObject *self, PyObject *args) {
31106 0 : PyObject *resultobj = 0;
31107 0 : char *arg1 = (char *) 0 ;
31108 0 : PyObject * obj0 = 0 ;
31109 0 : char *result = 0 ;
31110 :
31111 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_dirinfo",&obj0)) SWIG_fail;
31112 : {
31113 0 : if (obj0 == Py_None)
31114 : arg1 = NULL;
31115 0 : else if (PyUnicode_Check(obj0))
31116 0 : arg1 = PyUnicode_AsUTF8(obj0);
31117 0 : else if (PyBytes_Check(obj0))
31118 0 : arg1 = PyBytes_AsString(obj0);
31119 : else {
31120 0 : PyErr_Format(PyExc_TypeError,
31121 : "arg %d: expected str, bytes, or None, got %s",
31122 : 1, obj0->ob_type->tp_name);
31123 0 : return NULL;
31124 : }
31125 : }
31126 0 : result = (char *)gpgme_get_dirinfo((char const *)arg1);
31127 0 : resultobj = SWIG_FromCharPtr((const char *)result);
31128 0 : return resultobj;
31129 : fail:
31130 : return NULL;
31131 : }
31132 :
31133 :
31134 0 : SWIGINTERN PyObject *_wrap_gpgme_get_engine_info(PyObject *self, PyObject *args) {
31135 0 : PyObject *resultobj = 0;
31136 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
31137 0 : void *argp1 = 0 ;
31138 0 : int res1 = 0 ;
31139 0 : PyObject * obj0 = 0 ;
31140 : gpgme_error_t result;
31141 :
31142 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_engine_info",&obj0)) SWIG_fail;
31143 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
31144 0 : if (!SWIG_IsOK(res1)) {
31145 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_engine_info" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
31146 : }
31147 0 : arg1 = (gpgme_engine_info_t *)(argp1);
31148 0 : result = gpgme_get_engine_info(arg1);
31149 : {
31150 0 : resultobj = PyLong_FromLong(result);
31151 : }
31152 0 : return resultobj;
31153 : fail:
31154 : return NULL;
31155 : }
31156 :
31157 :
31158 0 : SWIGINTERN PyObject *_wrap_gpgme_set_engine_info(PyObject *self, PyObject *args) {
31159 0 : PyObject *resultobj = 0;
31160 : gpgme_protocol_t arg1 ;
31161 0 : char *arg2 = (char *) 0 ;
31162 0 : char *arg3 = (char *) 0 ;
31163 : int val1 ;
31164 0 : int ecode1 = 0 ;
31165 0 : PyObject * obj0 = 0 ;
31166 0 : PyObject * obj1 = 0 ;
31167 0 : PyObject * obj2 = 0 ;
31168 : gpgme_error_t result;
31169 :
31170 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_engine_info",&obj0,&obj1,&obj2)) SWIG_fail;
31171 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
31172 0 : if (!SWIG_IsOK(ecode1)) {
31173 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_set_engine_info" "', argument " "1"" of type '" "gpgme_protocol_t""'");
31174 : }
31175 0 : arg1 = (gpgme_protocol_t)(val1);
31176 : {
31177 0 : if (obj1 == Py_None)
31178 : arg2 = NULL;
31179 0 : else if (PyUnicode_Check(obj1))
31180 0 : arg2 = PyUnicode_AsUTF8(obj1);
31181 0 : else if (PyBytes_Check(obj1))
31182 0 : arg2 = PyBytes_AsString(obj1);
31183 : else {
31184 0 : PyErr_Format(PyExc_TypeError,
31185 : "arg %d: expected str, bytes, or None, got %s",
31186 : 2, obj1->ob_type->tp_name);
31187 0 : return NULL;
31188 : }
31189 : }
31190 : {
31191 0 : if (obj2 == Py_None)
31192 : arg3 = NULL;
31193 0 : else if (PyUnicode_Check(obj2))
31194 0 : arg3 = PyUnicode_AsUTF8(obj2);
31195 0 : else if (PyBytes_Check(obj2))
31196 0 : arg3 = PyBytes_AsString(obj2);
31197 : else {
31198 0 : PyErr_Format(PyExc_TypeError,
31199 : "arg %d: expected str, bytes, or None, got %s",
31200 : 3, obj2->ob_type->tp_name);
31201 0 : return NULL;
31202 : }
31203 : }
31204 0 : result = gpgme_set_engine_info(arg1,(char const *)arg2,(char const *)arg3);
31205 : {
31206 0 : resultobj = PyLong_FromLong(result);
31207 : }
31208 0 : return resultobj;
31209 : fail:
31210 : return NULL;
31211 : }
31212 :
31213 :
31214 62 : SWIGINTERN PyObject *_wrap_gpgme_engine_check_version(PyObject *self, PyObject *args) {
31215 62 : PyObject *resultobj = 0;
31216 : gpgme_protocol_t arg1 ;
31217 : int val1 ;
31218 62 : int ecode1 = 0 ;
31219 62 : PyObject * obj0 = 0 ;
31220 : gpgme_error_t result;
31221 :
31222 62 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_engine_check_version",&obj0)) SWIG_fail;
31223 62 : ecode1 = SWIG_AsVal_int(obj0, &val1);
31224 62 : if (!SWIG_IsOK(ecode1)) {
31225 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_engine_check_version" "', argument " "1"" of type '" "gpgme_protocol_t""'");
31226 : }
31227 62 : arg1 = (gpgme_protocol_t)(val1);
31228 62 : result = gpgme_engine_check_version(arg1);
31229 : {
31230 62 : resultobj = PyLong_FromLong(result);
31231 : }
31232 62 : return resultobj;
31233 : fail:
31234 : return NULL;
31235 : }
31236 :
31237 :
31238 0 : SWIGINTERN PyObject *_wrap_gpgme_result_ref(PyObject *self, PyObject *args) {
31239 0 : PyObject *resultobj = 0;
31240 0 : void *arg1 = (void *) 0 ;
31241 : int res1 ;
31242 0 : PyObject * obj0 = 0 ;
31243 :
31244 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_result_ref",&obj0)) SWIG_fail;
31245 0 : res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
31246 0 : if (!SWIG_IsOK(res1)) {
31247 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_result_ref" "', argument " "1"" of type '" "void *""'");
31248 : }
31249 0 : gpgme_result_ref(arg1);
31250 0 : resultobj = SWIG_Py_Void();
31251 0 : return resultobj;
31252 : fail:
31253 : return NULL;
31254 : }
31255 :
31256 :
31257 0 : SWIGINTERN PyObject *_wrap_gpgme_result_unref(PyObject *self, PyObject *args) {
31258 0 : PyObject *resultobj = 0;
31259 0 : void *arg1 = (void *) 0 ;
31260 : int res1 ;
31261 0 : PyObject * obj0 = 0 ;
31262 :
31263 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_result_unref",&obj0)) SWIG_fail;
31264 0 : res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
31265 0 : if (!SWIG_IsOK(res1)) {
31266 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_result_unref" "', argument " "1"" of type '" "void *""'");
31267 : }
31268 0 : gpgme_result_unref(arg1);
31269 0 : resultobj = SWIG_Py_Void();
31270 0 : return resultobj;
31271 : fail:
31272 : return NULL;
31273 : }
31274 :
31275 :
31276 0 : SWIGINTERN PyObject *_wrap_gpgme_pubkey_algo_string(PyObject *self, PyObject *args) {
31277 0 : PyObject *resultobj = 0;
31278 0 : gpgme_subkey_t arg1 = (gpgme_subkey_t) 0 ;
31279 0 : void *argp1 = 0 ;
31280 0 : int res1 = 0 ;
31281 0 : PyObject * obj0 = 0 ;
31282 0 : char *result = 0 ;
31283 :
31284 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_pubkey_algo_string",&obj0)) SWIG_fail;
31285 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
31286 0 : if (!SWIG_IsOK(res1)) {
31287 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_pubkey_algo_string" "', argument " "1"" of type '" "gpgme_subkey_t""'");
31288 : }
31289 0 : arg1 = (gpgme_subkey_t)(argp1);
31290 0 : result = (char *)gpgme_pubkey_algo_string(arg1);
31291 0 : resultobj = SWIG_FromCharPtr((const char *)result);
31292 0 : return resultobj;
31293 : fail:
31294 : return NULL;
31295 : }
31296 :
31297 :
31298 0 : SWIGINTERN PyObject *_wrap_gpgme_pubkey_algo_name(PyObject *self, PyObject *args) {
31299 0 : PyObject *resultobj = 0;
31300 : gpgme_pubkey_algo_t arg1 ;
31301 : int val1 ;
31302 0 : int ecode1 = 0 ;
31303 0 : PyObject * obj0 = 0 ;
31304 0 : char *result = 0 ;
31305 :
31306 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_pubkey_algo_name",&obj0)) SWIG_fail;
31307 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
31308 0 : if (!SWIG_IsOK(ecode1)) {
31309 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_pubkey_algo_name" "', argument " "1"" of type '" "gpgme_pubkey_algo_t""'");
31310 : }
31311 0 : arg1 = (gpgme_pubkey_algo_t)(val1);
31312 0 : result = (char *)gpgme_pubkey_algo_name(arg1);
31313 0 : resultobj = SWIG_FromCharPtr((const char *)result);
31314 0 : return resultobj;
31315 : fail:
31316 : return NULL;
31317 : }
31318 :
31319 :
31320 0 : SWIGINTERN PyObject *_wrap_gpgme_hash_algo_name(PyObject *self, PyObject *args) {
31321 0 : PyObject *resultobj = 0;
31322 : gpgme_hash_algo_t arg1 ;
31323 : int val1 ;
31324 0 : int ecode1 = 0 ;
31325 0 : PyObject * obj0 = 0 ;
31326 0 : char *result = 0 ;
31327 :
31328 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_hash_algo_name",&obj0)) SWIG_fail;
31329 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
31330 0 : if (!SWIG_IsOK(ecode1)) {
31331 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_hash_algo_name" "', argument " "1"" of type '" "gpgme_hash_algo_t""'");
31332 : }
31333 0 : arg1 = (gpgme_hash_algo_t)(val1);
31334 0 : result = (char *)gpgme_hash_algo_name(arg1);
31335 0 : resultobj = SWIG_FromCharPtr((const char *)result);
31336 0 : return resultobj;
31337 : fail:
31338 : return NULL;
31339 : }
31340 :
31341 :
31342 42 : SWIGINTERN PyObject *_wrap_new_gpgme_ctx_t_p(PyObject *self, PyObject *args) {
31343 42 : PyObject *resultobj = 0;
31344 42 : gpgme_ctx_t *result = 0 ;
31345 :
31346 42 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_ctx_t_p")) SWIG_fail;
31347 42 : result = (gpgme_ctx_t *)new_gpgme_ctx_t_p();
31348 42 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_context, 0 | 0 );
31349 42 : return resultobj;
31350 : fail:
31351 : return NULL;
31352 : }
31353 :
31354 :
31355 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_ctx_t_p(PyObject *self, PyObject *args) {
31356 0 : PyObject *resultobj = 0;
31357 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
31358 0 : void *argp1 = 0 ;
31359 0 : int res1 = 0 ;
31360 0 : PyObject * obj0 = 0 ;
31361 0 : gpgme_ctx_t *result = 0 ;
31362 :
31363 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_ctx_t_p",&obj0)) SWIG_fail;
31364 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
31365 0 : if (!SWIG_IsOK(res1)) {
31366 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_ctx_t_p" "', argument " "1"" of type '" "gpgme_ctx_t""'");
31367 : }
31368 0 : arg1 = (gpgme_ctx_t)(argp1);
31369 0 : result = (gpgme_ctx_t *)copy_gpgme_ctx_t_p(arg1);
31370 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_context, 0 | 0 );
31371 0 : return resultobj;
31372 : fail:
31373 : return NULL;
31374 : }
31375 :
31376 :
31377 42 : SWIGINTERN PyObject *_wrap_delete_gpgme_ctx_t_p(PyObject *self, PyObject *args) {
31378 42 : PyObject *resultobj = 0;
31379 42 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
31380 42 : void *argp1 = 0 ;
31381 42 : int res1 = 0 ;
31382 42 : PyObject * obj0 = 0 ;
31383 :
31384 42 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_ctx_t_p",&obj0)) SWIG_fail;
31385 42 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
31386 42 : if (!SWIG_IsOK(res1)) {
31387 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_ctx_t_p" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
31388 : }
31389 42 : arg1 = (gpgme_ctx_t *)(argp1);
31390 : delete_gpgme_ctx_t_p(arg1);
31391 42 : resultobj = SWIG_Py_Void();
31392 42 : return resultobj;
31393 : fail:
31394 : return NULL;
31395 : }
31396 :
31397 :
31398 0 : SWIGINTERN PyObject *_wrap_gpgme_ctx_t_p_assign(PyObject *self, PyObject *args) {
31399 0 : PyObject *resultobj = 0;
31400 0 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
31401 0 : gpgme_ctx_t arg2 = (gpgme_ctx_t) 0 ;
31402 0 : void *argp1 = 0 ;
31403 0 : int res1 = 0 ;
31404 0 : void *argp2 = 0 ;
31405 0 : int res2 = 0 ;
31406 0 : PyObject * obj0 = 0 ;
31407 0 : PyObject * obj1 = 0 ;
31408 :
31409 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_ctx_t_p_assign",&obj0,&obj1)) SWIG_fail;
31410 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
31411 0 : if (!SWIG_IsOK(res1)) {
31412 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_t_p_assign" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
31413 : }
31414 0 : arg1 = (gpgme_ctx_t *)(argp1);
31415 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_context, 0 | 0 );
31416 0 : if (!SWIG_IsOK(res2)) {
31417 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_ctx_t_p_assign" "', argument " "2"" of type '" "gpgme_ctx_t""'");
31418 : }
31419 0 : arg2 = (gpgme_ctx_t)(argp2);
31420 : gpgme_ctx_t_p_assign(arg1,arg2);
31421 0 : resultobj = SWIG_Py_Void();
31422 0 : return resultobj;
31423 : fail:
31424 : return NULL;
31425 : }
31426 :
31427 :
31428 42 : SWIGINTERN PyObject *_wrap_gpgme_ctx_t_p_value(PyObject *self, PyObject *args) {
31429 42 : PyObject *resultobj = 0;
31430 42 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
31431 42 : void *argp1 = 0 ;
31432 42 : int res1 = 0 ;
31433 42 : PyObject * obj0 = 0 ;
31434 : gpgme_ctx_t result;
31435 :
31436 42 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_ctx_t_p_value",&obj0)) SWIG_fail;
31437 42 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
31438 42 : if (!SWIG_IsOK(res1)) {
31439 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_t_p_value" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
31440 : }
31441 42 : arg1 = (gpgme_ctx_t *)(argp1);
31442 42 : result = (gpgme_ctx_t)gpgme_ctx_t_p_value(arg1);
31443 42 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_context, 0 | 0 );
31444 42 : return resultobj;
31445 : fail:
31446 : return NULL;
31447 : }
31448 :
31449 :
31450 103 : SWIGINTERN PyObject *_wrap_new_gpgme_data_t_p(PyObject *self, PyObject *args) {
31451 103 : PyObject *resultobj = 0;
31452 103 : gpgme_data_t *result = 0 ;
31453 :
31454 103 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_data_t_p")) SWIG_fail;
31455 103 : result = (gpgme_data_t *)new_gpgme_data_t_p();
31456 103 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_data, 0 | 0 );
31457 103 : return resultobj;
31458 : fail:
31459 : return NULL;
31460 : }
31461 :
31462 :
31463 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_data_t_p(PyObject *self, PyObject *args) {
31464 0 : PyObject *resultobj = 0;
31465 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
31466 0 : void *argp1 = 0 ;
31467 0 : int res1 = 0 ;
31468 0 : PyObject * obj0 = 0 ;
31469 0 : gpgme_data_t *result = 0 ;
31470 :
31471 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_data_t_p",&obj0)) SWIG_fail;
31472 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
31473 0 : if (!SWIG_IsOK(res1)) {
31474 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_data_t_p" "', argument " "1"" of type '" "gpgme_data_t""'");
31475 : }
31476 0 : arg1 = (gpgme_data_t)(argp1);
31477 0 : result = (gpgme_data_t *)copy_gpgme_data_t_p(arg1);
31478 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_data, 0 | 0 );
31479 0 : return resultobj;
31480 : fail:
31481 : return NULL;
31482 : }
31483 :
31484 :
31485 103 : SWIGINTERN PyObject *_wrap_delete_gpgme_data_t_p(PyObject *self, PyObject *args) {
31486 103 : PyObject *resultobj = 0;
31487 103 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
31488 103 : void *argp1 = 0 ;
31489 103 : int res1 = 0 ;
31490 103 : PyObject * obj0 = 0 ;
31491 :
31492 103 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_data_t_p",&obj0)) SWIG_fail;
31493 103 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
31494 103 : if (!SWIG_IsOK(res1)) {
31495 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_data_t_p" "', argument " "1"" of type '" "gpgme_data_t *""'");
31496 : }
31497 103 : arg1 = (gpgme_data_t *)(argp1);
31498 : delete_gpgme_data_t_p(arg1);
31499 103 : resultobj = SWIG_Py_Void();
31500 103 : return resultobj;
31501 : fail:
31502 : return NULL;
31503 : }
31504 :
31505 :
31506 0 : SWIGINTERN PyObject *_wrap_gpgme_data_t_p_assign(PyObject *self, PyObject *args) {
31507 0 : PyObject *resultobj = 0;
31508 0 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
31509 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
31510 0 : void *argp1 = 0 ;
31511 0 : int res1 = 0 ;
31512 0 : void *argp2 = 0 ;
31513 0 : int res2 = 0 ;
31514 0 : PyObject * obj0 = 0 ;
31515 0 : PyObject * obj1 = 0 ;
31516 :
31517 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_t_p_assign",&obj0,&obj1)) SWIG_fail;
31518 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
31519 0 : if (!SWIG_IsOK(res1)) {
31520 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_t_p_assign" "', argument " "1"" of type '" "gpgme_data_t *""'");
31521 : }
31522 0 : arg1 = (gpgme_data_t *)(argp1);
31523 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data, 0 | 0 );
31524 0 : if (!SWIG_IsOK(res2)) {
31525 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_t_p_assign" "', argument " "2"" of type '" "gpgme_data_t""'");
31526 : }
31527 0 : arg2 = (gpgme_data_t)(argp2);
31528 : gpgme_data_t_p_assign(arg1,arg2);
31529 0 : resultobj = SWIG_Py_Void();
31530 0 : return resultobj;
31531 : fail:
31532 : return NULL;
31533 : }
31534 :
31535 :
31536 103 : SWIGINTERN PyObject *_wrap_gpgme_data_t_p_value(PyObject *self, PyObject *args) {
31537 103 : PyObject *resultobj = 0;
31538 103 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
31539 103 : void *argp1 = 0 ;
31540 103 : int res1 = 0 ;
31541 103 : PyObject * obj0 = 0 ;
31542 : gpgme_data_t result;
31543 :
31544 103 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_t_p_value",&obj0)) SWIG_fail;
31545 103 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
31546 103 : if (!SWIG_IsOK(res1)) {
31547 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_t_p_value" "', argument " "1"" of type '" "gpgme_data_t *""'");
31548 : }
31549 103 : arg1 = (gpgme_data_t *)(argp1);
31550 103 : result = (gpgme_data_t)gpgme_data_t_p_value(arg1);
31551 103 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_data, 0 | 0 );
31552 103 : return resultobj;
31553 : fail:
31554 : return NULL;
31555 : }
31556 :
31557 :
31558 79 : SWIGINTERN PyObject *_wrap_new_gpgme_key_t_p(PyObject *self, PyObject *args) {
31559 79 : PyObject *resultobj = 0;
31560 79 : gpgme_key_t *result = 0 ;
31561 :
31562 79 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_key_t_p")) SWIG_fail;
31563 79 : result = (gpgme_key_t *)new_gpgme_key_t_p();
31564 79 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_key, 0 | 0 );
31565 79 : return resultobj;
31566 : fail:
31567 : return NULL;
31568 : }
31569 :
31570 :
31571 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_key_t_p(PyObject *self, PyObject *args) {
31572 0 : PyObject *resultobj = 0;
31573 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
31574 0 : void *argp1 = 0 ;
31575 0 : int res1 = 0 ;
31576 0 : PyObject * obj0 = 0 ;
31577 0 : gpgme_key_t *result = 0 ;
31578 :
31579 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_key_t_p",&obj0)) SWIG_fail;
31580 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
31581 0 : if (!SWIG_IsOK(res1)) {
31582 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_key_t_p" "', argument " "1"" of type '" "gpgme_key_t""'");
31583 : }
31584 0 : arg1 = (gpgme_key_t)(argp1);
31585 0 : result = (gpgme_key_t *)copy_gpgme_key_t_p(arg1);
31586 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_key, 0 | 0 );
31587 0 : return resultobj;
31588 : fail:
31589 : return NULL;
31590 : }
31591 :
31592 :
31593 79 : SWIGINTERN PyObject *_wrap_delete_gpgme_key_t_p(PyObject *self, PyObject *args) {
31594 79 : PyObject *resultobj = 0;
31595 79 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
31596 79 : void *argp1 = 0 ;
31597 79 : int res1 = 0 ;
31598 79 : PyObject * obj0 = 0 ;
31599 :
31600 79 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_key_t_p",&obj0)) SWIG_fail;
31601 79 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
31602 79 : if (!SWIG_IsOK(res1)) {
31603 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_key_t_p" "', argument " "1"" of type '" "gpgme_key_t *""'");
31604 : }
31605 79 : arg1 = (gpgme_key_t *)(argp1);
31606 : delete_gpgme_key_t_p(arg1);
31607 79 : resultobj = SWIG_Py_Void();
31608 79 : return resultobj;
31609 : fail:
31610 : return NULL;
31611 : }
31612 :
31613 :
31614 0 : SWIGINTERN PyObject *_wrap_gpgme_key_t_p_assign(PyObject *self, PyObject *args) {
31615 0 : PyObject *resultobj = 0;
31616 0 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
31617 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
31618 0 : void *argp1 = 0 ;
31619 0 : int res1 = 0 ;
31620 0 : void *argp2 = 0 ;
31621 0 : int res2 = 0 ;
31622 0 : PyObject * obj0 = 0 ;
31623 0 : PyObject * obj1 = 0 ;
31624 :
31625 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_key_t_p_assign",&obj0,&obj1)) SWIG_fail;
31626 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
31627 0 : if (!SWIG_IsOK(res1)) {
31628 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_t_p_assign" "', argument " "1"" of type '" "gpgme_key_t *""'");
31629 : }
31630 0 : arg1 = (gpgme_key_t *)(argp1);
31631 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
31632 0 : if (!SWIG_IsOK(res2)) {
31633 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_key_t_p_assign" "', argument " "2"" of type '" "gpgme_key_t""'");
31634 : }
31635 0 : arg2 = (gpgme_key_t)(argp2);
31636 : gpgme_key_t_p_assign(arg1,arg2);
31637 0 : resultobj = SWIG_Py_Void();
31638 0 : return resultobj;
31639 : fail:
31640 : return NULL;
31641 : }
31642 :
31643 :
31644 79 : SWIGINTERN PyObject *_wrap_gpgme_key_t_p_value(PyObject *self, PyObject *args) {
31645 79 : PyObject *resultobj = 0;
31646 79 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
31647 79 : void *argp1 = 0 ;
31648 79 : int res1 = 0 ;
31649 79 : PyObject * obj0 = 0 ;
31650 : gpgme_key_t result;
31651 :
31652 79 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_t_p_value",&obj0)) SWIG_fail;
31653 79 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
31654 79 : if (!SWIG_IsOK(res1)) {
31655 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_t_p_value" "', argument " "1"" of type '" "gpgme_key_t *""'");
31656 : }
31657 79 : arg1 = (gpgme_key_t *)(argp1);
31658 79 : result = (gpgme_key_t)gpgme_key_t_p_value(arg1);
31659 79 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, 0 | 0 );
31660 79 : return resultobj;
31661 : fail:
31662 : return NULL;
31663 : }
31664 :
31665 :
31666 11 : SWIGINTERN PyObject *_wrap_new_gpgme_error_t_p(PyObject *self, PyObject *args) {
31667 11 : PyObject *resultobj = 0;
31668 11 : gpgme_error_t *result = 0 ;
31669 :
31670 11 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_error_t_p")) SWIG_fail;
31671 11 : result = (gpgme_error_t *)new_gpgme_error_t_p();
31672 11 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpg_error_t, 0 | 0 );
31673 11 : return resultobj;
31674 : fail:
31675 : return NULL;
31676 : }
31677 :
31678 :
31679 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_error_t_p(PyObject *self, PyObject *args) {
31680 0 : PyObject *resultobj = 0;
31681 : gpgme_error_t arg1 ;
31682 0 : PyObject * obj0 = 0 ;
31683 0 : gpgme_error_t *result = 0 ;
31684 :
31685 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_error_t_p",&obj0)) SWIG_fail;
31686 : {
31687 0 : arg1 = PyLong_AsLong(obj0);
31688 : }
31689 0 : result = (gpgme_error_t *)copy_gpgme_error_t_p(arg1);
31690 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpg_error_t, 0 | 0 );
31691 0 : return resultobj;
31692 : fail:
31693 : return NULL;
31694 : }
31695 :
31696 :
31697 11 : SWIGINTERN PyObject *_wrap_delete_gpgme_error_t_p(PyObject *self, PyObject *args) {
31698 11 : PyObject *resultobj = 0;
31699 11 : gpgme_error_t *arg1 = (gpgme_error_t *) 0 ;
31700 11 : void *argp1 = 0 ;
31701 11 : int res1 = 0 ;
31702 11 : PyObject * obj0 = 0 ;
31703 :
31704 11 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_error_t_p",&obj0)) SWIG_fail;
31705 11 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpg_error_t, 0 | 0 );
31706 11 : if (!SWIG_IsOK(res1)) {
31707 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_error_t_p" "', argument " "1"" of type '" "gpgme_error_t *""'");
31708 : }
31709 11 : arg1 = (gpgme_error_t *)(argp1);
31710 : delete_gpgme_error_t_p(arg1);
31711 11 : resultobj = SWIG_Py_Void();
31712 11 : return resultobj;
31713 : fail:
31714 : return NULL;
31715 : }
31716 :
31717 :
31718 0 : SWIGINTERN PyObject *_wrap_gpgme_error_t_p_assign(PyObject *self, PyObject *args) {
31719 0 : PyObject *resultobj = 0;
31720 0 : gpgme_error_t *arg1 = (gpgme_error_t *) 0 ;
31721 : gpgme_error_t arg2 ;
31722 0 : void *argp1 = 0 ;
31723 0 : int res1 = 0 ;
31724 0 : PyObject * obj0 = 0 ;
31725 0 : PyObject * obj1 = 0 ;
31726 :
31727 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_error_t_p_assign",&obj0,&obj1)) SWIG_fail;
31728 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpg_error_t, 0 | 0 );
31729 0 : if (!SWIG_IsOK(res1)) {
31730 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_error_t_p_assign" "', argument " "1"" of type '" "gpgme_error_t *""'");
31731 : }
31732 0 : arg1 = (gpgme_error_t *)(argp1);
31733 : {
31734 0 : arg2 = PyLong_AsLong(obj1);
31735 : }
31736 : gpgme_error_t_p_assign(arg1,arg2);
31737 0 : resultobj = SWIG_Py_Void();
31738 0 : return resultobj;
31739 : fail:
31740 : return NULL;
31741 : }
31742 :
31743 :
31744 11 : SWIGINTERN PyObject *_wrap_gpgme_error_t_p_value(PyObject *self, PyObject *args) {
31745 11 : PyObject *resultobj = 0;
31746 11 : gpgme_error_t *arg1 = (gpgme_error_t *) 0 ;
31747 11 : void *argp1 = 0 ;
31748 11 : int res1 = 0 ;
31749 11 : PyObject * obj0 = 0 ;
31750 : gpgme_error_t result;
31751 :
31752 11 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_error_t_p_value",&obj0)) SWIG_fail;
31753 11 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpg_error_t, 0 | 0 );
31754 11 : if (!SWIG_IsOK(res1)) {
31755 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_error_t_p_value" "', argument " "1"" of type '" "gpgme_error_t *""'");
31756 : }
31757 11 : arg1 = (gpgme_error_t *)(argp1);
31758 11 : result = gpgme_error_t_p_value(arg1);
31759 : {
31760 11 : resultobj = PyLong_FromLong(result);
31761 : }
31762 11 : return resultobj;
31763 : fail:
31764 : return NULL;
31765 : }
31766 :
31767 :
31768 2 : SWIGINTERN PyObject *_wrap_new_gpgme_trust_item_t_p(PyObject *self, PyObject *args) {
31769 2 : PyObject *resultobj = 0;
31770 2 : gpgme_trust_item_t *result = 0 ;
31771 :
31772 2 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_trust_item_t_p")) SWIG_fail;
31773 2 : result = (gpgme_trust_item_t *)new_gpgme_trust_item_t_p();
31774 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
31775 2 : return resultobj;
31776 : fail:
31777 : return NULL;
31778 : }
31779 :
31780 :
31781 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_trust_item_t_p(PyObject *self, PyObject *args) {
31782 0 : PyObject *resultobj = 0;
31783 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
31784 0 : void *argp1 = 0 ;
31785 0 : int res1 = 0 ;
31786 0 : PyObject * obj0 = 0 ;
31787 0 : gpgme_trust_item_t *result = 0 ;
31788 :
31789 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_trust_item_t_p",&obj0)) SWIG_fail;
31790 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
31791 0 : if (!SWIG_IsOK(res1)) {
31792 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_trust_item_t_p" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
31793 : }
31794 0 : arg1 = (gpgme_trust_item_t)(argp1);
31795 0 : result = (gpgme_trust_item_t *)copy_gpgme_trust_item_t_p(arg1);
31796 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
31797 0 : return resultobj;
31798 : fail:
31799 : return NULL;
31800 : }
31801 :
31802 :
31803 2 : SWIGINTERN PyObject *_wrap_delete_gpgme_trust_item_t_p(PyObject *self, PyObject *args) {
31804 2 : PyObject *resultobj = 0;
31805 2 : gpgme_trust_item_t *arg1 = (gpgme_trust_item_t *) 0 ;
31806 2 : void *argp1 = 0 ;
31807 2 : int res1 = 0 ;
31808 2 : PyObject * obj0 = 0 ;
31809 :
31810 2 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_trust_item_t_p",&obj0)) SWIG_fail;
31811 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
31812 2 : if (!SWIG_IsOK(res1)) {
31813 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_trust_item_t_p" "', argument " "1"" of type '" "gpgme_trust_item_t *""'");
31814 : }
31815 2 : arg1 = (gpgme_trust_item_t *)(argp1);
31816 : delete_gpgme_trust_item_t_p(arg1);
31817 2 : resultobj = SWIG_Py_Void();
31818 2 : return resultobj;
31819 : fail:
31820 : return NULL;
31821 : }
31822 :
31823 :
31824 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_t_p_assign(PyObject *self, PyObject *args) {
31825 0 : PyObject *resultobj = 0;
31826 0 : gpgme_trust_item_t *arg1 = (gpgme_trust_item_t *) 0 ;
31827 0 : gpgme_trust_item_t arg2 = (gpgme_trust_item_t) 0 ;
31828 0 : void *argp1 = 0 ;
31829 0 : int res1 = 0 ;
31830 0 : void *argp2 = 0 ;
31831 0 : int res2 = 0 ;
31832 0 : PyObject * obj0 = 0 ;
31833 0 : PyObject * obj1 = 0 ;
31834 :
31835 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_trust_item_t_p_assign",&obj0,&obj1)) SWIG_fail;
31836 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
31837 0 : if (!SWIG_IsOK(res1)) {
31838 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_t_p_assign" "', argument " "1"" of type '" "gpgme_trust_item_t *""'");
31839 : }
31840 0 : arg1 = (gpgme_trust_item_t *)(argp1);
31841 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
31842 0 : if (!SWIG_IsOK(res2)) {
31843 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_trust_item_t_p_assign" "', argument " "2"" of type '" "gpgme_trust_item_t""'");
31844 : }
31845 0 : arg2 = (gpgme_trust_item_t)(argp2);
31846 : gpgme_trust_item_t_p_assign(arg1,arg2);
31847 0 : resultobj = SWIG_Py_Void();
31848 0 : return resultobj;
31849 : fail:
31850 : return NULL;
31851 : }
31852 :
31853 :
31854 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_t_p_value(PyObject *self, PyObject *args) {
31855 0 : PyObject *resultobj = 0;
31856 0 : gpgme_trust_item_t *arg1 = (gpgme_trust_item_t *) 0 ;
31857 0 : void *argp1 = 0 ;
31858 0 : int res1 = 0 ;
31859 0 : PyObject * obj0 = 0 ;
31860 : gpgme_trust_item_t result;
31861 :
31862 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_trust_item_t_p_value",&obj0)) SWIG_fail;
31863 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
31864 0 : if (!SWIG_IsOK(res1)) {
31865 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_t_p_value" "', argument " "1"" of type '" "gpgme_trust_item_t *""'");
31866 : }
31867 0 : arg1 = (gpgme_trust_item_t *)(argp1);
31868 0 : result = (gpgme_trust_item_t)gpgme_trust_item_t_p_value(arg1);
31869 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
31870 0 : return resultobj;
31871 : fail:
31872 : return NULL;
31873 : }
31874 :
31875 :
31876 0 : SWIGINTERN PyObject *_wrap_new_gpgme_engine_info_t_p(PyObject *self, PyObject *args) {
31877 0 : PyObject *resultobj = 0;
31878 0 : gpgme_engine_info_t *result = 0 ;
31879 :
31880 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_engine_info_t_p")) SWIG_fail;
31881 0 : result = (gpgme_engine_info_t *)new_gpgme_engine_info_t_p();
31882 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
31883 0 : return resultobj;
31884 : fail:
31885 : return NULL;
31886 : }
31887 :
31888 :
31889 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_engine_info_t_p(PyObject *self, PyObject *args) {
31890 0 : PyObject *resultobj = 0;
31891 0 : gpgme_engine_info_t arg1 = (gpgme_engine_info_t) 0 ;
31892 0 : void *argp1 = 0 ;
31893 0 : int res1 = 0 ;
31894 0 : PyObject * obj0 = 0 ;
31895 0 : gpgme_engine_info_t *result = 0 ;
31896 :
31897 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_engine_info_t_p",&obj0)) SWIG_fail;
31898 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
31899 0 : if (!SWIG_IsOK(res1)) {
31900 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_engine_info_t_p" "', argument " "1"" of type '" "gpgme_engine_info_t""'");
31901 : }
31902 0 : arg1 = (gpgme_engine_info_t)(argp1);
31903 0 : result = (gpgme_engine_info_t *)copy_gpgme_engine_info_t_p(arg1);
31904 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
31905 0 : return resultobj;
31906 : fail:
31907 : return NULL;
31908 : }
31909 :
31910 :
31911 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_engine_info_t_p(PyObject *self, PyObject *args) {
31912 0 : PyObject *resultobj = 0;
31913 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
31914 0 : void *argp1 = 0 ;
31915 0 : int res1 = 0 ;
31916 0 : PyObject * obj0 = 0 ;
31917 :
31918 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_engine_info_t_p",&obj0)) SWIG_fail;
31919 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
31920 0 : if (!SWIG_IsOK(res1)) {
31921 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_engine_info_t_p" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
31922 : }
31923 0 : arg1 = (gpgme_engine_info_t *)(argp1);
31924 : delete_gpgme_engine_info_t_p(arg1);
31925 0 : resultobj = SWIG_Py_Void();
31926 0 : return resultobj;
31927 : fail:
31928 : return NULL;
31929 : }
31930 :
31931 :
31932 0 : SWIGINTERN PyObject *_wrap_gpgme_engine_info_t_p_assign(PyObject *self, PyObject *args) {
31933 0 : PyObject *resultobj = 0;
31934 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
31935 0 : gpgme_engine_info_t arg2 = (gpgme_engine_info_t) 0 ;
31936 0 : void *argp1 = 0 ;
31937 0 : int res1 = 0 ;
31938 0 : void *argp2 = 0 ;
31939 0 : int res2 = 0 ;
31940 0 : PyObject * obj0 = 0 ;
31941 0 : PyObject * obj1 = 0 ;
31942 :
31943 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_engine_info_t_p_assign",&obj0,&obj1)) SWIG_fail;
31944 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
31945 0 : if (!SWIG_IsOK(res1)) {
31946 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_engine_info_t_p_assign" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
31947 : }
31948 0 : arg1 = (gpgme_engine_info_t *)(argp1);
31949 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
31950 0 : if (!SWIG_IsOK(res2)) {
31951 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_engine_info_t_p_assign" "', argument " "2"" of type '" "gpgme_engine_info_t""'");
31952 : }
31953 0 : arg2 = (gpgme_engine_info_t)(argp2);
31954 : gpgme_engine_info_t_p_assign(arg1,arg2);
31955 0 : resultobj = SWIG_Py_Void();
31956 0 : return resultobj;
31957 : fail:
31958 : return NULL;
31959 : }
31960 :
31961 :
31962 0 : SWIGINTERN PyObject *_wrap_gpgme_engine_info_t_p_value(PyObject *self, PyObject *args) {
31963 0 : PyObject *resultobj = 0;
31964 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
31965 0 : void *argp1 = 0 ;
31966 0 : int res1 = 0 ;
31967 0 : PyObject * obj0 = 0 ;
31968 : gpgme_engine_info_t result;
31969 :
31970 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_engine_info_t_p_value",&obj0)) SWIG_fail;
31971 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
31972 0 : if (!SWIG_IsOK(res1)) {
31973 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_engine_info_t_p_value" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
31974 : }
31975 0 : arg1 = (gpgme_engine_info_t *)(argp1);
31976 0 : result = (gpgme_engine_info_t)gpgme_engine_info_t_p_value(arg1);
31977 : {
31978 : int i;
31979 0 : int size = 0;
31980 : gpgme_engine_info_t curr;
31981 0 : for (curr = result; curr != NULL; curr = curr->next) {
31982 0 : size++;
31983 : }
31984 0 : resultobj = PyList_New(size);
31985 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
31986 : PyObject *fragile, *o;
31987 0 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_engine_info,
31988 : 0 );
31989 0 : o = _pyme_wrap_result(fragile, "EngineInfo");
31990 0 : if (o == NULL)
31991 : return NULL; /* raise */
31992 0 : Py_DECREF(fragile);
31993 0 : PyList_SetItem(resultobj, i, o);
31994 : }
31995 : }
31996 : return resultobj;
31997 : fail:
31998 : return NULL;
31999 : }
32000 :
32001 :
32002 1 : SWIGINTERN PyObject *_wrap_fdopen(PyObject *self, PyObject *args) {
32003 1 : PyObject *resultobj = 0;
32004 : int arg1 ;
32005 1 : char *arg2 = (char *) 0 ;
32006 : int val1 ;
32007 1 : int ecode1 = 0 ;
32008 1 : PyObject * obj0 = 0 ;
32009 1 : PyObject * obj1 = 0 ;
32010 1 : FILE *result = 0 ;
32011 :
32012 1 : if (!PyArg_ParseTuple(args,(char *)"OO:fdopen",&obj0,&obj1)) SWIG_fail;
32013 1 : ecode1 = SWIG_AsVal_int(obj0, &val1);
32014 1 : if (!SWIG_IsOK(ecode1)) {
32015 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fdopen" "', argument " "1"" of type '" "int""'");
32016 : }
32017 1 : arg1 = (int)(val1);
32018 : {
32019 1 : if (obj1 == Py_None)
32020 : arg2 = NULL;
32021 1 : else if (PyUnicode_Check(obj1))
32022 1 : arg2 = PyUnicode_AsUTF8(obj1);
32023 0 : else if (PyBytes_Check(obj1))
32024 0 : arg2 = PyBytes_AsString(obj1);
32025 : else {
32026 0 : PyErr_Format(PyExc_TypeError,
32027 : "arg %d: expected str, bytes, or None, got %s",
32028 : 2, obj1->ob_type->tp_name);
32029 0 : return NULL;
32030 : }
32031 : }
32032 1 : result = (FILE *)fdopen(arg1,(char const *)arg2);
32033 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 | 0 );
32034 1 : return resultobj;
32035 : fail:
32036 : return NULL;
32037 : }
32038 :
32039 :
32040 0 : SWIGINTERN int Swig_var_pyme_in_tree_build_set(PyObject *_val) {
32041 : {
32042 : int val;
32043 0 : int res = SWIG_AsVal_int(_val, &val);
32044 0 : if (!SWIG_IsOK(res)) {
32045 0 : SWIG_exception_fail(SWIG_ArgError(res), "in variable '""pyme_in_tree_build""' of type '""int""'");
32046 : }
32047 0 : pyme_in_tree_build = (int)(val);
32048 : }
32049 0 : return 0;
32050 : fail:
32051 0 : return 1;
32052 : }
32053 :
32054 :
32055 23 : SWIGINTERN PyObject *Swig_var_pyme_in_tree_build_get(void) {
32056 23 : PyObject *pyobj = 0;
32057 23 : PyObject *self = 0;
32058 :
32059 : (void)self;
32060 46 : pyobj = SWIG_From_int((int)(pyme_in_tree_build));
32061 23 : return pyobj;
32062 : }
32063 :
32064 :
32065 12 : SWIGINTERN PyObject *_wrap_pyme_raise_callback_exception(PyObject *self, PyObject *args) {
32066 12 : PyObject *resultobj = 0;
32067 12 : PyObject *arg1 = (PyObject *) 0 ;
32068 12 : PyObject * obj0 = 0 ;
32069 12 : PyObject *result = 0 ;
32070 :
32071 12 : if (!PyArg_ParseTuple(args,(char *)"O:pyme_raise_callback_exception",&obj0)) SWIG_fail;
32072 12 : arg1 = obj0;
32073 12 : result = (PyObject *)pyme_raise_callback_exception(arg1);
32074 12 : resultobj = result;
32075 12 : return resultobj;
32076 : fail:
32077 : return NULL;
32078 : }
32079 :
32080 :
32081 75 : SWIGINTERN PyObject *_wrap_pyme_set_passphrase_cb(PyObject *self, PyObject *args) {
32082 75 : PyObject *resultobj = 0;
32083 75 : PyObject *arg1 = (PyObject *) 0 ;
32084 75 : PyObject *arg2 = (PyObject *) 0 ;
32085 75 : PyObject * obj0 = 0 ;
32086 75 : PyObject * obj1 = 0 ;
32087 75 : PyObject *result = 0 ;
32088 :
32089 75 : if (!PyArg_ParseTuple(args,(char *)"OO:pyme_set_passphrase_cb",&obj0,&obj1)) SWIG_fail;
32090 75 : arg1 = obj0;
32091 75 : arg2 = obj1;
32092 75 : result = (PyObject *)pyme_set_passphrase_cb(arg1,arg2);
32093 75 : resultobj = result;
32094 75 : return resultobj;
32095 : fail:
32096 : return NULL;
32097 : }
32098 :
32099 :
32100 55 : SWIGINTERN PyObject *_wrap_pyme_set_progress_cb(PyObject *self, PyObject *args) {
32101 55 : PyObject *resultobj = 0;
32102 55 : PyObject *arg1 = (PyObject *) 0 ;
32103 55 : PyObject *arg2 = (PyObject *) 0 ;
32104 55 : PyObject * obj0 = 0 ;
32105 55 : PyObject * obj1 = 0 ;
32106 55 : PyObject *result = 0 ;
32107 :
32108 55 : if (!PyArg_ParseTuple(args,(char *)"OO:pyme_set_progress_cb",&obj0,&obj1)) SWIG_fail;
32109 55 : arg1 = obj0;
32110 55 : arg2 = obj1;
32111 55 : result = (PyObject *)pyme_set_progress_cb(arg1,arg2);
32112 55 : resultobj = result;
32113 55 : return resultobj;
32114 : fail:
32115 : return NULL;
32116 : }
32117 :
32118 :
32119 55 : SWIGINTERN PyObject *_wrap_pyme_set_status_cb(PyObject *self, PyObject *args) {
32120 55 : PyObject *resultobj = 0;
32121 55 : PyObject *arg1 = (PyObject *) 0 ;
32122 55 : PyObject *arg2 = (PyObject *) 0 ;
32123 55 : PyObject * obj0 = 0 ;
32124 55 : PyObject * obj1 = 0 ;
32125 55 : PyObject *result = 0 ;
32126 :
32127 55 : if (!PyArg_ParseTuple(args,(char *)"OO:pyme_set_status_cb",&obj0,&obj1)) SWIG_fail;
32128 55 : arg1 = obj0;
32129 55 : arg2 = obj1;
32130 55 : result = (PyObject *)pyme_set_status_cb(arg1,arg2);
32131 55 : resultobj = result;
32132 55 : return resultobj;
32133 : fail:
32134 : return NULL;
32135 : }
32136 :
32137 :
32138 10 : SWIGINTERN PyObject *_wrap_pyme_data_new_from_cbs(PyObject *self, PyObject *args) {
32139 10 : PyObject *resultobj = 0;
32140 10 : PyObject *arg1 = (PyObject *) 0 ;
32141 10 : PyObject *arg2 = (PyObject *) 0 ;
32142 10 : gpgme_data_t *arg3 = (gpgme_data_t *) 0 ;
32143 10 : void *argp3 = 0 ;
32144 10 : int res3 = 0 ;
32145 10 : PyObject * obj0 = 0 ;
32146 10 : PyObject * obj1 = 0 ;
32147 10 : PyObject * obj2 = 0 ;
32148 10 : PyObject *result = 0 ;
32149 :
32150 10 : if (!PyArg_ParseTuple(args,(char *)"OOO:pyme_data_new_from_cbs",&obj0,&obj1,&obj2)) SWIG_fail;
32151 10 : arg1 = obj0;
32152 10 : arg2 = obj1;
32153 10 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
32154 10 : if (!SWIG_IsOK(res3)) {
32155 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pyme_data_new_from_cbs" "', argument " "3"" of type '" "gpgme_data_t *""'");
32156 : }
32157 10 : arg3 = (gpgme_data_t *)(argp3);
32158 10 : result = (PyObject *)pyme_data_new_from_cbs(arg1,arg2,arg3);
32159 10 : resultobj = result;
32160 10 : return resultobj;
32161 : fail:
32162 : return NULL;
32163 : }
32164 :
32165 :
32166 : static PyMethodDef SwigMethods[] = {
32167 : { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
32168 : { (char *)"gpgme_err_make", _wrap_gpgme_err_make, METH_VARARGS, (char *)"gpgme_err_make(source, code) -> gpgme_error_t"},
32169 : { (char *)"gpgme_error", _wrap_gpgme_error, METH_VARARGS, (char *)"gpgme_error(code) -> gpgme_error_t"},
32170 : { (char *)"gpgme_err_code", _wrap_gpgme_err_code, METH_VARARGS, (char *)"gpgme_err_code(err) -> gpgme_err_code_t"},
32171 : { (char *)"gpgme_err_source", _wrap_gpgme_err_source, METH_VARARGS, (char *)"gpgme_err_source(err) -> gpgme_err_source_t"},
32172 : { (char *)"gpgme_strerror", _wrap_gpgme_strerror, METH_VARARGS, (char *)"gpgme_strerror(err) -> char const *"},
32173 : { (char *)"gpgme_strerror_r", _wrap_gpgme_strerror_r, METH_VARARGS, (char *)"gpgme_strerror_r(err, buf) -> int"},
32174 : { (char *)"gpgme_strsource", _wrap_gpgme_strsource, METH_VARARGS, (char *)"gpgme_strsource(err) -> char const *"},
32175 : { (char *)"gpgme_err_code_from_errno", _wrap_gpgme_err_code_from_errno, METH_VARARGS, (char *)"gpgme_err_code_from_errno(err) -> gpgme_err_code_t"},
32176 : { (char *)"gpgme_err_code_to_errno", _wrap_gpgme_err_code_to_errno, METH_VARARGS, (char *)"gpgme_err_code_to_errno(code) -> int"},
32177 : { (char *)"gpgme_err_code_from_syserror", _wrap_gpgme_err_code_from_syserror, METH_VARARGS, (char *)"gpgme_err_code_from_syserror() -> gpgme_err_code_t"},
32178 : { (char *)"gpgme_err_set_errno", _wrap_gpgme_err_set_errno, METH_VARARGS, (char *)"gpgme_err_set_errno(err)"},
32179 : { (char *)"gpgme_err_make_from_errno", _wrap_gpgme_err_make_from_errno, METH_VARARGS, (char *)"gpgme_err_make_from_errno(source, err) -> gpgme_error_t"},
32180 : { (char *)"gpgme_error_from_errno", _wrap_gpgme_error_from_errno, METH_VARARGS, (char *)"gpgme_error_from_errno(err) -> gpgme_error_t"},
32181 : { (char *)"gpgme_error_from_syserror", _wrap_gpgme_error_from_syserror, METH_VARARGS, (char *)"gpgme_error_from_syserror() -> gpgme_error_t"},
32182 : { (char *)"gpgme_new", _wrap_gpgme_new, METH_VARARGS, (char *)"gpgme_new(ctx) -> gpgme_error_t"},
32183 : { (char *)"gpgme_release", _wrap_gpgme_release, METH_VARARGS, (char *)"gpgme_release(ctx)"},
32184 : { (char *)"gpgme_set_ctx_flag", _wrap_gpgme_set_ctx_flag, METH_VARARGS, (char *)"gpgme_set_ctx_flag(ctx, name, value) -> gpgme_error_t"},
32185 : { (char *)"gpgme_set_protocol", _wrap_gpgme_set_protocol, METH_VARARGS, (char *)"gpgme_set_protocol(ctx, proto) -> gpgme_error_t"},
32186 : { (char *)"gpgme_get_protocol", _wrap_gpgme_get_protocol, METH_VARARGS, (char *)"gpgme_get_protocol(ctx) -> gpgme_protocol_t"},
32187 : { (char *)"gpgme_set_sub_protocol", _wrap_gpgme_set_sub_protocol, METH_VARARGS, (char *)"gpgme_set_sub_protocol(ctx, proto) -> gpgme_error_t"},
32188 : { (char *)"gpgme_get_sub_protocol", _wrap_gpgme_get_sub_protocol, METH_VARARGS, (char *)"gpgme_get_sub_protocol(ctx) -> gpgme_protocol_t"},
32189 : { (char *)"gpgme_get_protocol_name", _wrap_gpgme_get_protocol_name, METH_VARARGS, (char *)"gpgme_get_protocol_name(proto) -> char const *"},
32190 : { (char *)"gpgme_set_armor", _wrap_gpgme_set_armor, METH_VARARGS, (char *)"gpgme_set_armor(ctx, yes)"},
32191 : { (char *)"gpgme_get_armor", _wrap_gpgme_get_armor, METH_VARARGS, (char *)"gpgme_get_armor(ctx) -> int"},
32192 : { (char *)"gpgme_set_textmode", _wrap_gpgme_set_textmode, METH_VARARGS, (char *)"gpgme_set_textmode(ctx, yes)"},
32193 : { (char *)"gpgme_get_textmode", _wrap_gpgme_get_textmode, METH_VARARGS, (char *)"gpgme_get_textmode(ctx) -> int"},
32194 : { (char *)"gpgme_set_offline", _wrap_gpgme_set_offline, METH_VARARGS, (char *)"gpgme_set_offline(ctx, yes)"},
32195 : { (char *)"gpgme_get_offline", _wrap_gpgme_get_offline, METH_VARARGS, (char *)"gpgme_get_offline(ctx) -> int"},
32196 : { (char *)"gpgme_set_include_certs", _wrap_gpgme_set_include_certs, METH_VARARGS, (char *)"gpgme_set_include_certs(ctx, nr_of_certs)"},
32197 : { (char *)"gpgme_get_include_certs", _wrap_gpgme_get_include_certs, METH_VARARGS, (char *)"gpgme_get_include_certs(ctx) -> int"},
32198 : { (char *)"gpgme_set_keylist_mode", _wrap_gpgme_set_keylist_mode, METH_VARARGS, (char *)"gpgme_set_keylist_mode(ctx, mode) -> gpgme_error_t"},
32199 : { (char *)"gpgme_get_keylist_mode", _wrap_gpgme_get_keylist_mode, METH_VARARGS, (char *)"gpgme_get_keylist_mode(ctx) -> gpgme_keylist_mode_t"},
32200 : { (char *)"gpgme_set_pinentry_mode", _wrap_gpgme_set_pinentry_mode, METH_VARARGS, (char *)"gpgme_set_pinentry_mode(ctx, mode) -> gpgme_error_t"},
32201 : { (char *)"gpgme_get_pinentry_mode", _wrap_gpgme_get_pinentry_mode, METH_VARARGS, (char *)"gpgme_get_pinentry_mode(ctx) -> gpgme_pinentry_mode_t"},
32202 : { (char *)"gpgme_set_passphrase_cb", _wrap_gpgme_set_passphrase_cb, METH_VARARGS, (char *)"gpgme_set_passphrase_cb(ctx, cb, hook_value)"},
32203 : { (char *)"gpgme_get_passphrase_cb", _wrap_gpgme_get_passphrase_cb, METH_VARARGS, (char *)"gpgme_get_passphrase_cb(ctx, cb, hook_value)"},
32204 : { (char *)"gpgme_set_progress_cb", _wrap_gpgme_set_progress_cb, METH_VARARGS, (char *)"gpgme_set_progress_cb(c, cb, hook_value)"},
32205 : { (char *)"gpgme_get_progress_cb", _wrap_gpgme_get_progress_cb, METH_VARARGS, (char *)"gpgme_get_progress_cb(ctx, cb, hook_value)"},
32206 : { (char *)"gpgme_set_status_cb", _wrap_gpgme_set_status_cb, METH_VARARGS, (char *)"gpgme_set_status_cb(c, cb, hook_value)"},
32207 : { (char *)"gpgme_get_status_cb", _wrap_gpgme_get_status_cb, METH_VARARGS, (char *)"gpgme_get_status_cb(ctx, cb, hook_value)"},
32208 : { (char *)"gpgme_set_locale", _wrap_gpgme_set_locale, METH_VARARGS, (char *)"gpgme_set_locale(ctx, category, value) -> gpgme_error_t"},
32209 : { (char *)"gpgme_ctx_get_engine_info", _wrap_gpgme_ctx_get_engine_info, METH_VARARGS, (char *)"gpgme_ctx_get_engine_info(ctx) -> _gpgme_engine_info"},
32210 : { (char *)"gpgme_ctx_set_engine_info", _wrap_gpgme_ctx_set_engine_info, METH_VARARGS, (char *)"gpgme_ctx_set_engine_info(ctx, proto, file_name, home_dir) -> gpgme_error_t"},
32211 : { (char *)"gpgme_signers_clear", _wrap_gpgme_signers_clear, METH_VARARGS, (char *)"gpgme_signers_clear(ctx)"},
32212 : { (char *)"gpgme_signers_add", _wrap_gpgme_signers_add, METH_VARARGS, (char *)"gpgme_signers_add(ctx, key) -> gpgme_error_t"},
32213 : { (char *)"gpgme_signers_count", _wrap_gpgme_signers_count, METH_VARARGS, (char *)"gpgme_signers_count(ctx) -> unsigned int"},
32214 : { (char *)"gpgme_signers_enum", _wrap_gpgme_signers_enum, METH_VARARGS, (char *)"gpgme_signers_enum(ctx, seq) -> _gpgme_key"},
32215 : { (char *)"gpgme_sig_notation_clear", _wrap_gpgme_sig_notation_clear, METH_VARARGS, (char *)"gpgme_sig_notation_clear(ctx)"},
32216 : { (char *)"gpgme_sig_notation_add", _wrap_gpgme_sig_notation_add, METH_VARARGS, (char *)"gpgme_sig_notation_add(ctx, name, value, flags) -> gpgme_error_t"},
32217 : { (char *)"gpgme_sig_notation_get", _wrap_gpgme_sig_notation_get, METH_VARARGS, (char *)"gpgme_sig_notation_get(ctx) -> _gpgme_sig_notation"},
32218 : { (char *)"gpgme_set_io_cbs", _wrap_gpgme_set_io_cbs, METH_VARARGS, (char *)"gpgme_set_io_cbs(ctx, io_cbs)"},
32219 : { (char *)"gpgme_get_io_cbs", _wrap_gpgme_get_io_cbs, METH_VARARGS, (char *)"gpgme_get_io_cbs(ctx, io_cbs)"},
32220 : { (char *)"gpgme_io_read", _wrap_gpgme_io_read, METH_VARARGS, (char *)"gpgme_io_read(fd, buffer, count) -> ssize_t"},
32221 : { (char *)"gpgme_io_write", _wrap_gpgme_io_write, METH_VARARGS, (char *)"gpgme_io_write(fd, buffer, count) -> ssize_t"},
32222 : { (char *)"gpgme_io_writen", _wrap_gpgme_io_writen, METH_VARARGS, (char *)"gpgme_io_writen(fd, buffer, count) -> int"},
32223 : { (char *)"gpgme_wait", _wrap_gpgme_wait, METH_VARARGS, (char *)"gpgme_wait(ctx, status, hang) -> gpgme_ctx_t"},
32224 : { (char *)"gpgme_wait_ext", _wrap_gpgme_wait_ext, METH_VARARGS, (char *)"gpgme_wait_ext(ctx, status, op_err, hang) -> gpgme_ctx_t"},
32225 : { (char *)"gpgme_cancel", _wrap_gpgme_cancel, METH_VARARGS, (char *)"gpgme_cancel(ctx) -> gpgme_error_t"},
32226 : { (char *)"gpgme_cancel_async", _wrap_gpgme_cancel_async, METH_VARARGS, (char *)"gpgme_cancel_async(ctx) -> gpgme_error_t"},
32227 : { (char *)"gpgme_data_read", _wrap_gpgme_data_read, METH_VARARGS, (char *)"gpgme_data_read(dh, buffer) -> ssize_t"},
32228 : { (char *)"gpgme_data_write", _wrap_gpgme_data_write, METH_VARARGS, (char *)"gpgme_data_write(dh, buffer) -> ssize_t"},
32229 : { (char *)"gpgme_data_seek", _wrap_gpgme_data_seek, METH_VARARGS, (char *)"gpgme_data_seek(dh, offset, whence) -> off_t"},
32230 : { (char *)"gpgme_data_new", _wrap_gpgme_data_new, METH_VARARGS, (char *)"gpgme_data_new(r_dh) -> gpgme_error_t"},
32231 : { (char *)"gpgme_data_release", _wrap_gpgme_data_release, METH_VARARGS, (char *)"gpgme_data_release(dh)"},
32232 : { (char *)"gpgme_data_new_from_mem", _wrap_gpgme_data_new_from_mem, METH_VARARGS, (char *)"gpgme_data_new_from_mem(r_dh, buffer, size, copy) -> gpgme_error_t"},
32233 : { (char *)"gpgme_data_release_and_get_mem", _wrap_gpgme_data_release_and_get_mem, METH_VARARGS, (char *)"gpgme_data_release_and_get_mem(dh, r_len) -> char *"},
32234 : { (char *)"gpgme_free", _wrap_gpgme_free, METH_VARARGS, (char *)"gpgme_free(buffer)"},
32235 : { (char *)"gpgme_data_new_from_cbs", _wrap_gpgme_data_new_from_cbs, METH_VARARGS, (char *)"gpgme_data_new_from_cbs(dh, cbs, handle) -> gpgme_error_t"},
32236 : { (char *)"gpgme_data_new_from_fd", _wrap_gpgme_data_new_from_fd, METH_VARARGS, (char *)"gpgme_data_new_from_fd(dh, fd) -> gpgme_error_t"},
32237 : { (char *)"gpgme_data_new_from_stream", _wrap_gpgme_data_new_from_stream, METH_VARARGS, (char *)"gpgme_data_new_from_stream(dh, stream) -> gpgme_error_t"},
32238 : { (char *)"gpgme_data_get_encoding", _wrap_gpgme_data_get_encoding, METH_VARARGS, (char *)"gpgme_data_get_encoding(dh) -> gpgme_data_encoding_t"},
32239 : { (char *)"gpgme_data_set_encoding", _wrap_gpgme_data_set_encoding, METH_VARARGS, (char *)"gpgme_data_set_encoding(dh, enc) -> gpgme_error_t"},
32240 : { (char *)"gpgme_data_get_file_name", _wrap_gpgme_data_get_file_name, METH_VARARGS, (char *)"gpgme_data_get_file_name(dh) -> char *"},
32241 : { (char *)"gpgme_data_set_file_name", _wrap_gpgme_data_set_file_name, METH_VARARGS, (char *)"gpgme_data_set_file_name(dh, file_name) -> gpgme_error_t"},
32242 : { (char *)"gpgme_data_set_flag", _wrap_gpgme_data_set_flag, METH_VARARGS, (char *)"gpgme_data_set_flag(dh, name, value) -> gpg_error_t"},
32243 : { (char *)"gpgme_data_identify", _wrap_gpgme_data_identify, METH_VARARGS, (char *)"gpgme_data_identify(dh, reserved) -> gpgme_data_type_t"},
32244 : { (char *)"gpgme_data_new_from_file", _wrap_gpgme_data_new_from_file, METH_VARARGS, (char *)"gpgme_data_new_from_file(r_dh, fname, copy) -> gpgme_error_t"},
32245 : { (char *)"gpgme_data_new_from_filepart", _wrap_gpgme_data_new_from_filepart, METH_VARARGS, (char *)"gpgme_data_new_from_filepart(r_dh, fname, fp, offset, length) -> gpgme_error_t"},
32246 : { (char *)"gpgme_get_key", _wrap_gpgme_get_key, METH_VARARGS, (char *)"gpgme_get_key(ctx, fpr, r_key, secret) -> gpgme_error_t"},
32247 : { (char *)"gpgme_key_from_uid", _wrap_gpgme_key_from_uid, METH_VARARGS, (char *)"gpgme_key_from_uid(key, name) -> gpgme_error_t"},
32248 : { (char *)"gpgme_key_ref", _wrap_gpgme_key_ref, METH_VARARGS, (char *)"gpgme_key_ref(key)"},
32249 : { (char *)"gpgme_key_unref", _wrap_gpgme_key_unref, METH_VARARGS, (char *)"gpgme_key_unref(key)"},
32250 : { (char *)"gpgme_key_release", _wrap_gpgme_key_release, METH_VARARGS, (char *)"gpgme_key_release(key)"},
32251 : { (char *)"gpgme_op_encrypt_result", _wrap_gpgme_op_encrypt_result, METH_VARARGS, (char *)"gpgme_op_encrypt_result(ctx) -> _gpgme_op_encrypt_result"},
32252 : { (char *)"gpgme_op_encrypt_start", _wrap_gpgme_op_encrypt_start, METH_VARARGS, (char *)"gpgme_op_encrypt_start(ctx, recp, flags, plain, cipher) -> gpgme_error_t"},
32253 : { (char *)"gpgme_op_encrypt", _wrap_gpgme_op_encrypt, METH_VARARGS, (char *)"gpgme_op_encrypt(ctx, recp, flags, plain, cipher) -> gpgme_error_t"},
32254 : { (char *)"gpgme_op_encrypt_sign_start", _wrap_gpgme_op_encrypt_sign_start, METH_VARARGS, (char *)"gpgme_op_encrypt_sign_start(ctx, recp, flags, plain, cipher) -> gpgme_error_t"},
32255 : { (char *)"gpgme_op_encrypt_sign", _wrap_gpgme_op_encrypt_sign, METH_VARARGS, (char *)"gpgme_op_encrypt_sign(ctx, recp, flags, plain, cipher) -> gpgme_error_t"},
32256 : { (char *)"gpgme_op_decrypt_result", _wrap_gpgme_op_decrypt_result, METH_VARARGS, (char *)"gpgme_op_decrypt_result(ctx) -> _gpgme_op_decrypt_result"},
32257 : { (char *)"gpgme_op_decrypt_start", _wrap_gpgme_op_decrypt_start, METH_VARARGS, (char *)"gpgme_op_decrypt_start(ctx, cipher, plain) -> gpgme_error_t"},
32258 : { (char *)"gpgme_op_decrypt", _wrap_gpgme_op_decrypt, METH_VARARGS, (char *)"gpgme_op_decrypt(ctx, cipher, plain) -> gpgme_error_t"},
32259 : { (char *)"gpgme_op_decrypt_verify_start", _wrap_gpgme_op_decrypt_verify_start, METH_VARARGS, (char *)"gpgme_op_decrypt_verify_start(ctx, cipher, plain) -> gpgme_error_t"},
32260 : { (char *)"gpgme_op_decrypt_verify", _wrap_gpgme_op_decrypt_verify, METH_VARARGS, (char *)"gpgme_op_decrypt_verify(ctx, cipher, plain) -> gpgme_error_t"},
32261 : { (char *)"gpgme_op_sign_result", _wrap_gpgme_op_sign_result, METH_VARARGS, (char *)"gpgme_op_sign_result(ctx) -> _gpgme_op_sign_result"},
32262 : { (char *)"gpgme_op_sign_start", _wrap_gpgme_op_sign_start, METH_VARARGS, (char *)"gpgme_op_sign_start(ctx, plain, sig, mode) -> gpgme_error_t"},
32263 : { (char *)"gpgme_op_sign", _wrap_gpgme_op_sign, METH_VARARGS, (char *)"gpgme_op_sign(ctx, plain, sig, mode) -> gpgme_error_t"},
32264 : { (char *)"gpgme_op_verify_result", _wrap_gpgme_op_verify_result, METH_VARARGS, (char *)"gpgme_op_verify_result(ctx) -> _gpgme_op_verify_result"},
32265 : { (char *)"gpgme_op_verify_start", _wrap_gpgme_op_verify_start, METH_VARARGS, (char *)"gpgme_op_verify_start(ctx, sig, signed_text, plaintext) -> gpgme_error_t"},
32266 : { (char *)"gpgme_op_verify", _wrap_gpgme_op_verify, METH_VARARGS, (char *)"gpgme_op_verify(ctx, sig, signed_text, plaintext) -> gpgme_error_t"},
32267 : { (char *)"gpgme_op_import_result", _wrap_gpgme_op_import_result, METH_VARARGS, (char *)"gpgme_op_import_result(ctx) -> _gpgme_op_import_result"},
32268 : { (char *)"gpgme_op_import_start", _wrap_gpgme_op_import_start, METH_VARARGS, (char *)"gpgme_op_import_start(ctx, keydata) -> gpgme_error_t"},
32269 : { (char *)"gpgme_op_import", _wrap_gpgme_op_import, METH_VARARGS, (char *)"gpgme_op_import(ctx, keydata) -> gpgme_error_t"},
32270 : { (char *)"gpgme_op_import_keys_start", _wrap_gpgme_op_import_keys_start, METH_VARARGS, (char *)"gpgme_op_import_keys_start(ctx, keys) -> gpgme_error_t"},
32271 : { (char *)"gpgme_op_import_keys", _wrap_gpgme_op_import_keys, METH_VARARGS, (char *)"gpgme_op_import_keys(ctx, keys) -> gpgme_error_t"},
32272 : { (char *)"gpgme_op_export_start", _wrap_gpgme_op_export_start, METH_VARARGS, (char *)"gpgme_op_export_start(ctx, pattern, mode, keydata) -> gpgme_error_t"},
32273 : { (char *)"gpgme_op_export", _wrap_gpgme_op_export, METH_VARARGS, (char *)"gpgme_op_export(ctx, pattern, mode, keydata) -> gpgme_error_t"},
32274 : { (char *)"gpgme_op_export_ext_start", _wrap_gpgme_op_export_ext_start, METH_VARARGS, (char *)"gpgme_op_export_ext_start(ctx, pattern, mode, keydata) -> gpgme_error_t"},
32275 : { (char *)"gpgme_op_export_ext", _wrap_gpgme_op_export_ext, METH_VARARGS, (char *)"gpgme_op_export_ext(ctx, pattern, mode, keydata) -> gpgme_error_t"},
32276 : { (char *)"gpgme_op_export_keys_start", _wrap_gpgme_op_export_keys_start, METH_VARARGS, (char *)"gpgme_op_export_keys_start(ctx, keys, mode, keydata) -> gpgme_error_t"},
32277 : { (char *)"gpgme_op_export_keys", _wrap_gpgme_op_export_keys, METH_VARARGS, (char *)"gpgme_op_export_keys(ctx, keys, mode, keydata) -> gpgme_error_t"},
32278 : { (char *)"gpgme_op_genkey_start", _wrap_gpgme_op_genkey_start, METH_VARARGS, (char *)"gpgme_op_genkey_start(ctx, parms, pubkey, seckey) -> gpgme_error_t"},
32279 : { (char *)"gpgme_op_genkey", _wrap_gpgme_op_genkey, METH_VARARGS, (char *)"gpgme_op_genkey(ctx, parms, pubkey, seckey) -> gpgme_error_t"},
32280 : { (char *)"gpgme_op_genkey_result", _wrap_gpgme_op_genkey_result, METH_VARARGS, (char *)"gpgme_op_genkey_result(ctx) -> _gpgme_op_genkey_result"},
32281 : { (char *)"gpgme_op_delete_start", _wrap_gpgme_op_delete_start, METH_VARARGS, (char *)"gpgme_op_delete_start(ctx, key, allow_secret) -> gpgme_error_t"},
32282 : { (char *)"gpgme_op_delete", _wrap_gpgme_op_delete, METH_VARARGS, (char *)"gpgme_op_delete(ctx, key, allow_secret) -> gpgme_error_t"},
32283 : { (char *)"gpgme_op_edit_start", _wrap_gpgme_op_edit_start, METH_VARARGS, (char *)"gpgme_op_edit_start(ctx, key, fnc, out) -> gpgme_error_t"},
32284 : { (char *)"gpgme_op_edit", _wrap_gpgme_op_edit, METH_VARARGS, (char *)"gpgme_op_edit(ctx, key, fnc, out) -> gpgme_error_t"},
32285 : { (char *)"gpgme_op_card_edit_start", _wrap_gpgme_op_card_edit_start, METH_VARARGS, (char *)"gpgme_op_card_edit_start(ctx, key, fnc, out) -> gpgme_error_t"},
32286 : { (char *)"gpgme_op_card_edit", _wrap_gpgme_op_card_edit, METH_VARARGS, (char *)"gpgme_op_card_edit(ctx, key, fnc, out) -> gpgme_error_t"},
32287 : { (char *)"gpgme_op_keylist_result", _wrap_gpgme_op_keylist_result, METH_VARARGS, (char *)"gpgme_op_keylist_result(ctx) -> _gpgme_op_keylist_result"},
32288 : { (char *)"gpgme_op_keylist_start", _wrap_gpgme_op_keylist_start, METH_VARARGS, (char *)"gpgme_op_keylist_start(ctx, pattern, secret_only) -> gpgme_error_t"},
32289 : { (char *)"gpgme_op_keylist_ext_start", _wrap_gpgme_op_keylist_ext_start, METH_VARARGS, (char *)"gpgme_op_keylist_ext_start(ctx, pattern, secret_only, reserved) -> gpgme_error_t"},
32290 : { (char *)"gpgme_op_keylist_next", _wrap_gpgme_op_keylist_next, METH_VARARGS, (char *)"gpgme_op_keylist_next(ctx, r_key) -> gpgme_error_t"},
32291 : { (char *)"gpgme_op_keylist_end", _wrap_gpgme_op_keylist_end, METH_VARARGS, (char *)"gpgme_op_keylist_end(ctx) -> gpgme_error_t"},
32292 : { (char *)"gpgme_op_passwd_start", _wrap_gpgme_op_passwd_start, METH_VARARGS, (char *)"gpgme_op_passwd_start(ctx, key, flags) -> gpgme_error_t"},
32293 : { (char *)"gpgme_op_passwd", _wrap_gpgme_op_passwd, METH_VARARGS, (char *)"gpgme_op_passwd(ctx, key, flags) -> gpgme_error_t"},
32294 : { (char *)"gpgme_op_trustlist_start", _wrap_gpgme_op_trustlist_start, METH_VARARGS, (char *)"gpgme_op_trustlist_start(ctx, pattern, max_level) -> gpgme_error_t"},
32295 : { (char *)"gpgme_op_trustlist_next", _wrap_gpgme_op_trustlist_next, METH_VARARGS, (char *)"gpgme_op_trustlist_next(ctx, r_item) -> gpgme_error_t"},
32296 : { (char *)"gpgme_op_trustlist_end", _wrap_gpgme_op_trustlist_end, METH_VARARGS, (char *)"gpgme_op_trustlist_end(ctx) -> gpgme_error_t"},
32297 : { (char *)"gpgme_trust_item_ref", _wrap_gpgme_trust_item_ref, METH_VARARGS, (char *)"gpgme_trust_item_ref(item)"},
32298 : { (char *)"gpgme_trust_item_unref", _wrap_gpgme_trust_item_unref, METH_VARARGS, (char *)"gpgme_trust_item_unref(item)"},
32299 : { (char *)"gpgme_op_getauditlog_start", _wrap_gpgme_op_getauditlog_start, METH_VARARGS, (char *)"gpgme_op_getauditlog_start(ctx, output, flags) -> gpgme_error_t"},
32300 : { (char *)"gpgme_op_getauditlog", _wrap_gpgme_op_getauditlog, METH_VARARGS, (char *)"gpgme_op_getauditlog(ctx, output, flags) -> gpgme_error_t"},
32301 : { (char *)"gpgme_op_spawn_start", _wrap_gpgme_op_spawn_start, METH_VARARGS, (char *)"gpgme_op_spawn_start(ctx, file, argv, datain, dataout, dataerr, flags) -> gpgme_error_t"},
32302 : { (char *)"gpgme_op_spawn", _wrap_gpgme_op_spawn, METH_VARARGS, (char *)"gpgme_op_spawn(ctx, file, argv, datain, dataout, dataerr, flags) -> gpgme_error_t"},
32303 : { (char *)"gpgme_op_assuan_transact_start", _wrap_gpgme_op_assuan_transact_start, METH_VARARGS, (char *)"gpgme_op_assuan_transact_start(ctx, command, data_cb, inq_cb, stat_cb) -> gpgme_error_t"},
32304 : { (char *)"gpgme_op_assuan_transact_ext", _wrap_gpgme_op_assuan_transact_ext, METH_VARARGS, (char *)"gpgme_op_assuan_transact_ext(ctx, command, data_cb, inq_cb, stat_cb, op_err) -> gpgme_error_t"},
32305 : { (char *)"gpgme_op_vfs_mount_result", _wrap_gpgme_op_vfs_mount_result, METH_VARARGS, (char *)"gpgme_op_vfs_mount_result(ctx) -> _gpgme_op_vfs_mount_result"},
32306 : { (char *)"gpgme_op_vfs_mount", _wrap_gpgme_op_vfs_mount, METH_VARARGS, (char *)"gpgme_op_vfs_mount(ctx, container_file, mount_dir, flags, op_err) -> gpgme_error_t"},
32307 : { (char *)"gpgme_op_vfs_create", _wrap_gpgme_op_vfs_create, METH_VARARGS, (char *)"gpgme_op_vfs_create(ctx, recp, container_file, flags, op_err) -> gpgme_error_t"},
32308 : { (char *)"gpgme_conf_arg_new", _wrap_gpgme_conf_arg_new, METH_VARARGS, (char *)"gpgme_conf_arg_new(arg_p, type, value) -> gpgme_error_t"},
32309 : { (char *)"gpgme_conf_arg_release", _wrap_gpgme_conf_arg_release, METH_VARARGS, (char *)"gpgme_conf_arg_release(arg, type)"},
32310 : { (char *)"gpgme_conf_opt_change", _wrap_gpgme_conf_opt_change, METH_VARARGS, (char *)"gpgme_conf_opt_change(opt, reset, arg) -> gpgme_error_t"},
32311 : { (char *)"gpgme_conf_release", _wrap_gpgme_conf_release, METH_VARARGS, (char *)"gpgme_conf_release(conf)"},
32312 : { (char *)"gpgme_op_conf_load", _wrap_gpgme_op_conf_load, METH_VARARGS, (char *)"gpgme_op_conf_load(ctx, conf_p) -> gpgme_error_t"},
32313 : { (char *)"gpgme_op_conf_save", _wrap_gpgme_op_conf_save, METH_VARARGS, (char *)"gpgme_op_conf_save(ctx, comp) -> gpgme_error_t"},
32314 : { (char *)"gpgme_set_global_flag", _wrap_gpgme_set_global_flag, METH_VARARGS, (char *)"gpgme_set_global_flag(name, value) -> int"},
32315 : { (char *)"gpgme_check_version", _wrap_gpgme_check_version, METH_VARARGS, (char *)"gpgme_check_version(req_version) -> char const *"},
32316 : { (char *)"gpgme_check_version_internal", _wrap_gpgme_check_version_internal, METH_VARARGS, (char *)"gpgme_check_version_internal(req_version, offset_sig_validity) -> char const *"},
32317 : { (char *)"gpgme_get_dirinfo", _wrap_gpgme_get_dirinfo, METH_VARARGS, (char *)"gpgme_get_dirinfo(what) -> char const *"},
32318 : { (char *)"gpgme_get_engine_info", _wrap_gpgme_get_engine_info, METH_VARARGS, (char *)"gpgme_get_engine_info(engine_info) -> gpgme_error_t"},
32319 : { (char *)"gpgme_set_engine_info", _wrap_gpgme_set_engine_info, METH_VARARGS, (char *)"gpgme_set_engine_info(proto, file_name, home_dir) -> gpgme_error_t"},
32320 : { (char *)"gpgme_engine_check_version", _wrap_gpgme_engine_check_version, METH_VARARGS, (char *)"gpgme_engine_check_version(proto) -> gpgme_error_t"},
32321 : { (char *)"gpgme_result_ref", _wrap_gpgme_result_ref, METH_VARARGS, (char *)"gpgme_result_ref(result)"},
32322 : { (char *)"gpgme_result_unref", _wrap_gpgme_result_unref, METH_VARARGS, (char *)"gpgme_result_unref(result)"},
32323 : { (char *)"gpgme_pubkey_algo_string", _wrap_gpgme_pubkey_algo_string, METH_VARARGS, (char *)"gpgme_pubkey_algo_string(subkey) -> char *"},
32324 : { (char *)"gpgme_pubkey_algo_name", _wrap_gpgme_pubkey_algo_name, METH_VARARGS, (char *)"gpgme_pubkey_algo_name(algo) -> char const *"},
32325 : { (char *)"gpgme_hash_algo_name", _wrap_gpgme_hash_algo_name, METH_VARARGS, (char *)"gpgme_hash_algo_name(algo) -> char const *"},
32326 : { (char *)"new_gpgme_ctx_t_p", _wrap_new_gpgme_ctx_t_p, METH_VARARGS, (char *)"new_gpgme_ctx_t_p() -> gpgme_ctx_t *"},
32327 : { (char *)"copy_gpgme_ctx_t_p", _wrap_copy_gpgme_ctx_t_p, METH_VARARGS, (char *)"copy_gpgme_ctx_t_p(value) -> gpgme_ctx_t *"},
32328 : { (char *)"delete_gpgme_ctx_t_p", _wrap_delete_gpgme_ctx_t_p, METH_VARARGS, (char *)"delete_gpgme_ctx_t_p(obj)"},
32329 : { (char *)"gpgme_ctx_t_p_assign", _wrap_gpgme_ctx_t_p_assign, METH_VARARGS, (char *)"gpgme_ctx_t_p_assign(obj, value)"},
32330 : { (char *)"gpgme_ctx_t_p_value", _wrap_gpgme_ctx_t_p_value, METH_VARARGS, (char *)"gpgme_ctx_t_p_value(obj) -> gpgme_ctx_t"},
32331 : { (char *)"new_gpgme_data_t_p", _wrap_new_gpgme_data_t_p, METH_VARARGS, (char *)"new_gpgme_data_t_p() -> gpgme_data_t *"},
32332 : { (char *)"copy_gpgme_data_t_p", _wrap_copy_gpgme_data_t_p, METH_VARARGS, (char *)"copy_gpgme_data_t_p(value) -> gpgme_data_t *"},
32333 : { (char *)"delete_gpgme_data_t_p", _wrap_delete_gpgme_data_t_p, METH_VARARGS, (char *)"delete_gpgme_data_t_p(obj)"},
32334 : { (char *)"gpgme_data_t_p_assign", _wrap_gpgme_data_t_p_assign, METH_VARARGS, (char *)"gpgme_data_t_p_assign(obj, value)"},
32335 : { (char *)"gpgme_data_t_p_value", _wrap_gpgme_data_t_p_value, METH_VARARGS, (char *)"gpgme_data_t_p_value(obj) -> gpgme_data_t"},
32336 : { (char *)"new_gpgme_key_t_p", _wrap_new_gpgme_key_t_p, METH_VARARGS, (char *)"new_gpgme_key_t_p() -> gpgme_key_t *"},
32337 : { (char *)"copy_gpgme_key_t_p", _wrap_copy_gpgme_key_t_p, METH_VARARGS, (char *)"copy_gpgme_key_t_p(value) -> gpgme_key_t *"},
32338 : { (char *)"delete_gpgme_key_t_p", _wrap_delete_gpgme_key_t_p, METH_VARARGS, (char *)"delete_gpgme_key_t_p(obj)"},
32339 : { (char *)"gpgme_key_t_p_assign", _wrap_gpgme_key_t_p_assign, METH_VARARGS, (char *)"gpgme_key_t_p_assign(obj, value)"},
32340 : { (char *)"gpgme_key_t_p_value", _wrap_gpgme_key_t_p_value, METH_VARARGS, (char *)"gpgme_key_t_p_value(obj) -> _gpgme_key"},
32341 : { (char *)"new_gpgme_error_t_p", _wrap_new_gpgme_error_t_p, METH_VARARGS, (char *)"new_gpgme_error_t_p() -> gpgme_error_t *"},
32342 : { (char *)"copy_gpgme_error_t_p", _wrap_copy_gpgme_error_t_p, METH_VARARGS, (char *)"copy_gpgme_error_t_p(value) -> gpgme_error_t *"},
32343 : { (char *)"delete_gpgme_error_t_p", _wrap_delete_gpgme_error_t_p, METH_VARARGS, (char *)"delete_gpgme_error_t_p(obj)"},
32344 : { (char *)"gpgme_error_t_p_assign", _wrap_gpgme_error_t_p_assign, METH_VARARGS, (char *)"gpgme_error_t_p_assign(obj, value)"},
32345 : { (char *)"gpgme_error_t_p_value", _wrap_gpgme_error_t_p_value, METH_VARARGS, (char *)"gpgme_error_t_p_value(obj) -> gpgme_error_t"},
32346 : { (char *)"new_gpgme_trust_item_t_p", _wrap_new_gpgme_trust_item_t_p, METH_VARARGS, (char *)"new_gpgme_trust_item_t_p() -> gpgme_trust_item_t *"},
32347 : { (char *)"copy_gpgme_trust_item_t_p", _wrap_copy_gpgme_trust_item_t_p, METH_VARARGS, (char *)"copy_gpgme_trust_item_t_p(value) -> gpgme_trust_item_t *"},
32348 : { (char *)"delete_gpgme_trust_item_t_p", _wrap_delete_gpgme_trust_item_t_p, METH_VARARGS, (char *)"delete_gpgme_trust_item_t_p(obj)"},
32349 : { (char *)"gpgme_trust_item_t_p_assign", _wrap_gpgme_trust_item_t_p_assign, METH_VARARGS, (char *)"gpgme_trust_item_t_p_assign(obj, value)"},
32350 : { (char *)"gpgme_trust_item_t_p_value", _wrap_gpgme_trust_item_t_p_value, METH_VARARGS, (char *)"gpgme_trust_item_t_p_value(obj) -> _gpgme_trust_item"},
32351 : { (char *)"new_gpgme_engine_info_t_p", _wrap_new_gpgme_engine_info_t_p, METH_VARARGS, (char *)"new_gpgme_engine_info_t_p() -> gpgme_engine_info_t *"},
32352 : { (char *)"copy_gpgme_engine_info_t_p", _wrap_copy_gpgme_engine_info_t_p, METH_VARARGS, (char *)"copy_gpgme_engine_info_t_p(value) -> gpgme_engine_info_t *"},
32353 : { (char *)"delete_gpgme_engine_info_t_p", _wrap_delete_gpgme_engine_info_t_p, METH_VARARGS, (char *)"delete_gpgme_engine_info_t_p(obj)"},
32354 : { (char *)"gpgme_engine_info_t_p_assign", _wrap_gpgme_engine_info_t_p_assign, METH_VARARGS, (char *)"gpgme_engine_info_t_p_assign(obj, value)"},
32355 : { (char *)"gpgme_engine_info_t_p_value", _wrap_gpgme_engine_info_t_p_value, METH_VARARGS, (char *)"gpgme_engine_info_t_p_value(obj) -> _gpgme_engine_info"},
32356 : { (char *)"fdopen", _wrap_fdopen, METH_VARARGS, (char *)"fdopen(fildes, mode) -> FILE *"},
32357 : { (char *)"pyme_raise_callback_exception", _wrap_pyme_raise_callback_exception, METH_VARARGS, (char *)"pyme_raise_callback_exception(self) -> PyObject *"},
32358 : { (char *)"pyme_set_passphrase_cb", _wrap_pyme_set_passphrase_cb, METH_VARARGS, (char *)"pyme_set_passphrase_cb(self, cb) -> PyObject *"},
32359 : { (char *)"pyme_set_progress_cb", _wrap_pyme_set_progress_cb, METH_VARARGS, (char *)"pyme_set_progress_cb(self, cb) -> PyObject *"},
32360 : { (char *)"pyme_set_status_cb", _wrap_pyme_set_status_cb, METH_VARARGS, (char *)"pyme_set_status_cb(self, cb) -> PyObject *"},
32361 : { (char *)"pyme_data_new_from_cbs", _wrap_pyme_data_new_from_cbs, METH_VARARGS, (char *)"pyme_data_new_from_cbs(self, pycbs, r_data) -> PyObject *"},
32362 : { NULL, NULL, 0, NULL }
32363 : };
32364 :
32365 30 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_sig_notation)
32366 : static SwigPyGetSet _gpgme_sig_notation_name_getset = { _wrap__gpgme_sig_notation_name_get, _wrap__gpgme_sig_notation_name_set };
32367 : static SwigPyGetSet _gpgme_sig_notation_critical_getset = { _wrap__gpgme_sig_notation_critical_get, _wrap__gpgme_sig_notation_critical_set };
32368 : static SwigPyGetSet _gpgme_sig_notation_value_getset = { _wrap__gpgme_sig_notation_value_get, _wrap__gpgme_sig_notation_value_set };
32369 : static SwigPyGetSet _gpgme_sig_notation_human_readable_getset = { _wrap__gpgme_sig_notation_human_readable_get, _wrap__gpgme_sig_notation_human_readable_set };
32370 : static SwigPyGetSet _gpgme_sig_notation_flags_getset = { _wrap__gpgme_sig_notation_flags_get, _wrap__gpgme_sig_notation_flags_set };
32371 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_sig_notation_getset[] = {
32372 : { (char*) "name", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_sig_notation.name", (void*) &_gpgme_sig_notation_name_getset }
32373 : ,
32374 : { (char*) "critical", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_sig_notation.critical", (void*) &_gpgme_sig_notation_critical_getset }
32375 : ,
32376 : { (char*) "value", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_sig_notation.value", (void*) &_gpgme_sig_notation_value_getset }
32377 : ,
32378 : { (char*) "human_readable", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_sig_notation.human_readable", (void*) &_gpgme_sig_notation_human_readable_getset }
32379 : ,
32380 : { (char*) "flags", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_sig_notation.flags", (void*) &_gpgme_sig_notation_flags_getset }
32381 : ,
32382 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
32383 : };
32384 :
32385 : SWIGINTERN PyObject *
32386 0 : SwigPyBuiltin___gpgme_sig_notation_richcompare(PyObject *self, PyObject *other, int op) {
32387 0 : PyObject *result = NULL;
32388 0 : PyObject *tuple = PyTuple_New(1);
32389 : assert(tuple);
32390 0 : PyTuple_SET_ITEM(tuple, 0, other);
32391 0 : Py_XINCREF(other);
32392 : if (!result) {
32393 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
32394 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
32395 : } else {
32396 0 : result = Py_NotImplemented;
32397 0 : Py_INCREF(result);
32398 : }
32399 : }
32400 0 : Py_DECREF(tuple);
32401 0 : return result;
32402 : }
32403 :
32404 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_sig_notation_methods[] = {
32405 : { NULL, NULL, 0, NULL } /* Sentinel */
32406 : };
32407 :
32408 : static PyHeapTypeObject SwigPyBuiltin___gpgme_sig_notation_type = {
32409 : {
32410 : #if PY_VERSION_HEX >= 0x03000000
32411 : PyVarObject_HEAD_INIT(NULL, 0)
32412 : #else
32413 : PyObject_HEAD_INIT(NULL)
32414 : 0, /* ob_size */
32415 : #endif
32416 : "_gpgme_sig_notation", /* tp_name */
32417 : sizeof(SwigPyObject), /* tp_basicsize */
32418 : 0, /* tp_itemsize */
32419 : (destructor) _wrap_delete__gpgme_sig_notation_closure, /* tp_dealloc */
32420 : (printfunc) 0, /* tp_print */
32421 : (getattrfunc) 0, /* tp_getattr */
32422 : (setattrfunc) 0, /* tp_setattr */
32423 : #if PY_VERSION_HEX >= 0x03000000
32424 : 0, /* tp_compare */
32425 : #else
32426 : (cmpfunc) 0, /* tp_compare */
32427 : #endif
32428 : (reprfunc) 0, /* tp_repr */
32429 : &SwigPyBuiltin___gpgme_sig_notation_type.as_number, /* tp_as_number */
32430 : &SwigPyBuiltin___gpgme_sig_notation_type.as_sequence, /* tp_as_sequence */
32431 : &SwigPyBuiltin___gpgme_sig_notation_type.as_mapping, /* tp_as_mapping */
32432 : (hashfunc) 0, /* tp_hash */
32433 : (ternaryfunc) 0, /* tp_call */
32434 : (reprfunc) 0, /* tp_str */
32435 : (getattrofunc) 0, /* tp_getattro */
32436 : (setattrofunc) 0, /* tp_setattro */
32437 : &SwigPyBuiltin___gpgme_sig_notation_type.as_buffer, /* tp_as_buffer */
32438 : #if PY_VERSION_HEX >= 0x03000000
32439 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
32440 : #else
32441 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
32442 : #endif
32443 : "::_gpgme_sig_notation", /* tp_doc */
32444 : (traverseproc) 0, /* tp_traverse */
32445 : (inquiry) 0, /* tp_clear */
32446 : (richcmpfunc) SwigPyBuiltin___gpgme_sig_notation_richcompare, /* feature:python:tp_richcompare */
32447 : 0, /* tp_weaklistoffset */
32448 : (getiterfunc) 0, /* tp_iter */
32449 : (iternextfunc) 0, /* tp_iternext */
32450 : SwigPyBuiltin___gpgme_sig_notation_methods, /* tp_methods */
32451 : 0, /* tp_members */
32452 : SwigPyBuiltin___gpgme_sig_notation_getset, /* tp_getset */
32453 : 0, /* tp_base */
32454 : 0, /* tp_dict */
32455 : (descrgetfunc) 0, /* tp_descr_get */
32456 : (descrsetfunc) 0, /* tp_descr_set */
32457 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
32458 : (initproc) _wrap_new__gpgme_sig_notation, /* tp_init */
32459 : (allocfunc) 0, /* tp_alloc */
32460 : (newfunc) 0, /* tp_new */
32461 : (freefunc) 0, /* tp_free */
32462 : (inquiry) 0, /* tp_is_gc */
32463 : (PyObject*) 0, /* tp_bases */
32464 : (PyObject*) 0, /* tp_mro */
32465 : (PyObject*) 0, /* tp_cache */
32466 : (PyObject*) 0, /* tp_subclasses */
32467 : (PyObject*) 0, /* tp_weaklist */
32468 : (destructor) 0, /* tp_del */
32469 : #if PY_VERSION_HEX >= 0x02060000
32470 : (int) 0, /* tp_version_tag */
32471 : #endif
32472 : },
32473 : {
32474 : (binaryfunc) 0, /* nb_add */
32475 : (binaryfunc) 0, /* nb_subtract */
32476 : (binaryfunc) 0, /* nb_multiply */
32477 : #if PY_VERSION_HEX < 0x03000000
32478 : (binaryfunc) 0, /* nb_divide */
32479 : #endif
32480 : (binaryfunc) 0, /* nb_remainder */
32481 : (binaryfunc) 0, /* nb_divmod */
32482 : (ternaryfunc) 0, /* nb_power */
32483 : (unaryfunc) 0, /* nb_negative */
32484 : (unaryfunc) 0, /* nb_positive */
32485 : (unaryfunc) 0, /* nb_absolute */
32486 : (inquiry) 0, /* nb_nonzero */
32487 : (unaryfunc) 0, /* nb_invert */
32488 : (binaryfunc) 0, /* nb_lshift */
32489 : (binaryfunc) 0, /* nb_rshift */
32490 : (binaryfunc) 0, /* nb_and */
32491 : (binaryfunc) 0, /* nb_xor */
32492 : (binaryfunc) 0, /* nb_or */
32493 : #if PY_VERSION_HEX < 0x03000000
32494 : (coercion) 0, /* nb_coerce */
32495 : #endif
32496 : (unaryfunc) 0, /* nb_int */
32497 : #if PY_VERSION_HEX >= 0x03000000
32498 : (void*) 0, /* nb_reserved */
32499 : #else
32500 : (unaryfunc) 0, /* nb_long */
32501 : #endif
32502 : (unaryfunc) 0, /* nb_float */
32503 : #if PY_VERSION_HEX < 0x03000000
32504 : (unaryfunc) 0, /* nb_oct */
32505 : (unaryfunc) 0, /* nb_hex */
32506 : #endif
32507 : (binaryfunc) 0, /* nb_inplace_add */
32508 : (binaryfunc) 0, /* nb_inplace_subtract */
32509 : (binaryfunc) 0, /* nb_inplace_multiply */
32510 : #if PY_VERSION_HEX < 0x03000000
32511 : (binaryfunc) 0, /* nb_inplace_divide */
32512 : #endif
32513 : (binaryfunc) 0, /* nb_inplace_remainder */
32514 : (ternaryfunc) 0, /* nb_inplace_power */
32515 : (binaryfunc) 0, /* nb_inplace_lshift */
32516 : (binaryfunc) 0, /* nb_inplace_rshift */
32517 : (binaryfunc) 0, /* nb_inplace_and */
32518 : (binaryfunc) 0, /* nb_inplace_xor */
32519 : (binaryfunc) 0, /* nb_inplace_or */
32520 : (binaryfunc) 0, /* nb_floor_divide */
32521 : (binaryfunc) 0, /* nb_true_divide */
32522 : (binaryfunc) 0, /* nb_inplace_floor_divide */
32523 : (binaryfunc) 0, /* nb_inplace_true_divide */
32524 : #if PY_VERSION_HEX >= 0x02050000
32525 : (unaryfunc) 0, /* nb_index */
32526 : #endif
32527 : },
32528 : {
32529 : (lenfunc) 0, /* mp_length */
32530 : (binaryfunc) 0, /* mp_subscript */
32531 : (objobjargproc) 0, /* mp_ass_subscript */
32532 : },
32533 : {
32534 : (lenfunc) 0, /* sq_length */
32535 : (binaryfunc) 0, /* sq_concat */
32536 : (ssizeargfunc) 0, /* sq_repeat */
32537 : (ssizeargfunc) 0, /* sq_item */
32538 : #if PY_VERSION_HEX >= 0x03000000
32539 : (void*) 0, /* was_sq_slice */
32540 : #else
32541 : (ssizessizeargfunc) 0, /* sq_slice */
32542 : #endif
32543 : (ssizeobjargproc) 0, /* sq_ass_item */
32544 : #if PY_VERSION_HEX >= 0x03000000
32545 : (void*) 0, /* was_sq_ass_slice */
32546 : #else
32547 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
32548 : #endif
32549 : (objobjproc) 0, /* sq_contains */
32550 : (binaryfunc) 0, /* sq_inplace_concat */
32551 : (ssizeargfunc) 0, /* sq_inplace_repeat */
32552 : },
32553 : {
32554 : #if PY_VERSION_HEX < 0x03000000
32555 : (readbufferproc) 0, /* bf_getreadbuffer */
32556 : (writebufferproc) 0, /* bf_getwritebuffer */
32557 : (segcountproc) 0, /* bf_getsegcount */
32558 : (charbufferproc) 0, /* bf_getcharbuffer */
32559 : #endif
32560 : #if PY_VERSION_HEX >= 0x02060000
32561 : (getbufferproc) 0, /* bf_getbuffer */
32562 : (releasebufferproc) 0, /* bf_releasebuffer */
32563 : #endif
32564 : },
32565 : (PyObject*) 0, /* ht_name */
32566 : (PyObject*) 0, /* ht_slots */
32567 : };
32568 :
32569 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_sig_notation_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_sig_notation_type};
32570 :
32571 6 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_engine_info)
32572 : static SwigPyGetSet _gpgme_engine_info_file_name_getset = { _wrap__gpgme_engine_info_file_name_get, _wrap__gpgme_engine_info_file_name_set };
32573 : static SwigPyGetSet _gpgme_engine_info_version_getset = { _wrap__gpgme_engine_info_version_get, _wrap__gpgme_engine_info_version_set };
32574 : static SwigPyGetSet _gpgme_engine_info_req_version_getset = { _wrap__gpgme_engine_info_req_version_get, _wrap__gpgme_engine_info_req_version_set };
32575 : static SwigPyGetSet _gpgme_engine_info_protocol_getset = { _wrap__gpgme_engine_info_protocol_get, _wrap__gpgme_engine_info_protocol_set };
32576 : static SwigPyGetSet _gpgme_engine_info_home_dir_getset = { _wrap__gpgme_engine_info_home_dir_get, _wrap__gpgme_engine_info_home_dir_set };
32577 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_engine_info_getset[] = {
32578 : { (char*) "file_name", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_engine_info.file_name", (void*) &_gpgme_engine_info_file_name_getset }
32579 : ,
32580 : { (char*) "version", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_engine_info.version", (void*) &_gpgme_engine_info_version_getset }
32581 : ,
32582 : { (char*) "req_version", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_engine_info.req_version", (void*) &_gpgme_engine_info_req_version_getset }
32583 : ,
32584 : { (char*) "protocol", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_engine_info.protocol", (void*) &_gpgme_engine_info_protocol_getset }
32585 : ,
32586 : { (char*) "home_dir", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_engine_info.home_dir", (void*) &_gpgme_engine_info_home_dir_getset }
32587 : ,
32588 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
32589 : };
32590 :
32591 : SWIGINTERN PyObject *
32592 0 : SwigPyBuiltin___gpgme_engine_info_richcompare(PyObject *self, PyObject *other, int op) {
32593 0 : PyObject *result = NULL;
32594 0 : PyObject *tuple = PyTuple_New(1);
32595 : assert(tuple);
32596 0 : PyTuple_SET_ITEM(tuple, 0, other);
32597 0 : Py_XINCREF(other);
32598 : if (!result) {
32599 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
32600 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
32601 : } else {
32602 0 : result = Py_NotImplemented;
32603 0 : Py_INCREF(result);
32604 : }
32605 : }
32606 0 : Py_DECREF(tuple);
32607 0 : return result;
32608 : }
32609 :
32610 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_engine_info_methods[] = {
32611 : { NULL, NULL, 0, NULL } /* Sentinel */
32612 : };
32613 :
32614 : static PyHeapTypeObject SwigPyBuiltin___gpgme_engine_info_type = {
32615 : {
32616 : #if PY_VERSION_HEX >= 0x03000000
32617 : PyVarObject_HEAD_INIT(NULL, 0)
32618 : #else
32619 : PyObject_HEAD_INIT(NULL)
32620 : 0, /* ob_size */
32621 : #endif
32622 : "_gpgme_engine_info", /* tp_name */
32623 : sizeof(SwigPyObject), /* tp_basicsize */
32624 : 0, /* tp_itemsize */
32625 : (destructor) _wrap_delete__gpgme_engine_info_closure, /* tp_dealloc */
32626 : (printfunc) 0, /* tp_print */
32627 : (getattrfunc) 0, /* tp_getattr */
32628 : (setattrfunc) 0, /* tp_setattr */
32629 : #if PY_VERSION_HEX >= 0x03000000
32630 : 0, /* tp_compare */
32631 : #else
32632 : (cmpfunc) 0, /* tp_compare */
32633 : #endif
32634 : (reprfunc) 0, /* tp_repr */
32635 : &SwigPyBuiltin___gpgme_engine_info_type.as_number, /* tp_as_number */
32636 : &SwigPyBuiltin___gpgme_engine_info_type.as_sequence, /* tp_as_sequence */
32637 : &SwigPyBuiltin___gpgme_engine_info_type.as_mapping, /* tp_as_mapping */
32638 : (hashfunc) 0, /* tp_hash */
32639 : (ternaryfunc) 0, /* tp_call */
32640 : (reprfunc) 0, /* tp_str */
32641 : (getattrofunc) 0, /* tp_getattro */
32642 : (setattrofunc) 0, /* tp_setattro */
32643 : &SwigPyBuiltin___gpgme_engine_info_type.as_buffer, /* tp_as_buffer */
32644 : #if PY_VERSION_HEX >= 0x03000000
32645 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
32646 : #else
32647 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
32648 : #endif
32649 : "::_gpgme_engine_info", /* tp_doc */
32650 : (traverseproc) 0, /* tp_traverse */
32651 : (inquiry) 0, /* tp_clear */
32652 : (richcmpfunc) SwigPyBuiltin___gpgme_engine_info_richcompare, /* feature:python:tp_richcompare */
32653 : 0, /* tp_weaklistoffset */
32654 : (getiterfunc) 0, /* tp_iter */
32655 : (iternextfunc) 0, /* tp_iternext */
32656 : SwigPyBuiltin___gpgme_engine_info_methods, /* tp_methods */
32657 : 0, /* tp_members */
32658 : SwigPyBuiltin___gpgme_engine_info_getset, /* tp_getset */
32659 : 0, /* tp_base */
32660 : 0, /* tp_dict */
32661 : (descrgetfunc) 0, /* tp_descr_get */
32662 : (descrsetfunc) 0, /* tp_descr_set */
32663 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
32664 : (initproc) _wrap_new__gpgme_engine_info, /* tp_init */
32665 : (allocfunc) 0, /* tp_alloc */
32666 : (newfunc) 0, /* tp_new */
32667 : (freefunc) 0, /* tp_free */
32668 : (inquiry) 0, /* tp_is_gc */
32669 : (PyObject*) 0, /* tp_bases */
32670 : (PyObject*) 0, /* tp_mro */
32671 : (PyObject*) 0, /* tp_cache */
32672 : (PyObject*) 0, /* tp_subclasses */
32673 : (PyObject*) 0, /* tp_weaklist */
32674 : (destructor) 0, /* tp_del */
32675 : #if PY_VERSION_HEX >= 0x02060000
32676 : (int) 0, /* tp_version_tag */
32677 : #endif
32678 : },
32679 : {
32680 : (binaryfunc) 0, /* nb_add */
32681 : (binaryfunc) 0, /* nb_subtract */
32682 : (binaryfunc) 0, /* nb_multiply */
32683 : #if PY_VERSION_HEX < 0x03000000
32684 : (binaryfunc) 0, /* nb_divide */
32685 : #endif
32686 : (binaryfunc) 0, /* nb_remainder */
32687 : (binaryfunc) 0, /* nb_divmod */
32688 : (ternaryfunc) 0, /* nb_power */
32689 : (unaryfunc) 0, /* nb_negative */
32690 : (unaryfunc) 0, /* nb_positive */
32691 : (unaryfunc) 0, /* nb_absolute */
32692 : (inquiry) 0, /* nb_nonzero */
32693 : (unaryfunc) 0, /* nb_invert */
32694 : (binaryfunc) 0, /* nb_lshift */
32695 : (binaryfunc) 0, /* nb_rshift */
32696 : (binaryfunc) 0, /* nb_and */
32697 : (binaryfunc) 0, /* nb_xor */
32698 : (binaryfunc) 0, /* nb_or */
32699 : #if PY_VERSION_HEX < 0x03000000
32700 : (coercion) 0, /* nb_coerce */
32701 : #endif
32702 : (unaryfunc) 0, /* nb_int */
32703 : #if PY_VERSION_HEX >= 0x03000000
32704 : (void*) 0, /* nb_reserved */
32705 : #else
32706 : (unaryfunc) 0, /* nb_long */
32707 : #endif
32708 : (unaryfunc) 0, /* nb_float */
32709 : #if PY_VERSION_HEX < 0x03000000
32710 : (unaryfunc) 0, /* nb_oct */
32711 : (unaryfunc) 0, /* nb_hex */
32712 : #endif
32713 : (binaryfunc) 0, /* nb_inplace_add */
32714 : (binaryfunc) 0, /* nb_inplace_subtract */
32715 : (binaryfunc) 0, /* nb_inplace_multiply */
32716 : #if PY_VERSION_HEX < 0x03000000
32717 : (binaryfunc) 0, /* nb_inplace_divide */
32718 : #endif
32719 : (binaryfunc) 0, /* nb_inplace_remainder */
32720 : (ternaryfunc) 0, /* nb_inplace_power */
32721 : (binaryfunc) 0, /* nb_inplace_lshift */
32722 : (binaryfunc) 0, /* nb_inplace_rshift */
32723 : (binaryfunc) 0, /* nb_inplace_and */
32724 : (binaryfunc) 0, /* nb_inplace_xor */
32725 : (binaryfunc) 0, /* nb_inplace_or */
32726 : (binaryfunc) 0, /* nb_floor_divide */
32727 : (binaryfunc) 0, /* nb_true_divide */
32728 : (binaryfunc) 0, /* nb_inplace_floor_divide */
32729 : (binaryfunc) 0, /* nb_inplace_true_divide */
32730 : #if PY_VERSION_HEX >= 0x02050000
32731 : (unaryfunc) 0, /* nb_index */
32732 : #endif
32733 : },
32734 : {
32735 : (lenfunc) 0, /* mp_length */
32736 : (binaryfunc) 0, /* mp_subscript */
32737 : (objobjargproc) 0, /* mp_ass_subscript */
32738 : },
32739 : {
32740 : (lenfunc) 0, /* sq_length */
32741 : (binaryfunc) 0, /* sq_concat */
32742 : (ssizeargfunc) 0, /* sq_repeat */
32743 : (ssizeargfunc) 0, /* sq_item */
32744 : #if PY_VERSION_HEX >= 0x03000000
32745 : (void*) 0, /* was_sq_slice */
32746 : #else
32747 : (ssizessizeargfunc) 0, /* sq_slice */
32748 : #endif
32749 : (ssizeobjargproc) 0, /* sq_ass_item */
32750 : #if PY_VERSION_HEX >= 0x03000000
32751 : (void*) 0, /* was_sq_ass_slice */
32752 : #else
32753 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
32754 : #endif
32755 : (objobjproc) 0, /* sq_contains */
32756 : (binaryfunc) 0, /* sq_inplace_concat */
32757 : (ssizeargfunc) 0, /* sq_inplace_repeat */
32758 : },
32759 : {
32760 : #if PY_VERSION_HEX < 0x03000000
32761 : (readbufferproc) 0, /* bf_getreadbuffer */
32762 : (writebufferproc) 0, /* bf_getwritebuffer */
32763 : (segcountproc) 0, /* bf_getsegcount */
32764 : (charbufferproc) 0, /* bf_getcharbuffer */
32765 : #endif
32766 : #if PY_VERSION_HEX >= 0x02060000
32767 : (getbufferproc) 0, /* bf_getbuffer */
32768 : (releasebufferproc) 0, /* bf_releasebuffer */
32769 : #endif
32770 : },
32771 : (PyObject*) 0, /* ht_name */
32772 : (PyObject*) 0, /* ht_slots */
32773 : };
32774 :
32775 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_engine_info_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_engine_info_type};
32776 :
32777 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_tofu_info)
32778 : static SwigPyGetSet _gpgme_tofu_info__rfu_getset = { _wrap__gpgme_tofu_info__rfu_get, _wrap__gpgme_tofu_info__rfu_set };
32779 : static SwigPyGetSet _gpgme_tofu_info_signfirst_getset = { _wrap__gpgme_tofu_info_signfirst_get, _wrap__gpgme_tofu_info_signfirst_set };
32780 : static SwigPyGetSet _gpgme_tofu_info_validity_getset = { _wrap__gpgme_tofu_info_validity_get, _wrap__gpgme_tofu_info_validity_set };
32781 : static SwigPyGetSet _gpgme_tofu_info_signcount_getset = { _wrap__gpgme_tofu_info_signcount_get, _wrap__gpgme_tofu_info_signcount_set };
32782 : static SwigPyGetSet _gpgme_tofu_info_signlast_getset = { _wrap__gpgme_tofu_info_signlast_get, _wrap__gpgme_tofu_info_signlast_set };
32783 : static SwigPyGetSet _gpgme_tofu_info_encrfirst_getset = { _wrap__gpgme_tofu_info_encrfirst_get, _wrap__gpgme_tofu_info_encrfirst_set };
32784 : static SwigPyGetSet _gpgme_tofu_info_policy_getset = { _wrap__gpgme_tofu_info_policy_get, _wrap__gpgme_tofu_info_policy_set };
32785 : static SwigPyGetSet _gpgme_tofu_info_encrcount_getset = { _wrap__gpgme_tofu_info_encrcount_get, _wrap__gpgme_tofu_info_encrcount_set };
32786 : static SwigPyGetSet _gpgme_tofu_info_description_getset = { _wrap__gpgme_tofu_info_description_get, _wrap__gpgme_tofu_info_description_set };
32787 : static SwigPyGetSet _gpgme_tofu_info_encrlast_getset = { _wrap__gpgme_tofu_info_encrlast_get, _wrap__gpgme_tofu_info_encrlast_set };
32788 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_tofu_info_getset[] = {
32789 : { (char*) "_rfu", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_tofu_info._rfu", (void*) &_gpgme_tofu_info__rfu_getset }
32790 : ,
32791 : { (char*) "signfirst", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_tofu_info.signfirst", (void*) &_gpgme_tofu_info_signfirst_getset }
32792 : ,
32793 : { (char*) "validity", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_tofu_info.validity", (void*) &_gpgme_tofu_info_validity_getset }
32794 : ,
32795 : { (char*) "signcount", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_tofu_info.signcount", (void*) &_gpgme_tofu_info_signcount_getset }
32796 : ,
32797 : { (char*) "signlast", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_tofu_info.signlast", (void*) &_gpgme_tofu_info_signlast_getset }
32798 : ,
32799 : { (char*) "encrfirst", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_tofu_info.encrfirst", (void*) &_gpgme_tofu_info_encrfirst_getset }
32800 : ,
32801 : { (char*) "policy", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_tofu_info.policy", (void*) &_gpgme_tofu_info_policy_getset }
32802 : ,
32803 : { (char*) "encrcount", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_tofu_info.encrcount", (void*) &_gpgme_tofu_info_encrcount_getset }
32804 : ,
32805 : { (char*) "description", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_tofu_info.description", (void*) &_gpgme_tofu_info_description_getset }
32806 : ,
32807 : { (char*) "encrlast", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_tofu_info.encrlast", (void*) &_gpgme_tofu_info_encrlast_getset }
32808 : ,
32809 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
32810 : };
32811 :
32812 : SWIGINTERN PyObject *
32813 0 : SwigPyBuiltin___gpgme_tofu_info_richcompare(PyObject *self, PyObject *other, int op) {
32814 0 : PyObject *result = NULL;
32815 0 : PyObject *tuple = PyTuple_New(1);
32816 : assert(tuple);
32817 0 : PyTuple_SET_ITEM(tuple, 0, other);
32818 0 : Py_XINCREF(other);
32819 : if (!result) {
32820 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
32821 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
32822 : } else {
32823 0 : result = Py_NotImplemented;
32824 0 : Py_INCREF(result);
32825 : }
32826 : }
32827 0 : Py_DECREF(tuple);
32828 0 : return result;
32829 : }
32830 :
32831 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_tofu_info_methods[] = {
32832 : { NULL, NULL, 0, NULL } /* Sentinel */
32833 : };
32834 :
32835 : static PyHeapTypeObject SwigPyBuiltin___gpgme_tofu_info_type = {
32836 : {
32837 : #if PY_VERSION_HEX >= 0x03000000
32838 : PyVarObject_HEAD_INIT(NULL, 0)
32839 : #else
32840 : PyObject_HEAD_INIT(NULL)
32841 : 0, /* ob_size */
32842 : #endif
32843 : "_gpgme_tofu_info", /* tp_name */
32844 : sizeof(SwigPyObject), /* tp_basicsize */
32845 : 0, /* tp_itemsize */
32846 : (destructor) _wrap_delete__gpgme_tofu_info_closure, /* tp_dealloc */
32847 : (printfunc) 0, /* tp_print */
32848 : (getattrfunc) 0, /* tp_getattr */
32849 : (setattrfunc) 0, /* tp_setattr */
32850 : #if PY_VERSION_HEX >= 0x03000000
32851 : 0, /* tp_compare */
32852 : #else
32853 : (cmpfunc) 0, /* tp_compare */
32854 : #endif
32855 : (reprfunc) 0, /* tp_repr */
32856 : &SwigPyBuiltin___gpgme_tofu_info_type.as_number, /* tp_as_number */
32857 : &SwigPyBuiltin___gpgme_tofu_info_type.as_sequence, /* tp_as_sequence */
32858 : &SwigPyBuiltin___gpgme_tofu_info_type.as_mapping, /* tp_as_mapping */
32859 : (hashfunc) 0, /* tp_hash */
32860 : (ternaryfunc) 0, /* tp_call */
32861 : (reprfunc) 0, /* tp_str */
32862 : (getattrofunc) 0, /* tp_getattro */
32863 : (setattrofunc) 0, /* tp_setattro */
32864 : &SwigPyBuiltin___gpgme_tofu_info_type.as_buffer, /* tp_as_buffer */
32865 : #if PY_VERSION_HEX >= 0x03000000
32866 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
32867 : #else
32868 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
32869 : #endif
32870 : "::_gpgme_tofu_info", /* tp_doc */
32871 : (traverseproc) 0, /* tp_traverse */
32872 : (inquiry) 0, /* tp_clear */
32873 : (richcmpfunc) SwigPyBuiltin___gpgme_tofu_info_richcompare, /* feature:python:tp_richcompare */
32874 : 0, /* tp_weaklistoffset */
32875 : (getiterfunc) 0, /* tp_iter */
32876 : (iternextfunc) 0, /* tp_iternext */
32877 : SwigPyBuiltin___gpgme_tofu_info_methods, /* tp_methods */
32878 : 0, /* tp_members */
32879 : SwigPyBuiltin___gpgme_tofu_info_getset, /* tp_getset */
32880 : 0, /* tp_base */
32881 : 0, /* tp_dict */
32882 : (descrgetfunc) 0, /* tp_descr_get */
32883 : (descrsetfunc) 0, /* tp_descr_set */
32884 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
32885 : (initproc) _wrap_new__gpgme_tofu_info, /* tp_init */
32886 : (allocfunc) 0, /* tp_alloc */
32887 : (newfunc) 0, /* tp_new */
32888 : (freefunc) 0, /* tp_free */
32889 : (inquiry) 0, /* tp_is_gc */
32890 : (PyObject*) 0, /* tp_bases */
32891 : (PyObject*) 0, /* tp_mro */
32892 : (PyObject*) 0, /* tp_cache */
32893 : (PyObject*) 0, /* tp_subclasses */
32894 : (PyObject*) 0, /* tp_weaklist */
32895 : (destructor) 0, /* tp_del */
32896 : #if PY_VERSION_HEX >= 0x02060000
32897 : (int) 0, /* tp_version_tag */
32898 : #endif
32899 : },
32900 : {
32901 : (binaryfunc) 0, /* nb_add */
32902 : (binaryfunc) 0, /* nb_subtract */
32903 : (binaryfunc) 0, /* nb_multiply */
32904 : #if PY_VERSION_HEX < 0x03000000
32905 : (binaryfunc) 0, /* nb_divide */
32906 : #endif
32907 : (binaryfunc) 0, /* nb_remainder */
32908 : (binaryfunc) 0, /* nb_divmod */
32909 : (ternaryfunc) 0, /* nb_power */
32910 : (unaryfunc) 0, /* nb_negative */
32911 : (unaryfunc) 0, /* nb_positive */
32912 : (unaryfunc) 0, /* nb_absolute */
32913 : (inquiry) 0, /* nb_nonzero */
32914 : (unaryfunc) 0, /* nb_invert */
32915 : (binaryfunc) 0, /* nb_lshift */
32916 : (binaryfunc) 0, /* nb_rshift */
32917 : (binaryfunc) 0, /* nb_and */
32918 : (binaryfunc) 0, /* nb_xor */
32919 : (binaryfunc) 0, /* nb_or */
32920 : #if PY_VERSION_HEX < 0x03000000
32921 : (coercion) 0, /* nb_coerce */
32922 : #endif
32923 : (unaryfunc) 0, /* nb_int */
32924 : #if PY_VERSION_HEX >= 0x03000000
32925 : (void*) 0, /* nb_reserved */
32926 : #else
32927 : (unaryfunc) 0, /* nb_long */
32928 : #endif
32929 : (unaryfunc) 0, /* nb_float */
32930 : #if PY_VERSION_HEX < 0x03000000
32931 : (unaryfunc) 0, /* nb_oct */
32932 : (unaryfunc) 0, /* nb_hex */
32933 : #endif
32934 : (binaryfunc) 0, /* nb_inplace_add */
32935 : (binaryfunc) 0, /* nb_inplace_subtract */
32936 : (binaryfunc) 0, /* nb_inplace_multiply */
32937 : #if PY_VERSION_HEX < 0x03000000
32938 : (binaryfunc) 0, /* nb_inplace_divide */
32939 : #endif
32940 : (binaryfunc) 0, /* nb_inplace_remainder */
32941 : (ternaryfunc) 0, /* nb_inplace_power */
32942 : (binaryfunc) 0, /* nb_inplace_lshift */
32943 : (binaryfunc) 0, /* nb_inplace_rshift */
32944 : (binaryfunc) 0, /* nb_inplace_and */
32945 : (binaryfunc) 0, /* nb_inplace_xor */
32946 : (binaryfunc) 0, /* nb_inplace_or */
32947 : (binaryfunc) 0, /* nb_floor_divide */
32948 : (binaryfunc) 0, /* nb_true_divide */
32949 : (binaryfunc) 0, /* nb_inplace_floor_divide */
32950 : (binaryfunc) 0, /* nb_inplace_true_divide */
32951 : #if PY_VERSION_HEX >= 0x02050000
32952 : (unaryfunc) 0, /* nb_index */
32953 : #endif
32954 : },
32955 : {
32956 : (lenfunc) 0, /* mp_length */
32957 : (binaryfunc) 0, /* mp_subscript */
32958 : (objobjargproc) 0, /* mp_ass_subscript */
32959 : },
32960 : {
32961 : (lenfunc) 0, /* sq_length */
32962 : (binaryfunc) 0, /* sq_concat */
32963 : (ssizeargfunc) 0, /* sq_repeat */
32964 : (ssizeargfunc) 0, /* sq_item */
32965 : #if PY_VERSION_HEX >= 0x03000000
32966 : (void*) 0, /* was_sq_slice */
32967 : #else
32968 : (ssizessizeargfunc) 0, /* sq_slice */
32969 : #endif
32970 : (ssizeobjargproc) 0, /* sq_ass_item */
32971 : #if PY_VERSION_HEX >= 0x03000000
32972 : (void*) 0, /* was_sq_ass_slice */
32973 : #else
32974 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
32975 : #endif
32976 : (objobjproc) 0, /* sq_contains */
32977 : (binaryfunc) 0, /* sq_inplace_concat */
32978 : (ssizeargfunc) 0, /* sq_inplace_repeat */
32979 : },
32980 : {
32981 : #if PY_VERSION_HEX < 0x03000000
32982 : (readbufferproc) 0, /* bf_getreadbuffer */
32983 : (writebufferproc) 0, /* bf_getwritebuffer */
32984 : (segcountproc) 0, /* bf_getsegcount */
32985 : (charbufferproc) 0, /* bf_getcharbuffer */
32986 : #endif
32987 : #if PY_VERSION_HEX >= 0x02060000
32988 : (getbufferproc) 0, /* bf_getbuffer */
32989 : (releasebufferproc) 0, /* bf_releasebuffer */
32990 : #endif
32991 : },
32992 : (PyObject*) 0, /* ht_name */
32993 : (PyObject*) 0, /* ht_slots */
32994 : };
32995 :
32996 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_tofu_info_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_tofu_info_type};
32997 :
32998 352 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_subkey)
32999 : static SwigPyGetSet _gpgme_subkey__unused_getset = { _wrap__gpgme_subkey__unused_get, _wrap__gpgme_subkey__unused_set };
33000 : static SwigPyGetSet _gpgme_subkey_invalid_getset = { _wrap__gpgme_subkey_invalid_get, _wrap__gpgme_subkey_invalid_set };
33001 : static SwigPyGetSet _gpgme_subkey_can_sign_getset = { _wrap__gpgme_subkey_can_sign_get, _wrap__gpgme_subkey_can_sign_set };
33002 : static SwigPyGetSet _gpgme_subkey_curve_getset = { _wrap__gpgme_subkey_curve_get, _wrap__gpgme_subkey_curve_set };
33003 : static SwigPyGetSet _gpgme_subkey_keygrip_getset = { _wrap__gpgme_subkey_keygrip_get, _wrap__gpgme_subkey_keygrip_set };
33004 : static SwigPyGetSet _gpgme_subkey_can_certify_getset = { _wrap__gpgme_subkey_can_certify_get, _wrap__gpgme_subkey_can_certify_set };
33005 : static SwigPyGetSet _gpgme_subkey_length_getset = { _wrap__gpgme_subkey_length_get, _wrap__gpgme_subkey_length_set };
33006 : static SwigPyGetSet _gpgme_subkey_keyid_getset = { _wrap__gpgme_subkey_keyid_get, _wrap__gpgme_subkey_keyid_set };
33007 : static SwigPyGetSet _gpgme_subkey_secret_getset = { _wrap__gpgme_subkey_secret_get, _wrap__gpgme_subkey_secret_set };
33008 : static SwigPyGetSet _gpgme_subkey_can_encrypt_getset = { _wrap__gpgme_subkey_can_encrypt_get, _wrap__gpgme_subkey_can_encrypt_set };
33009 : static SwigPyGetSet _gpgme_subkey_revoked_getset = { _wrap__gpgme_subkey_revoked_get, _wrap__gpgme_subkey_revoked_set };
33010 : static SwigPyGetSet _gpgme_subkey_card_number_getset = { _wrap__gpgme_subkey_card_number_get, _wrap__gpgme_subkey_card_number_set };
33011 : static SwigPyGetSet _gpgme_subkey_can_authenticate_getset = { _wrap__gpgme_subkey_can_authenticate_get, _wrap__gpgme_subkey_can_authenticate_set };
33012 : static SwigPyGetSet _gpgme_subkey_pubkey_algo_getset = { _wrap__gpgme_subkey_pubkey_algo_get, _wrap__gpgme_subkey_pubkey_algo_set };
33013 : static SwigPyGetSet _gpgme_subkey_fpr_getset = { _wrap__gpgme_subkey_fpr_get, _wrap__gpgme_subkey_fpr_set };
33014 : static SwigPyGetSet _gpgme_subkey_expires_getset = { _wrap__gpgme_subkey_expires_get, _wrap__gpgme_subkey_expires_set };
33015 : static SwigPyGetSet _gpgme_subkey_expired_getset = { _wrap__gpgme_subkey_expired_get, _wrap__gpgme_subkey_expired_set };
33016 : static SwigPyGetSet _gpgme_subkey_is_cardkey_getset = { _wrap__gpgme_subkey_is_cardkey_get, _wrap__gpgme_subkey_is_cardkey_set };
33017 : static SwigPyGetSet _gpgme_subkey_disabled_getset = { _wrap__gpgme_subkey_disabled_get, _wrap__gpgme_subkey_disabled_set };
33018 : static SwigPyGetSet _gpgme_subkey__keyid_getset = { _wrap__gpgme_subkey__keyid_get, _wrap__gpgme_subkey__keyid_set };
33019 : static SwigPyGetSet _gpgme_subkey_timestamp_getset = { _wrap__gpgme_subkey_timestamp_get, _wrap__gpgme_subkey_timestamp_set };
33020 : static SwigPyGetSet _gpgme_subkey_is_qualified_getset = { _wrap__gpgme_subkey_is_qualified_get, _wrap__gpgme_subkey_is_qualified_set };
33021 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_subkey_getset[] = {
33022 : { (char*) "_unused", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey._unused", (void*) &_gpgme_subkey__unused_getset }
33023 : ,
33024 : { (char*) "invalid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.invalid", (void*) &_gpgme_subkey_invalid_getset }
33025 : ,
33026 : { (char*) "can_sign", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.can_sign", (void*) &_gpgme_subkey_can_sign_getset }
33027 : ,
33028 : { (char*) "curve", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.curve", (void*) &_gpgme_subkey_curve_getset }
33029 : ,
33030 : { (char*) "keygrip", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.keygrip", (void*) &_gpgme_subkey_keygrip_getset }
33031 : ,
33032 : { (char*) "can_certify", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.can_certify", (void*) &_gpgme_subkey_can_certify_getset }
33033 : ,
33034 : { (char*) "length", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.length", (void*) &_gpgme_subkey_length_getset }
33035 : ,
33036 : { (char*) "keyid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.keyid", (void*) &_gpgme_subkey_keyid_getset }
33037 : ,
33038 : { (char*) "secret", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.secret", (void*) &_gpgme_subkey_secret_getset }
33039 : ,
33040 : { (char*) "can_encrypt", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.can_encrypt", (void*) &_gpgme_subkey_can_encrypt_getset }
33041 : ,
33042 : { (char*) "revoked", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.revoked", (void*) &_gpgme_subkey_revoked_getset }
33043 : ,
33044 : { (char*) "card_number", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.card_number", (void*) &_gpgme_subkey_card_number_getset }
33045 : ,
33046 : { (char*) "can_authenticate", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.can_authenticate", (void*) &_gpgme_subkey_can_authenticate_getset }
33047 : ,
33048 : { (char*) "pubkey_algo", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.pubkey_algo", (void*) &_gpgme_subkey_pubkey_algo_getset }
33049 : ,
33050 : { (char*) "fpr", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.fpr", (void*) &_gpgme_subkey_fpr_getset }
33051 : ,
33052 : { (char*) "expires", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.expires", (void*) &_gpgme_subkey_expires_getset }
33053 : ,
33054 : { (char*) "expired", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.expired", (void*) &_gpgme_subkey_expired_getset }
33055 : ,
33056 : { (char*) "is_cardkey", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.is_cardkey", (void*) &_gpgme_subkey_is_cardkey_getset }
33057 : ,
33058 : { (char*) "disabled", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.disabled", (void*) &_gpgme_subkey_disabled_getset }
33059 : ,
33060 : { (char*) "_keyid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey._keyid", (void*) &_gpgme_subkey__keyid_getset }
33061 : ,
33062 : { (char*) "timestamp", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.timestamp", (void*) &_gpgme_subkey_timestamp_getset }
33063 : ,
33064 : { (char*) "is_qualified", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_subkey.is_qualified", (void*) &_gpgme_subkey_is_qualified_getset }
33065 : ,
33066 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
33067 : };
33068 :
33069 : SWIGINTERN PyObject *
33070 0 : SwigPyBuiltin___gpgme_subkey_richcompare(PyObject *self, PyObject *other, int op) {
33071 0 : PyObject *result = NULL;
33072 0 : PyObject *tuple = PyTuple_New(1);
33073 : assert(tuple);
33074 0 : PyTuple_SET_ITEM(tuple, 0, other);
33075 0 : Py_XINCREF(other);
33076 : if (!result) {
33077 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
33078 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
33079 : } else {
33080 0 : result = Py_NotImplemented;
33081 0 : Py_INCREF(result);
33082 : }
33083 : }
33084 0 : Py_DECREF(tuple);
33085 0 : return result;
33086 : }
33087 :
33088 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_subkey_methods[] = {
33089 : { NULL, NULL, 0, NULL } /* Sentinel */
33090 : };
33091 :
33092 : static PyHeapTypeObject SwigPyBuiltin___gpgme_subkey_type = {
33093 : {
33094 : #if PY_VERSION_HEX >= 0x03000000
33095 : PyVarObject_HEAD_INIT(NULL, 0)
33096 : #else
33097 : PyObject_HEAD_INIT(NULL)
33098 : 0, /* ob_size */
33099 : #endif
33100 : "_gpgme_subkey", /* tp_name */
33101 : sizeof(SwigPyObject), /* tp_basicsize */
33102 : 0, /* tp_itemsize */
33103 : (destructor) _wrap_delete__gpgme_subkey_closure, /* tp_dealloc */
33104 : (printfunc) 0, /* tp_print */
33105 : (getattrfunc) 0, /* tp_getattr */
33106 : (setattrfunc) 0, /* tp_setattr */
33107 : #if PY_VERSION_HEX >= 0x03000000
33108 : 0, /* tp_compare */
33109 : #else
33110 : (cmpfunc) 0, /* tp_compare */
33111 : #endif
33112 : (reprfunc) 0, /* tp_repr */
33113 : &SwigPyBuiltin___gpgme_subkey_type.as_number, /* tp_as_number */
33114 : &SwigPyBuiltin___gpgme_subkey_type.as_sequence, /* tp_as_sequence */
33115 : &SwigPyBuiltin___gpgme_subkey_type.as_mapping, /* tp_as_mapping */
33116 : (hashfunc) 0, /* tp_hash */
33117 : (ternaryfunc) 0, /* tp_call */
33118 : (reprfunc) 0, /* tp_str */
33119 : (getattrofunc) 0, /* tp_getattro */
33120 : (setattrofunc) 0, /* tp_setattro */
33121 : &SwigPyBuiltin___gpgme_subkey_type.as_buffer, /* tp_as_buffer */
33122 : #if PY_VERSION_HEX >= 0x03000000
33123 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
33124 : #else
33125 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
33126 : #endif
33127 : "::_gpgme_subkey", /* tp_doc */
33128 : (traverseproc) 0, /* tp_traverse */
33129 : (inquiry) 0, /* tp_clear */
33130 : (richcmpfunc) SwigPyBuiltin___gpgme_subkey_richcompare, /* feature:python:tp_richcompare */
33131 : 0, /* tp_weaklistoffset */
33132 : (getiterfunc) 0, /* tp_iter */
33133 : (iternextfunc) 0, /* tp_iternext */
33134 : SwigPyBuiltin___gpgme_subkey_methods, /* tp_methods */
33135 : 0, /* tp_members */
33136 : SwigPyBuiltin___gpgme_subkey_getset, /* tp_getset */
33137 : 0, /* tp_base */
33138 : 0, /* tp_dict */
33139 : (descrgetfunc) 0, /* tp_descr_get */
33140 : (descrsetfunc) 0, /* tp_descr_set */
33141 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
33142 : (initproc) _wrap_new__gpgme_subkey, /* tp_init */
33143 : (allocfunc) 0, /* tp_alloc */
33144 : (newfunc) 0, /* tp_new */
33145 : (freefunc) 0, /* tp_free */
33146 : (inquiry) 0, /* tp_is_gc */
33147 : (PyObject*) 0, /* tp_bases */
33148 : (PyObject*) 0, /* tp_mro */
33149 : (PyObject*) 0, /* tp_cache */
33150 : (PyObject*) 0, /* tp_subclasses */
33151 : (PyObject*) 0, /* tp_weaklist */
33152 : (destructor) 0, /* tp_del */
33153 : #if PY_VERSION_HEX >= 0x02060000
33154 : (int) 0, /* tp_version_tag */
33155 : #endif
33156 : },
33157 : {
33158 : (binaryfunc) 0, /* nb_add */
33159 : (binaryfunc) 0, /* nb_subtract */
33160 : (binaryfunc) 0, /* nb_multiply */
33161 : #if PY_VERSION_HEX < 0x03000000
33162 : (binaryfunc) 0, /* nb_divide */
33163 : #endif
33164 : (binaryfunc) 0, /* nb_remainder */
33165 : (binaryfunc) 0, /* nb_divmod */
33166 : (ternaryfunc) 0, /* nb_power */
33167 : (unaryfunc) 0, /* nb_negative */
33168 : (unaryfunc) 0, /* nb_positive */
33169 : (unaryfunc) 0, /* nb_absolute */
33170 : (inquiry) 0, /* nb_nonzero */
33171 : (unaryfunc) 0, /* nb_invert */
33172 : (binaryfunc) 0, /* nb_lshift */
33173 : (binaryfunc) 0, /* nb_rshift */
33174 : (binaryfunc) 0, /* nb_and */
33175 : (binaryfunc) 0, /* nb_xor */
33176 : (binaryfunc) 0, /* nb_or */
33177 : #if PY_VERSION_HEX < 0x03000000
33178 : (coercion) 0, /* nb_coerce */
33179 : #endif
33180 : (unaryfunc) 0, /* nb_int */
33181 : #if PY_VERSION_HEX >= 0x03000000
33182 : (void*) 0, /* nb_reserved */
33183 : #else
33184 : (unaryfunc) 0, /* nb_long */
33185 : #endif
33186 : (unaryfunc) 0, /* nb_float */
33187 : #if PY_VERSION_HEX < 0x03000000
33188 : (unaryfunc) 0, /* nb_oct */
33189 : (unaryfunc) 0, /* nb_hex */
33190 : #endif
33191 : (binaryfunc) 0, /* nb_inplace_add */
33192 : (binaryfunc) 0, /* nb_inplace_subtract */
33193 : (binaryfunc) 0, /* nb_inplace_multiply */
33194 : #if PY_VERSION_HEX < 0x03000000
33195 : (binaryfunc) 0, /* nb_inplace_divide */
33196 : #endif
33197 : (binaryfunc) 0, /* nb_inplace_remainder */
33198 : (ternaryfunc) 0, /* nb_inplace_power */
33199 : (binaryfunc) 0, /* nb_inplace_lshift */
33200 : (binaryfunc) 0, /* nb_inplace_rshift */
33201 : (binaryfunc) 0, /* nb_inplace_and */
33202 : (binaryfunc) 0, /* nb_inplace_xor */
33203 : (binaryfunc) 0, /* nb_inplace_or */
33204 : (binaryfunc) 0, /* nb_floor_divide */
33205 : (binaryfunc) 0, /* nb_true_divide */
33206 : (binaryfunc) 0, /* nb_inplace_floor_divide */
33207 : (binaryfunc) 0, /* nb_inplace_true_divide */
33208 : #if PY_VERSION_HEX >= 0x02050000
33209 : (unaryfunc) 0, /* nb_index */
33210 : #endif
33211 : },
33212 : {
33213 : (lenfunc) 0, /* mp_length */
33214 : (binaryfunc) 0, /* mp_subscript */
33215 : (objobjargproc) 0, /* mp_ass_subscript */
33216 : },
33217 : {
33218 : (lenfunc) 0, /* sq_length */
33219 : (binaryfunc) 0, /* sq_concat */
33220 : (ssizeargfunc) 0, /* sq_repeat */
33221 : (ssizeargfunc) 0, /* sq_item */
33222 : #if PY_VERSION_HEX >= 0x03000000
33223 : (void*) 0, /* was_sq_slice */
33224 : #else
33225 : (ssizessizeargfunc) 0, /* sq_slice */
33226 : #endif
33227 : (ssizeobjargproc) 0, /* sq_ass_item */
33228 : #if PY_VERSION_HEX >= 0x03000000
33229 : (void*) 0, /* was_sq_ass_slice */
33230 : #else
33231 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
33232 : #endif
33233 : (objobjproc) 0, /* sq_contains */
33234 : (binaryfunc) 0, /* sq_inplace_concat */
33235 : (ssizeargfunc) 0, /* sq_inplace_repeat */
33236 : },
33237 : {
33238 : #if PY_VERSION_HEX < 0x03000000
33239 : (readbufferproc) 0, /* bf_getreadbuffer */
33240 : (writebufferproc) 0, /* bf_getwritebuffer */
33241 : (segcountproc) 0, /* bf_getsegcount */
33242 : (charbufferproc) 0, /* bf_getcharbuffer */
33243 : #endif
33244 : #if PY_VERSION_HEX >= 0x02060000
33245 : (getbufferproc) 0, /* bf_getbuffer */
33246 : (releasebufferproc) 0, /* bf_releasebuffer */
33247 : #endif
33248 : },
33249 : (PyObject*) 0, /* ht_name */
33250 : (PyObject*) 0, /* ht_slots */
33251 : };
33252 :
33253 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_subkey_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_subkey_type};
33254 :
33255 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_key_sig)
33256 : static SwigPyGetSet _gpgme_key_sig_invalid_getset = { _wrap__gpgme_key_sig_invalid_get, _wrap__gpgme_key_sig_invalid_set };
33257 : static SwigPyGetSet _gpgme_key_sig__unused_getset = { _wrap__gpgme_key_sig__unused_get, _wrap__gpgme_key_sig__unused_set };
33258 : static SwigPyGetSet _gpgme_key_sig_uid_getset = { _wrap__gpgme_key_sig_uid_get, _wrap__gpgme_key_sig_uid_set };
33259 : static SwigPyGetSet _gpgme_key_sig_keyid_getset = { _wrap__gpgme_key_sig_keyid_get, _wrap__gpgme_key_sig_keyid_set };
33260 : static SwigPyGetSet _gpgme_key_sig_name_getset = { _wrap__gpgme_key_sig_name_get, _wrap__gpgme_key_sig_name_set };
33261 : static SwigPyGetSet _gpgme_key_sig__last_notation_getset = { _wrap__gpgme_key_sig__last_notation_get, _wrap__gpgme_key_sig__last_notation_set };
33262 : static SwigPyGetSet _gpgme_key_sig_sig_class_getset = { _wrap__gpgme_key_sig_sig_class_get, _wrap__gpgme_key_sig_sig_class_set };
33263 : static SwigPyGetSet _gpgme_key_sig_revoked_getset = { _wrap__gpgme_key_sig_revoked_get, _wrap__gpgme_key_sig_revoked_set };
33264 : static SwigPyGetSet _gpgme_key_sig_pubkey_algo_getset = { _wrap__gpgme_key_sig_pubkey_algo_get, _wrap__gpgme_key_sig_pubkey_algo_set };
33265 : static SwigPyGetSet _gpgme_key_sig_expires_getset = { _wrap__gpgme_key_sig_expires_get, _wrap__gpgme_key_sig_expires_set };
33266 : static SwigPyGetSet _gpgme_key_sig_email_getset = { _wrap__gpgme_key_sig_email_get, _wrap__gpgme_key_sig_email_set };
33267 : static SwigPyGetSet _gpgme_key_sig_notations_getset = { _wrap__gpgme_key_sig_notations_get, _wrap__gpgme_key_sig_notations_set };
33268 : static SwigPyGetSet _gpgme_key_sig_expired_getset = { _wrap__gpgme_key_sig_expired_get, _wrap__gpgme_key_sig_expired_set };
33269 : static SwigPyGetSet _gpgme_key_sig_comment_getset = { _wrap__gpgme_key_sig_comment_get, _wrap__gpgme_key_sig_comment_set };
33270 : static SwigPyGetSet _gpgme_key_sig__keyid_getset = { _wrap__gpgme_key_sig__keyid_get, _wrap__gpgme_key_sig__keyid_set };
33271 : static SwigPyGetSet _gpgme_key_sig_timestamp_getset = { _wrap__gpgme_key_sig_timestamp_get, _wrap__gpgme_key_sig_timestamp_set };
33272 : static SwigPyGetSet _gpgme_key_sig_status_getset = { _wrap__gpgme_key_sig_status_get, _wrap__gpgme_key_sig_status_set };
33273 : static SwigPyGetSet _gpgme_key_sig_exportable_getset = { _wrap__gpgme_key_sig_exportable_get, _wrap__gpgme_key_sig_exportable_set };
33274 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_key_sig_getset[] = {
33275 : { (char*) "invalid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.invalid", (void*) &_gpgme_key_sig_invalid_getset }
33276 : ,
33277 : { (char*) "_unused", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig._unused", (void*) &_gpgme_key_sig__unused_getset }
33278 : ,
33279 : { (char*) "uid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.uid", (void*) &_gpgme_key_sig_uid_getset }
33280 : ,
33281 : { (char*) "keyid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.keyid", (void*) &_gpgme_key_sig_keyid_getset }
33282 : ,
33283 : { (char*) "name", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.name", (void*) &_gpgme_key_sig_name_getset }
33284 : ,
33285 : { (char*) "_last_notation", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig._last_notation", (void*) &_gpgme_key_sig__last_notation_getset }
33286 : ,
33287 : { (char*) "sig_class", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.sig_class", (void*) &_gpgme_key_sig_sig_class_getset }
33288 : ,
33289 : { (char*) "revoked", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.revoked", (void*) &_gpgme_key_sig_revoked_getset }
33290 : ,
33291 : { (char*) "pubkey_algo", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.pubkey_algo", (void*) &_gpgme_key_sig_pubkey_algo_getset }
33292 : ,
33293 : { (char*) "expires", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.expires", (void*) &_gpgme_key_sig_expires_getset }
33294 : ,
33295 : { (char*) "email", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.email", (void*) &_gpgme_key_sig_email_getset }
33296 : ,
33297 : { (char*) "notations", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.notations", (void*) &_gpgme_key_sig_notations_getset }
33298 : ,
33299 : { (char*) "expired", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.expired", (void*) &_gpgme_key_sig_expired_getset }
33300 : ,
33301 : { (char*) "comment", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.comment", (void*) &_gpgme_key_sig_comment_getset }
33302 : ,
33303 : { (char*) "_keyid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig._keyid", (void*) &_gpgme_key_sig__keyid_getset }
33304 : ,
33305 : { (char*) "timestamp", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.timestamp", (void*) &_gpgme_key_sig_timestamp_getset }
33306 : ,
33307 : { (char*) "status", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.status", (void*) &_gpgme_key_sig_status_getset }
33308 : ,
33309 : { (char*) "exportable", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key_sig.exportable", (void*) &_gpgme_key_sig_exportable_getset }
33310 : ,
33311 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
33312 : };
33313 :
33314 : SWIGINTERN PyObject *
33315 0 : SwigPyBuiltin___gpgme_key_sig_richcompare(PyObject *self, PyObject *other, int op) {
33316 0 : PyObject *result = NULL;
33317 0 : PyObject *tuple = PyTuple_New(1);
33318 : assert(tuple);
33319 0 : PyTuple_SET_ITEM(tuple, 0, other);
33320 0 : Py_XINCREF(other);
33321 : if (!result) {
33322 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
33323 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
33324 : } else {
33325 0 : result = Py_NotImplemented;
33326 0 : Py_INCREF(result);
33327 : }
33328 : }
33329 0 : Py_DECREF(tuple);
33330 0 : return result;
33331 : }
33332 :
33333 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_key_sig_methods[] = {
33334 : { NULL, NULL, 0, NULL } /* Sentinel */
33335 : };
33336 :
33337 : static PyHeapTypeObject SwigPyBuiltin___gpgme_key_sig_type = {
33338 : {
33339 : #if PY_VERSION_HEX >= 0x03000000
33340 : PyVarObject_HEAD_INIT(NULL, 0)
33341 : #else
33342 : PyObject_HEAD_INIT(NULL)
33343 : 0, /* ob_size */
33344 : #endif
33345 : "_gpgme_key_sig", /* tp_name */
33346 : sizeof(SwigPyObject), /* tp_basicsize */
33347 : 0, /* tp_itemsize */
33348 : (destructor) _wrap_delete__gpgme_key_sig_closure, /* tp_dealloc */
33349 : (printfunc) 0, /* tp_print */
33350 : (getattrfunc) 0, /* tp_getattr */
33351 : (setattrfunc) 0, /* tp_setattr */
33352 : #if PY_VERSION_HEX >= 0x03000000
33353 : 0, /* tp_compare */
33354 : #else
33355 : (cmpfunc) 0, /* tp_compare */
33356 : #endif
33357 : (reprfunc) 0, /* tp_repr */
33358 : &SwigPyBuiltin___gpgme_key_sig_type.as_number, /* tp_as_number */
33359 : &SwigPyBuiltin___gpgme_key_sig_type.as_sequence, /* tp_as_sequence */
33360 : &SwigPyBuiltin___gpgme_key_sig_type.as_mapping, /* tp_as_mapping */
33361 : (hashfunc) 0, /* tp_hash */
33362 : (ternaryfunc) 0, /* tp_call */
33363 : (reprfunc) 0, /* tp_str */
33364 : (getattrofunc) 0, /* tp_getattro */
33365 : (setattrofunc) 0, /* tp_setattro */
33366 : &SwigPyBuiltin___gpgme_key_sig_type.as_buffer, /* tp_as_buffer */
33367 : #if PY_VERSION_HEX >= 0x03000000
33368 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
33369 : #else
33370 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
33371 : #endif
33372 : "::_gpgme_key_sig", /* tp_doc */
33373 : (traverseproc) 0, /* tp_traverse */
33374 : (inquiry) 0, /* tp_clear */
33375 : (richcmpfunc) SwigPyBuiltin___gpgme_key_sig_richcompare, /* feature:python:tp_richcompare */
33376 : 0, /* tp_weaklistoffset */
33377 : (getiterfunc) 0, /* tp_iter */
33378 : (iternextfunc) 0, /* tp_iternext */
33379 : SwigPyBuiltin___gpgme_key_sig_methods, /* tp_methods */
33380 : 0, /* tp_members */
33381 : SwigPyBuiltin___gpgme_key_sig_getset, /* tp_getset */
33382 : 0, /* tp_base */
33383 : 0, /* tp_dict */
33384 : (descrgetfunc) 0, /* tp_descr_get */
33385 : (descrsetfunc) 0, /* tp_descr_set */
33386 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
33387 : (initproc) _wrap_new__gpgme_key_sig, /* tp_init */
33388 : (allocfunc) 0, /* tp_alloc */
33389 : (newfunc) 0, /* tp_new */
33390 : (freefunc) 0, /* tp_free */
33391 : (inquiry) 0, /* tp_is_gc */
33392 : (PyObject*) 0, /* tp_bases */
33393 : (PyObject*) 0, /* tp_mro */
33394 : (PyObject*) 0, /* tp_cache */
33395 : (PyObject*) 0, /* tp_subclasses */
33396 : (PyObject*) 0, /* tp_weaklist */
33397 : (destructor) 0, /* tp_del */
33398 : #if PY_VERSION_HEX >= 0x02060000
33399 : (int) 0, /* tp_version_tag */
33400 : #endif
33401 : },
33402 : {
33403 : (binaryfunc) 0, /* nb_add */
33404 : (binaryfunc) 0, /* nb_subtract */
33405 : (binaryfunc) 0, /* nb_multiply */
33406 : #if PY_VERSION_HEX < 0x03000000
33407 : (binaryfunc) 0, /* nb_divide */
33408 : #endif
33409 : (binaryfunc) 0, /* nb_remainder */
33410 : (binaryfunc) 0, /* nb_divmod */
33411 : (ternaryfunc) 0, /* nb_power */
33412 : (unaryfunc) 0, /* nb_negative */
33413 : (unaryfunc) 0, /* nb_positive */
33414 : (unaryfunc) 0, /* nb_absolute */
33415 : (inquiry) 0, /* nb_nonzero */
33416 : (unaryfunc) 0, /* nb_invert */
33417 : (binaryfunc) 0, /* nb_lshift */
33418 : (binaryfunc) 0, /* nb_rshift */
33419 : (binaryfunc) 0, /* nb_and */
33420 : (binaryfunc) 0, /* nb_xor */
33421 : (binaryfunc) 0, /* nb_or */
33422 : #if PY_VERSION_HEX < 0x03000000
33423 : (coercion) 0, /* nb_coerce */
33424 : #endif
33425 : (unaryfunc) 0, /* nb_int */
33426 : #if PY_VERSION_HEX >= 0x03000000
33427 : (void*) 0, /* nb_reserved */
33428 : #else
33429 : (unaryfunc) 0, /* nb_long */
33430 : #endif
33431 : (unaryfunc) 0, /* nb_float */
33432 : #if PY_VERSION_HEX < 0x03000000
33433 : (unaryfunc) 0, /* nb_oct */
33434 : (unaryfunc) 0, /* nb_hex */
33435 : #endif
33436 : (binaryfunc) 0, /* nb_inplace_add */
33437 : (binaryfunc) 0, /* nb_inplace_subtract */
33438 : (binaryfunc) 0, /* nb_inplace_multiply */
33439 : #if PY_VERSION_HEX < 0x03000000
33440 : (binaryfunc) 0, /* nb_inplace_divide */
33441 : #endif
33442 : (binaryfunc) 0, /* nb_inplace_remainder */
33443 : (ternaryfunc) 0, /* nb_inplace_power */
33444 : (binaryfunc) 0, /* nb_inplace_lshift */
33445 : (binaryfunc) 0, /* nb_inplace_rshift */
33446 : (binaryfunc) 0, /* nb_inplace_and */
33447 : (binaryfunc) 0, /* nb_inplace_xor */
33448 : (binaryfunc) 0, /* nb_inplace_or */
33449 : (binaryfunc) 0, /* nb_floor_divide */
33450 : (binaryfunc) 0, /* nb_true_divide */
33451 : (binaryfunc) 0, /* nb_inplace_floor_divide */
33452 : (binaryfunc) 0, /* nb_inplace_true_divide */
33453 : #if PY_VERSION_HEX >= 0x02050000
33454 : (unaryfunc) 0, /* nb_index */
33455 : #endif
33456 : },
33457 : {
33458 : (lenfunc) 0, /* mp_length */
33459 : (binaryfunc) 0, /* mp_subscript */
33460 : (objobjargproc) 0, /* mp_ass_subscript */
33461 : },
33462 : {
33463 : (lenfunc) 0, /* sq_length */
33464 : (binaryfunc) 0, /* sq_concat */
33465 : (ssizeargfunc) 0, /* sq_repeat */
33466 : (ssizeargfunc) 0, /* sq_item */
33467 : #if PY_VERSION_HEX >= 0x03000000
33468 : (void*) 0, /* was_sq_slice */
33469 : #else
33470 : (ssizessizeargfunc) 0, /* sq_slice */
33471 : #endif
33472 : (ssizeobjargproc) 0, /* sq_ass_item */
33473 : #if PY_VERSION_HEX >= 0x03000000
33474 : (void*) 0, /* was_sq_ass_slice */
33475 : #else
33476 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
33477 : #endif
33478 : (objobjproc) 0, /* sq_contains */
33479 : (binaryfunc) 0, /* sq_inplace_concat */
33480 : (ssizeargfunc) 0, /* sq_inplace_repeat */
33481 : },
33482 : {
33483 : #if PY_VERSION_HEX < 0x03000000
33484 : (readbufferproc) 0, /* bf_getreadbuffer */
33485 : (writebufferproc) 0, /* bf_getwritebuffer */
33486 : (segcountproc) 0, /* bf_getsegcount */
33487 : (charbufferproc) 0, /* bf_getcharbuffer */
33488 : #endif
33489 : #if PY_VERSION_HEX >= 0x02060000
33490 : (getbufferproc) 0, /* bf_getbuffer */
33491 : (releasebufferproc) 0, /* bf_releasebuffer */
33492 : #endif
33493 : },
33494 : (PyObject*) 0, /* ht_name */
33495 : (PyObject*) 0, /* ht_slots */
33496 : };
33497 :
33498 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_key_sig_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_key_sig_type};
33499 :
33500 416 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_user_id)
33501 : static SwigPyGetSet _gpgme_user_id_invalid_getset = { _wrap__gpgme_user_id_invalid_get, _wrap__gpgme_user_id_invalid_set };
33502 : static SwigPyGetSet _gpgme_user_id__unused_getset = { _wrap__gpgme_user_id__unused_get, _wrap__gpgme_user_id__unused_set };
33503 : static SwigPyGetSet _gpgme_user_id_uid_getset = { _wrap__gpgme_user_id_uid_get, _wrap__gpgme_user_id_uid_set };
33504 : static SwigPyGetSet _gpgme_user_id_name_getset = { _wrap__gpgme_user_id_name_get, _wrap__gpgme_user_id_name_set };
33505 : static SwigPyGetSet _gpgme_user_id__last_keysig_getset = { _wrap__gpgme_user_id__last_keysig_get, _wrap__gpgme_user_id__last_keysig_set };
33506 : static SwigPyGetSet _gpgme_user_id_revoked_getset = { _wrap__gpgme_user_id_revoked_get, _wrap__gpgme_user_id_revoked_set };
33507 : static SwigPyGetSet _gpgme_user_id_validity_getset = { _wrap__gpgme_user_id_validity_get, _wrap__gpgme_user_id_validity_set };
33508 : static SwigPyGetSet _gpgme_user_id_tofu_getset = { _wrap__gpgme_user_id_tofu_get, _wrap__gpgme_user_id_tofu_set };
33509 : static SwigPyGetSet _gpgme_user_id_email_getset = { _wrap__gpgme_user_id_email_get, _wrap__gpgme_user_id_email_set };
33510 : static SwigPyGetSet _gpgme_user_id_comment_getset = { _wrap__gpgme_user_id_comment_get, _wrap__gpgme_user_id_comment_set };
33511 : static SwigPyGetSet _gpgme_user_id_signatures_getset = { _wrap__gpgme_user_id_signatures_get, _wrap__gpgme_user_id_signatures_set };
33512 : static SwigPyGetSet _gpgme_user_id_address_getset = { _wrap__gpgme_user_id_address_get, _wrap__gpgme_user_id_address_set };
33513 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_user_id_getset[] = {
33514 : { (char*) "invalid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id.invalid", (void*) &_gpgme_user_id_invalid_getset }
33515 : ,
33516 : { (char*) "_unused", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id._unused", (void*) &_gpgme_user_id__unused_getset }
33517 : ,
33518 : { (char*) "uid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id.uid", (void*) &_gpgme_user_id_uid_getset }
33519 : ,
33520 : { (char*) "name", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id.name", (void*) &_gpgme_user_id_name_getset }
33521 : ,
33522 : { (char*) "_last_keysig", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id._last_keysig", (void*) &_gpgme_user_id__last_keysig_getset }
33523 : ,
33524 : { (char*) "revoked", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id.revoked", (void*) &_gpgme_user_id_revoked_getset }
33525 : ,
33526 : { (char*) "validity", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id.validity", (void*) &_gpgme_user_id_validity_getset }
33527 : ,
33528 : { (char*) "tofu", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id.tofu", (void*) &_gpgme_user_id_tofu_getset }
33529 : ,
33530 : { (char*) "email", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id.email", (void*) &_gpgme_user_id_email_getset }
33531 : ,
33532 : { (char*) "comment", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id.comment", (void*) &_gpgme_user_id_comment_getset }
33533 : ,
33534 : { (char*) "signatures", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id.signatures", (void*) &_gpgme_user_id_signatures_getset }
33535 : ,
33536 : { (char*) "address", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_user_id.address", (void*) &_gpgme_user_id_address_getset }
33537 : ,
33538 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
33539 : };
33540 :
33541 : SWIGINTERN PyObject *
33542 0 : SwigPyBuiltin___gpgme_user_id_richcompare(PyObject *self, PyObject *other, int op) {
33543 0 : PyObject *result = NULL;
33544 0 : PyObject *tuple = PyTuple_New(1);
33545 : assert(tuple);
33546 0 : PyTuple_SET_ITEM(tuple, 0, other);
33547 0 : Py_XINCREF(other);
33548 : if (!result) {
33549 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
33550 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
33551 : } else {
33552 0 : result = Py_NotImplemented;
33553 0 : Py_INCREF(result);
33554 : }
33555 : }
33556 0 : Py_DECREF(tuple);
33557 0 : return result;
33558 : }
33559 :
33560 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_user_id_methods[] = {
33561 : { NULL, NULL, 0, NULL } /* Sentinel */
33562 : };
33563 :
33564 : static PyHeapTypeObject SwigPyBuiltin___gpgme_user_id_type = {
33565 : {
33566 : #if PY_VERSION_HEX >= 0x03000000
33567 : PyVarObject_HEAD_INIT(NULL, 0)
33568 : #else
33569 : PyObject_HEAD_INIT(NULL)
33570 : 0, /* ob_size */
33571 : #endif
33572 : "_gpgme_user_id", /* tp_name */
33573 : sizeof(SwigPyObject), /* tp_basicsize */
33574 : 0, /* tp_itemsize */
33575 : (destructor) _wrap_delete__gpgme_user_id_closure, /* tp_dealloc */
33576 : (printfunc) 0, /* tp_print */
33577 : (getattrfunc) 0, /* tp_getattr */
33578 : (setattrfunc) 0, /* tp_setattr */
33579 : #if PY_VERSION_HEX >= 0x03000000
33580 : 0, /* tp_compare */
33581 : #else
33582 : (cmpfunc) 0, /* tp_compare */
33583 : #endif
33584 : (reprfunc) 0, /* tp_repr */
33585 : &SwigPyBuiltin___gpgme_user_id_type.as_number, /* tp_as_number */
33586 : &SwigPyBuiltin___gpgme_user_id_type.as_sequence, /* tp_as_sequence */
33587 : &SwigPyBuiltin___gpgme_user_id_type.as_mapping, /* tp_as_mapping */
33588 : (hashfunc) 0, /* tp_hash */
33589 : (ternaryfunc) 0, /* tp_call */
33590 : (reprfunc) 0, /* tp_str */
33591 : (getattrofunc) 0, /* tp_getattro */
33592 : (setattrofunc) 0, /* tp_setattro */
33593 : &SwigPyBuiltin___gpgme_user_id_type.as_buffer, /* tp_as_buffer */
33594 : #if PY_VERSION_HEX >= 0x03000000
33595 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
33596 : #else
33597 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
33598 : #endif
33599 : "::_gpgme_user_id", /* tp_doc */
33600 : (traverseproc) 0, /* tp_traverse */
33601 : (inquiry) 0, /* tp_clear */
33602 : (richcmpfunc) SwigPyBuiltin___gpgme_user_id_richcompare, /* feature:python:tp_richcompare */
33603 : 0, /* tp_weaklistoffset */
33604 : (getiterfunc) 0, /* tp_iter */
33605 : (iternextfunc) 0, /* tp_iternext */
33606 : SwigPyBuiltin___gpgme_user_id_methods, /* tp_methods */
33607 : 0, /* tp_members */
33608 : SwigPyBuiltin___gpgme_user_id_getset, /* tp_getset */
33609 : 0, /* tp_base */
33610 : 0, /* tp_dict */
33611 : (descrgetfunc) 0, /* tp_descr_get */
33612 : (descrsetfunc) 0, /* tp_descr_set */
33613 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
33614 : (initproc) _wrap_new__gpgme_user_id, /* tp_init */
33615 : (allocfunc) 0, /* tp_alloc */
33616 : (newfunc) 0, /* tp_new */
33617 : (freefunc) 0, /* tp_free */
33618 : (inquiry) 0, /* tp_is_gc */
33619 : (PyObject*) 0, /* tp_bases */
33620 : (PyObject*) 0, /* tp_mro */
33621 : (PyObject*) 0, /* tp_cache */
33622 : (PyObject*) 0, /* tp_subclasses */
33623 : (PyObject*) 0, /* tp_weaklist */
33624 : (destructor) 0, /* tp_del */
33625 : #if PY_VERSION_HEX >= 0x02060000
33626 : (int) 0, /* tp_version_tag */
33627 : #endif
33628 : },
33629 : {
33630 : (binaryfunc) 0, /* nb_add */
33631 : (binaryfunc) 0, /* nb_subtract */
33632 : (binaryfunc) 0, /* nb_multiply */
33633 : #if PY_VERSION_HEX < 0x03000000
33634 : (binaryfunc) 0, /* nb_divide */
33635 : #endif
33636 : (binaryfunc) 0, /* nb_remainder */
33637 : (binaryfunc) 0, /* nb_divmod */
33638 : (ternaryfunc) 0, /* nb_power */
33639 : (unaryfunc) 0, /* nb_negative */
33640 : (unaryfunc) 0, /* nb_positive */
33641 : (unaryfunc) 0, /* nb_absolute */
33642 : (inquiry) 0, /* nb_nonzero */
33643 : (unaryfunc) 0, /* nb_invert */
33644 : (binaryfunc) 0, /* nb_lshift */
33645 : (binaryfunc) 0, /* nb_rshift */
33646 : (binaryfunc) 0, /* nb_and */
33647 : (binaryfunc) 0, /* nb_xor */
33648 : (binaryfunc) 0, /* nb_or */
33649 : #if PY_VERSION_HEX < 0x03000000
33650 : (coercion) 0, /* nb_coerce */
33651 : #endif
33652 : (unaryfunc) 0, /* nb_int */
33653 : #if PY_VERSION_HEX >= 0x03000000
33654 : (void*) 0, /* nb_reserved */
33655 : #else
33656 : (unaryfunc) 0, /* nb_long */
33657 : #endif
33658 : (unaryfunc) 0, /* nb_float */
33659 : #if PY_VERSION_HEX < 0x03000000
33660 : (unaryfunc) 0, /* nb_oct */
33661 : (unaryfunc) 0, /* nb_hex */
33662 : #endif
33663 : (binaryfunc) 0, /* nb_inplace_add */
33664 : (binaryfunc) 0, /* nb_inplace_subtract */
33665 : (binaryfunc) 0, /* nb_inplace_multiply */
33666 : #if PY_VERSION_HEX < 0x03000000
33667 : (binaryfunc) 0, /* nb_inplace_divide */
33668 : #endif
33669 : (binaryfunc) 0, /* nb_inplace_remainder */
33670 : (ternaryfunc) 0, /* nb_inplace_power */
33671 : (binaryfunc) 0, /* nb_inplace_lshift */
33672 : (binaryfunc) 0, /* nb_inplace_rshift */
33673 : (binaryfunc) 0, /* nb_inplace_and */
33674 : (binaryfunc) 0, /* nb_inplace_xor */
33675 : (binaryfunc) 0, /* nb_inplace_or */
33676 : (binaryfunc) 0, /* nb_floor_divide */
33677 : (binaryfunc) 0, /* nb_true_divide */
33678 : (binaryfunc) 0, /* nb_inplace_floor_divide */
33679 : (binaryfunc) 0, /* nb_inplace_true_divide */
33680 : #if PY_VERSION_HEX >= 0x02050000
33681 : (unaryfunc) 0, /* nb_index */
33682 : #endif
33683 : },
33684 : {
33685 : (lenfunc) 0, /* mp_length */
33686 : (binaryfunc) 0, /* mp_subscript */
33687 : (objobjargproc) 0, /* mp_ass_subscript */
33688 : },
33689 : {
33690 : (lenfunc) 0, /* sq_length */
33691 : (binaryfunc) 0, /* sq_concat */
33692 : (ssizeargfunc) 0, /* sq_repeat */
33693 : (ssizeargfunc) 0, /* sq_item */
33694 : #if PY_VERSION_HEX >= 0x03000000
33695 : (void*) 0, /* was_sq_slice */
33696 : #else
33697 : (ssizessizeargfunc) 0, /* sq_slice */
33698 : #endif
33699 : (ssizeobjargproc) 0, /* sq_ass_item */
33700 : #if PY_VERSION_HEX >= 0x03000000
33701 : (void*) 0, /* was_sq_ass_slice */
33702 : #else
33703 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
33704 : #endif
33705 : (objobjproc) 0, /* sq_contains */
33706 : (binaryfunc) 0, /* sq_inplace_concat */
33707 : (ssizeargfunc) 0, /* sq_inplace_repeat */
33708 : },
33709 : {
33710 : #if PY_VERSION_HEX < 0x03000000
33711 : (readbufferproc) 0, /* bf_getreadbuffer */
33712 : (writebufferproc) 0, /* bf_getwritebuffer */
33713 : (segcountproc) 0, /* bf_getsegcount */
33714 : (charbufferproc) 0, /* bf_getcharbuffer */
33715 : #endif
33716 : #if PY_VERSION_HEX >= 0x02060000
33717 : (getbufferproc) 0, /* bf_getbuffer */
33718 : (releasebufferproc) 0, /* bf_releasebuffer */
33719 : #endif
33720 : },
33721 : (PyObject*) 0, /* ht_name */
33722 : (PyObject*) 0, /* ht_slots */
33723 : };
33724 :
33725 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_user_id_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_user_id_type};
33726 :
33727 80 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_key)
33728 : static SwigPyGetSet _gpgme_key_invalid_getset = { _wrap__gpgme_key_invalid_get, _wrap__gpgme_key_invalid_set };
33729 : static SwigPyGetSet _gpgme_key_can_sign_getset = { _wrap__gpgme_key_can_sign_get, _wrap__gpgme_key_can_sign_set };
33730 : static SwigPyGetSet _gpgme_key__unused_getset = { _wrap__gpgme_key__unused_get, _wrap__gpgme_key__unused_set };
33731 : static SwigPyGetSet _gpgme_key_owner_trust_getset = { _wrap__gpgme_key_owner_trust_get, _wrap__gpgme_key_owner_trust_set };
33732 : static SwigPyGetSet _gpgme_key_protocol_getset = { _wrap__gpgme_key_protocol_get, _wrap__gpgme_key_protocol_set };
33733 : static SwigPyGetSet _gpgme_key_can_certify_getset = { _wrap__gpgme_key_can_certify_get, _wrap__gpgme_key_can_certify_set };
33734 : static SwigPyGetSet _gpgme_key_secret_getset = { _wrap__gpgme_key_secret_get, _wrap__gpgme_key_secret_set };
33735 : static SwigPyGetSet _gpgme_key__refs_getset = { _wrap__gpgme_key__refs_get, _wrap__gpgme_key__refs_set };
33736 : static SwigPyGetSet _gpgme_key_can_encrypt_getset = { _wrap__gpgme_key_can_encrypt_get, _wrap__gpgme_key_can_encrypt_set };
33737 : static SwigPyGetSet _gpgme_key_issuer_serial_getset = { _wrap__gpgme_key_issuer_serial_get, _wrap__gpgme_key_issuer_serial_set };
33738 : static SwigPyGetSet _gpgme_key_revoked_getset = { _wrap__gpgme_key_revoked_get, _wrap__gpgme_key_revoked_set };
33739 : static SwigPyGetSet _gpgme_key_can_authenticate_getset = { _wrap__gpgme_key_can_authenticate_get, _wrap__gpgme_key_can_authenticate_set };
33740 : static SwigPyGetSet _gpgme_key_fpr_getset = { _wrap__gpgme_key_fpr_get, _wrap__gpgme_key_fpr_set };
33741 : static SwigPyGetSet _gpgme_key_expired_getset = { _wrap__gpgme_key_expired_get, _wrap__gpgme_key_expired_set };
33742 : static SwigPyGetSet _gpgme_key_subkeys_getset = { _wrap__gpgme_key_subkeys_get, _wrap__gpgme_key_subkeys_set };
33743 : static SwigPyGetSet _gpgme_key_uids_getset = { _wrap__gpgme_key_uids_get, _wrap__gpgme_key_uids_set };
33744 : static SwigPyGetSet _gpgme_key__last_subkey_getset = { _wrap__gpgme_key__last_subkey_get, _wrap__gpgme_key__last_subkey_set };
33745 : static SwigPyGetSet _gpgme_key_issuer_name_getset = { _wrap__gpgme_key_issuer_name_get, _wrap__gpgme_key_issuer_name_set };
33746 : static SwigPyGetSet _gpgme_key__last_uid_getset = { _wrap__gpgme_key__last_uid_get, _wrap__gpgme_key__last_uid_set };
33747 : static SwigPyGetSet _gpgme_key_keylist_mode_getset = { _wrap__gpgme_key_keylist_mode_get, _wrap__gpgme_key_keylist_mode_set };
33748 : static SwigPyGetSet _gpgme_key_disabled_getset = { _wrap__gpgme_key_disabled_get, _wrap__gpgme_key_disabled_set };
33749 : static SwigPyGetSet _gpgme_key_chain_id_getset = { _wrap__gpgme_key_chain_id_get, _wrap__gpgme_key_chain_id_set };
33750 : static SwigPyGetSet _gpgme_key_is_qualified_getset = { _wrap__gpgme_key_is_qualified_get, _wrap__gpgme_key_is_qualified_set };
33751 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_key_getset[] = {
33752 : { (char*) "invalid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.invalid", (void*) &_gpgme_key_invalid_getset }
33753 : ,
33754 : { (char*) "can_sign", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.can_sign", (void*) &_gpgme_key_can_sign_getset }
33755 : ,
33756 : { (char*) "_unused", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key._unused", (void*) &_gpgme_key__unused_getset }
33757 : ,
33758 : { (char*) "owner_trust", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.owner_trust", (void*) &_gpgme_key_owner_trust_getset }
33759 : ,
33760 : { (char*) "protocol", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.protocol", (void*) &_gpgme_key_protocol_getset }
33761 : ,
33762 : { (char*) "can_certify", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.can_certify", (void*) &_gpgme_key_can_certify_getset }
33763 : ,
33764 : { (char*) "secret", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.secret", (void*) &_gpgme_key_secret_getset }
33765 : ,
33766 : { (char*) "_refs", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key._refs", (void*) &_gpgme_key__refs_getset }
33767 : ,
33768 : { (char*) "can_encrypt", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.can_encrypt", (void*) &_gpgme_key_can_encrypt_getset }
33769 : ,
33770 : { (char*) "issuer_serial", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.issuer_serial", (void*) &_gpgme_key_issuer_serial_getset }
33771 : ,
33772 : { (char*) "revoked", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.revoked", (void*) &_gpgme_key_revoked_getset }
33773 : ,
33774 : { (char*) "can_authenticate", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.can_authenticate", (void*) &_gpgme_key_can_authenticate_getset }
33775 : ,
33776 : { (char*) "fpr", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.fpr", (void*) &_gpgme_key_fpr_getset }
33777 : ,
33778 : { (char*) "expired", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.expired", (void*) &_gpgme_key_expired_getset }
33779 : ,
33780 : { (char*) "subkeys", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.subkeys", (void*) &_gpgme_key_subkeys_getset }
33781 : ,
33782 : { (char*) "uids", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.uids", (void*) &_gpgme_key_uids_getset }
33783 : ,
33784 : { (char*) "_last_subkey", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key._last_subkey", (void*) &_gpgme_key__last_subkey_getset }
33785 : ,
33786 : { (char*) "issuer_name", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.issuer_name", (void*) &_gpgme_key_issuer_name_getset }
33787 : ,
33788 : { (char*) "_last_uid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key._last_uid", (void*) &_gpgme_key__last_uid_getset }
33789 : ,
33790 : { (char*) "keylist_mode", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.keylist_mode", (void*) &_gpgme_key_keylist_mode_getset }
33791 : ,
33792 : { (char*) "disabled", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.disabled", (void*) &_gpgme_key_disabled_getset }
33793 : ,
33794 : { (char*) "chain_id", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.chain_id", (void*) &_gpgme_key_chain_id_getset }
33795 : ,
33796 : { (char*) "is_qualified", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_key.is_qualified", (void*) &_gpgme_key_is_qualified_getset }
33797 : ,
33798 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
33799 : };
33800 :
33801 : SWIGINTERN PyObject *
33802 6 : SwigPyBuiltin___gpgme_key_richcompare(PyObject *self, PyObject *other, int op) {
33803 6 : PyObject *result = NULL;
33804 6 : PyObject *tuple = PyTuple_New(1);
33805 : assert(tuple);
33806 6 : PyTuple_SET_ITEM(tuple, 0, other);
33807 6 : Py_XINCREF(other);
33808 : if (!result) {
33809 6 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
33810 2 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
33811 : } else {
33812 4 : result = Py_NotImplemented;
33813 4 : Py_INCREF(result);
33814 : }
33815 : }
33816 6 : Py_DECREF(tuple);
33817 6 : return result;
33818 : }
33819 :
33820 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_key_methods[] = {
33821 : { NULL, NULL, 0, NULL } /* Sentinel */
33822 : };
33823 :
33824 : static PyHeapTypeObject SwigPyBuiltin___gpgme_key_type = {
33825 : {
33826 : #if PY_VERSION_HEX >= 0x03000000
33827 : PyVarObject_HEAD_INIT(NULL, 0)
33828 : #else
33829 : PyObject_HEAD_INIT(NULL)
33830 : 0, /* ob_size */
33831 : #endif
33832 : "_gpgme_key", /* tp_name */
33833 : sizeof(SwigPyObject), /* tp_basicsize */
33834 : 0, /* tp_itemsize */
33835 : (destructor) _wrap_delete__gpgme_key_closure, /* tp_dealloc */
33836 : (printfunc) 0, /* tp_print */
33837 : (getattrfunc) 0, /* tp_getattr */
33838 : (setattrfunc) 0, /* tp_setattr */
33839 : #if PY_VERSION_HEX >= 0x03000000
33840 : 0, /* tp_compare */
33841 : #else
33842 : (cmpfunc) 0, /* tp_compare */
33843 : #endif
33844 : (reprfunc) 0, /* tp_repr */
33845 : &SwigPyBuiltin___gpgme_key_type.as_number, /* tp_as_number */
33846 : &SwigPyBuiltin___gpgme_key_type.as_sequence, /* tp_as_sequence */
33847 : &SwigPyBuiltin___gpgme_key_type.as_mapping, /* tp_as_mapping */
33848 : (hashfunc) 0, /* tp_hash */
33849 : (ternaryfunc) 0, /* tp_call */
33850 : (reprfunc) 0, /* tp_str */
33851 : (getattrofunc) 0, /* tp_getattro */
33852 : (setattrofunc) 0, /* tp_setattro */
33853 : &SwigPyBuiltin___gpgme_key_type.as_buffer, /* tp_as_buffer */
33854 : #if PY_VERSION_HEX >= 0x03000000
33855 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
33856 : #else
33857 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
33858 : #endif
33859 : "::_gpgme_key", /* tp_doc */
33860 : (traverseproc) 0, /* tp_traverse */
33861 : (inquiry) 0, /* tp_clear */
33862 : (richcmpfunc) SwigPyBuiltin___gpgme_key_richcompare, /* feature:python:tp_richcompare */
33863 : 0, /* tp_weaklistoffset */
33864 : (getiterfunc) 0, /* tp_iter */
33865 : (iternextfunc) 0, /* tp_iternext */
33866 : SwigPyBuiltin___gpgme_key_methods, /* tp_methods */
33867 : 0, /* tp_members */
33868 : SwigPyBuiltin___gpgme_key_getset, /* tp_getset */
33869 : 0, /* tp_base */
33870 : 0, /* tp_dict */
33871 : (descrgetfunc) 0, /* tp_descr_get */
33872 : (descrsetfunc) 0, /* tp_descr_set */
33873 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
33874 : (initproc) _wrap_new__gpgme_key, /* tp_init */
33875 : (allocfunc) 0, /* tp_alloc */
33876 : (newfunc) 0, /* tp_new */
33877 : (freefunc) 0, /* tp_free */
33878 : (inquiry) 0, /* tp_is_gc */
33879 : (PyObject*) 0, /* tp_bases */
33880 : (PyObject*) 0, /* tp_mro */
33881 : (PyObject*) 0, /* tp_cache */
33882 : (PyObject*) 0, /* tp_subclasses */
33883 : (PyObject*) 0, /* tp_weaklist */
33884 : (destructor) 0, /* tp_del */
33885 : #if PY_VERSION_HEX >= 0x02060000
33886 : (int) 0, /* tp_version_tag */
33887 : #endif
33888 : },
33889 : {
33890 : (binaryfunc) 0, /* nb_add */
33891 : (binaryfunc) 0, /* nb_subtract */
33892 : (binaryfunc) 0, /* nb_multiply */
33893 : #if PY_VERSION_HEX < 0x03000000
33894 : (binaryfunc) 0, /* nb_divide */
33895 : #endif
33896 : (binaryfunc) 0, /* nb_remainder */
33897 : (binaryfunc) 0, /* nb_divmod */
33898 : (ternaryfunc) 0, /* nb_power */
33899 : (unaryfunc) 0, /* nb_negative */
33900 : (unaryfunc) 0, /* nb_positive */
33901 : (unaryfunc) 0, /* nb_absolute */
33902 : (inquiry) 0, /* nb_nonzero */
33903 : (unaryfunc) 0, /* nb_invert */
33904 : (binaryfunc) 0, /* nb_lshift */
33905 : (binaryfunc) 0, /* nb_rshift */
33906 : (binaryfunc) 0, /* nb_and */
33907 : (binaryfunc) 0, /* nb_xor */
33908 : (binaryfunc) 0, /* nb_or */
33909 : #if PY_VERSION_HEX < 0x03000000
33910 : (coercion) 0, /* nb_coerce */
33911 : #endif
33912 : (unaryfunc) 0, /* nb_int */
33913 : #if PY_VERSION_HEX >= 0x03000000
33914 : (void*) 0, /* nb_reserved */
33915 : #else
33916 : (unaryfunc) 0, /* nb_long */
33917 : #endif
33918 : (unaryfunc) 0, /* nb_float */
33919 : #if PY_VERSION_HEX < 0x03000000
33920 : (unaryfunc) 0, /* nb_oct */
33921 : (unaryfunc) 0, /* nb_hex */
33922 : #endif
33923 : (binaryfunc) 0, /* nb_inplace_add */
33924 : (binaryfunc) 0, /* nb_inplace_subtract */
33925 : (binaryfunc) 0, /* nb_inplace_multiply */
33926 : #if PY_VERSION_HEX < 0x03000000
33927 : (binaryfunc) 0, /* nb_inplace_divide */
33928 : #endif
33929 : (binaryfunc) 0, /* nb_inplace_remainder */
33930 : (ternaryfunc) 0, /* nb_inplace_power */
33931 : (binaryfunc) 0, /* nb_inplace_lshift */
33932 : (binaryfunc) 0, /* nb_inplace_rshift */
33933 : (binaryfunc) 0, /* nb_inplace_and */
33934 : (binaryfunc) 0, /* nb_inplace_xor */
33935 : (binaryfunc) 0, /* nb_inplace_or */
33936 : (binaryfunc) 0, /* nb_floor_divide */
33937 : (binaryfunc) 0, /* nb_true_divide */
33938 : (binaryfunc) 0, /* nb_inplace_floor_divide */
33939 : (binaryfunc) 0, /* nb_inplace_true_divide */
33940 : #if PY_VERSION_HEX >= 0x02050000
33941 : (unaryfunc) 0, /* nb_index */
33942 : #endif
33943 : },
33944 : {
33945 : (lenfunc) 0, /* mp_length */
33946 : (binaryfunc) 0, /* mp_subscript */
33947 : (objobjargproc) 0, /* mp_ass_subscript */
33948 : },
33949 : {
33950 : (lenfunc) 0, /* sq_length */
33951 : (binaryfunc) 0, /* sq_concat */
33952 : (ssizeargfunc) 0, /* sq_repeat */
33953 : (ssizeargfunc) 0, /* sq_item */
33954 : #if PY_VERSION_HEX >= 0x03000000
33955 : (void*) 0, /* was_sq_slice */
33956 : #else
33957 : (ssizessizeargfunc) 0, /* sq_slice */
33958 : #endif
33959 : (ssizeobjargproc) 0, /* sq_ass_item */
33960 : #if PY_VERSION_HEX >= 0x03000000
33961 : (void*) 0, /* was_sq_ass_slice */
33962 : #else
33963 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
33964 : #endif
33965 : (objobjproc) 0, /* sq_contains */
33966 : (binaryfunc) 0, /* sq_inplace_concat */
33967 : (ssizeargfunc) 0, /* sq_inplace_repeat */
33968 : },
33969 : {
33970 : #if PY_VERSION_HEX < 0x03000000
33971 : (readbufferproc) 0, /* bf_getreadbuffer */
33972 : (writebufferproc) 0, /* bf_getwritebuffer */
33973 : (segcountproc) 0, /* bf_getsegcount */
33974 : (charbufferproc) 0, /* bf_getcharbuffer */
33975 : #endif
33976 : #if PY_VERSION_HEX >= 0x02060000
33977 : (getbufferproc) 0, /* bf_getbuffer */
33978 : (releasebufferproc) 0, /* bf_releasebuffer */
33979 : #endif
33980 : },
33981 : (PyObject*) 0, /* ht_name */
33982 : (PyObject*) 0, /* ht_slots */
33983 : };
33984 :
33985 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_key_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_key_type};
33986 :
33987 6 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_invalid_key)
33988 : static SwigPyGetSet _gpgme_invalid_key_fpr_getset = { _wrap__gpgme_invalid_key_fpr_get, _wrap__gpgme_invalid_key_fpr_set };
33989 : static SwigPyGetSet _gpgme_invalid_key_reason_getset = { _wrap__gpgme_invalid_key_reason_get, _wrap__gpgme_invalid_key_reason_set };
33990 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_invalid_key_getset[] = {
33991 : { (char*) "fpr", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_invalid_key.fpr", (void*) &_gpgme_invalid_key_fpr_getset }
33992 : ,
33993 : { (char*) "reason", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_invalid_key.reason", (void*) &_gpgme_invalid_key_reason_getset }
33994 : ,
33995 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
33996 : };
33997 :
33998 : SWIGINTERN PyObject *
33999 0 : SwigPyBuiltin___gpgme_invalid_key_richcompare(PyObject *self, PyObject *other, int op) {
34000 0 : PyObject *result = NULL;
34001 0 : PyObject *tuple = PyTuple_New(1);
34002 : assert(tuple);
34003 0 : PyTuple_SET_ITEM(tuple, 0, other);
34004 0 : Py_XINCREF(other);
34005 : if (!result) {
34006 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
34007 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
34008 : } else {
34009 0 : result = Py_NotImplemented;
34010 0 : Py_INCREF(result);
34011 : }
34012 : }
34013 0 : Py_DECREF(tuple);
34014 0 : return result;
34015 : }
34016 :
34017 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_invalid_key_methods[] = {
34018 : { NULL, NULL, 0, NULL } /* Sentinel */
34019 : };
34020 :
34021 : static PyHeapTypeObject SwigPyBuiltin___gpgme_invalid_key_type = {
34022 : {
34023 : #if PY_VERSION_HEX >= 0x03000000
34024 : PyVarObject_HEAD_INIT(NULL, 0)
34025 : #else
34026 : PyObject_HEAD_INIT(NULL)
34027 : 0, /* ob_size */
34028 : #endif
34029 : "_gpgme_invalid_key", /* tp_name */
34030 : sizeof(SwigPyObject), /* tp_basicsize */
34031 : 0, /* tp_itemsize */
34032 : (destructor) _wrap_delete__gpgme_invalid_key_closure, /* tp_dealloc */
34033 : (printfunc) 0, /* tp_print */
34034 : (getattrfunc) 0, /* tp_getattr */
34035 : (setattrfunc) 0, /* tp_setattr */
34036 : #if PY_VERSION_HEX >= 0x03000000
34037 : 0, /* tp_compare */
34038 : #else
34039 : (cmpfunc) 0, /* tp_compare */
34040 : #endif
34041 : (reprfunc) 0, /* tp_repr */
34042 : &SwigPyBuiltin___gpgme_invalid_key_type.as_number, /* tp_as_number */
34043 : &SwigPyBuiltin___gpgme_invalid_key_type.as_sequence, /* tp_as_sequence */
34044 : &SwigPyBuiltin___gpgme_invalid_key_type.as_mapping, /* tp_as_mapping */
34045 : (hashfunc) 0, /* tp_hash */
34046 : (ternaryfunc) 0, /* tp_call */
34047 : (reprfunc) 0, /* tp_str */
34048 : (getattrofunc) 0, /* tp_getattro */
34049 : (setattrofunc) 0, /* tp_setattro */
34050 : &SwigPyBuiltin___gpgme_invalid_key_type.as_buffer, /* tp_as_buffer */
34051 : #if PY_VERSION_HEX >= 0x03000000
34052 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
34053 : #else
34054 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
34055 : #endif
34056 : "::_gpgme_invalid_key", /* tp_doc */
34057 : (traverseproc) 0, /* tp_traverse */
34058 : (inquiry) 0, /* tp_clear */
34059 : (richcmpfunc) SwigPyBuiltin___gpgme_invalid_key_richcompare, /* feature:python:tp_richcompare */
34060 : 0, /* tp_weaklistoffset */
34061 : (getiterfunc) 0, /* tp_iter */
34062 : (iternextfunc) 0, /* tp_iternext */
34063 : SwigPyBuiltin___gpgme_invalid_key_methods, /* tp_methods */
34064 : 0, /* tp_members */
34065 : SwigPyBuiltin___gpgme_invalid_key_getset, /* tp_getset */
34066 : 0, /* tp_base */
34067 : 0, /* tp_dict */
34068 : (descrgetfunc) 0, /* tp_descr_get */
34069 : (descrsetfunc) 0, /* tp_descr_set */
34070 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
34071 : (initproc) _wrap_new__gpgme_invalid_key, /* tp_init */
34072 : (allocfunc) 0, /* tp_alloc */
34073 : (newfunc) 0, /* tp_new */
34074 : (freefunc) 0, /* tp_free */
34075 : (inquiry) 0, /* tp_is_gc */
34076 : (PyObject*) 0, /* tp_bases */
34077 : (PyObject*) 0, /* tp_mro */
34078 : (PyObject*) 0, /* tp_cache */
34079 : (PyObject*) 0, /* tp_subclasses */
34080 : (PyObject*) 0, /* tp_weaklist */
34081 : (destructor) 0, /* tp_del */
34082 : #if PY_VERSION_HEX >= 0x02060000
34083 : (int) 0, /* tp_version_tag */
34084 : #endif
34085 : },
34086 : {
34087 : (binaryfunc) 0, /* nb_add */
34088 : (binaryfunc) 0, /* nb_subtract */
34089 : (binaryfunc) 0, /* nb_multiply */
34090 : #if PY_VERSION_HEX < 0x03000000
34091 : (binaryfunc) 0, /* nb_divide */
34092 : #endif
34093 : (binaryfunc) 0, /* nb_remainder */
34094 : (binaryfunc) 0, /* nb_divmod */
34095 : (ternaryfunc) 0, /* nb_power */
34096 : (unaryfunc) 0, /* nb_negative */
34097 : (unaryfunc) 0, /* nb_positive */
34098 : (unaryfunc) 0, /* nb_absolute */
34099 : (inquiry) 0, /* nb_nonzero */
34100 : (unaryfunc) 0, /* nb_invert */
34101 : (binaryfunc) 0, /* nb_lshift */
34102 : (binaryfunc) 0, /* nb_rshift */
34103 : (binaryfunc) 0, /* nb_and */
34104 : (binaryfunc) 0, /* nb_xor */
34105 : (binaryfunc) 0, /* nb_or */
34106 : #if PY_VERSION_HEX < 0x03000000
34107 : (coercion) 0, /* nb_coerce */
34108 : #endif
34109 : (unaryfunc) 0, /* nb_int */
34110 : #if PY_VERSION_HEX >= 0x03000000
34111 : (void*) 0, /* nb_reserved */
34112 : #else
34113 : (unaryfunc) 0, /* nb_long */
34114 : #endif
34115 : (unaryfunc) 0, /* nb_float */
34116 : #if PY_VERSION_HEX < 0x03000000
34117 : (unaryfunc) 0, /* nb_oct */
34118 : (unaryfunc) 0, /* nb_hex */
34119 : #endif
34120 : (binaryfunc) 0, /* nb_inplace_add */
34121 : (binaryfunc) 0, /* nb_inplace_subtract */
34122 : (binaryfunc) 0, /* nb_inplace_multiply */
34123 : #if PY_VERSION_HEX < 0x03000000
34124 : (binaryfunc) 0, /* nb_inplace_divide */
34125 : #endif
34126 : (binaryfunc) 0, /* nb_inplace_remainder */
34127 : (ternaryfunc) 0, /* nb_inplace_power */
34128 : (binaryfunc) 0, /* nb_inplace_lshift */
34129 : (binaryfunc) 0, /* nb_inplace_rshift */
34130 : (binaryfunc) 0, /* nb_inplace_and */
34131 : (binaryfunc) 0, /* nb_inplace_xor */
34132 : (binaryfunc) 0, /* nb_inplace_or */
34133 : (binaryfunc) 0, /* nb_floor_divide */
34134 : (binaryfunc) 0, /* nb_true_divide */
34135 : (binaryfunc) 0, /* nb_inplace_floor_divide */
34136 : (binaryfunc) 0, /* nb_inplace_true_divide */
34137 : #if PY_VERSION_HEX >= 0x02050000
34138 : (unaryfunc) 0, /* nb_index */
34139 : #endif
34140 : },
34141 : {
34142 : (lenfunc) 0, /* mp_length */
34143 : (binaryfunc) 0, /* mp_subscript */
34144 : (objobjargproc) 0, /* mp_ass_subscript */
34145 : },
34146 : {
34147 : (lenfunc) 0, /* sq_length */
34148 : (binaryfunc) 0, /* sq_concat */
34149 : (ssizeargfunc) 0, /* sq_repeat */
34150 : (ssizeargfunc) 0, /* sq_item */
34151 : #if PY_VERSION_HEX >= 0x03000000
34152 : (void*) 0, /* was_sq_slice */
34153 : #else
34154 : (ssizessizeargfunc) 0, /* sq_slice */
34155 : #endif
34156 : (ssizeobjargproc) 0, /* sq_ass_item */
34157 : #if PY_VERSION_HEX >= 0x03000000
34158 : (void*) 0, /* was_sq_ass_slice */
34159 : #else
34160 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
34161 : #endif
34162 : (objobjproc) 0, /* sq_contains */
34163 : (binaryfunc) 0, /* sq_inplace_concat */
34164 : (ssizeargfunc) 0, /* sq_inplace_repeat */
34165 : },
34166 : {
34167 : #if PY_VERSION_HEX < 0x03000000
34168 : (readbufferproc) 0, /* bf_getreadbuffer */
34169 : (writebufferproc) 0, /* bf_getwritebuffer */
34170 : (segcountproc) 0, /* bf_getsegcount */
34171 : (charbufferproc) 0, /* bf_getcharbuffer */
34172 : #endif
34173 : #if PY_VERSION_HEX >= 0x02060000
34174 : (getbufferproc) 0, /* bf_getbuffer */
34175 : (releasebufferproc) 0, /* bf_releasebuffer */
34176 : #endif
34177 : },
34178 : (PyObject*) 0, /* ht_name */
34179 : (PyObject*) 0, /* ht_slots */
34180 : };
34181 :
34182 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_invalid_key_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_invalid_key_type};
34183 :
34184 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_gpgme_io_event_done_data)
34185 : static SwigPyGetSet gpgme_io_event_done_data_err_getset = { _wrap_gpgme_io_event_done_data_err_get, _wrap_gpgme_io_event_done_data_err_set };
34186 : static SwigPyGetSet gpgme_io_event_done_data_op_err_getset = { _wrap_gpgme_io_event_done_data_op_err_get, _wrap_gpgme_io_event_done_data_op_err_set };
34187 : SWIGINTERN PyGetSetDef SwigPyBuiltin__gpgme_io_event_done_data_getset[] = {
34188 : { (char*) "err", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_io_event_done_data.err", (void*) &gpgme_io_event_done_data_err_getset }
34189 : ,
34190 : { (char*) "op_err", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_io_event_done_data.op_err", (void*) &gpgme_io_event_done_data_op_err_getset }
34191 : ,
34192 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
34193 : };
34194 :
34195 : SWIGINTERN PyObject *
34196 0 : SwigPyBuiltin__gpgme_io_event_done_data_richcompare(PyObject *self, PyObject *other, int op) {
34197 0 : PyObject *result = NULL;
34198 0 : PyObject *tuple = PyTuple_New(1);
34199 : assert(tuple);
34200 0 : PyTuple_SET_ITEM(tuple, 0, other);
34201 0 : Py_XINCREF(other);
34202 : if (!result) {
34203 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
34204 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
34205 : } else {
34206 0 : result = Py_NotImplemented;
34207 0 : Py_INCREF(result);
34208 : }
34209 : }
34210 0 : Py_DECREF(tuple);
34211 0 : return result;
34212 : }
34213 :
34214 : SWIGINTERN PyMethodDef SwigPyBuiltin__gpgme_io_event_done_data_methods[] = {
34215 : { NULL, NULL, 0, NULL } /* Sentinel */
34216 : };
34217 :
34218 : static PyHeapTypeObject SwigPyBuiltin__gpgme_io_event_done_data_type = {
34219 : {
34220 : #if PY_VERSION_HEX >= 0x03000000
34221 : PyVarObject_HEAD_INIT(NULL, 0)
34222 : #else
34223 : PyObject_HEAD_INIT(NULL)
34224 : 0, /* ob_size */
34225 : #endif
34226 : "gpgme_io_event_done_data", /* tp_name */
34227 : sizeof(SwigPyObject), /* tp_basicsize */
34228 : 0, /* tp_itemsize */
34229 : (destructor) _wrap_delete_gpgme_io_event_done_data_closure, /* tp_dealloc */
34230 : (printfunc) 0, /* tp_print */
34231 : (getattrfunc) 0, /* tp_getattr */
34232 : (setattrfunc) 0, /* tp_setattr */
34233 : #if PY_VERSION_HEX >= 0x03000000
34234 : 0, /* tp_compare */
34235 : #else
34236 : (cmpfunc) 0, /* tp_compare */
34237 : #endif
34238 : (reprfunc) 0, /* tp_repr */
34239 : &SwigPyBuiltin__gpgme_io_event_done_data_type.as_number, /* tp_as_number */
34240 : &SwigPyBuiltin__gpgme_io_event_done_data_type.as_sequence, /* tp_as_sequence */
34241 : &SwigPyBuiltin__gpgme_io_event_done_data_type.as_mapping, /* tp_as_mapping */
34242 : (hashfunc) 0, /* tp_hash */
34243 : (ternaryfunc) 0, /* tp_call */
34244 : (reprfunc) 0, /* tp_str */
34245 : (getattrofunc) 0, /* tp_getattro */
34246 : (setattrofunc) 0, /* tp_setattro */
34247 : &SwigPyBuiltin__gpgme_io_event_done_data_type.as_buffer, /* tp_as_buffer */
34248 : #if PY_VERSION_HEX >= 0x03000000
34249 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
34250 : #else
34251 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
34252 : #endif
34253 : "::gpgme_io_event_done_data", /* tp_doc */
34254 : (traverseproc) 0, /* tp_traverse */
34255 : (inquiry) 0, /* tp_clear */
34256 : (richcmpfunc) SwigPyBuiltin__gpgme_io_event_done_data_richcompare, /* feature:python:tp_richcompare */
34257 : 0, /* tp_weaklistoffset */
34258 : (getiterfunc) 0, /* tp_iter */
34259 : (iternextfunc) 0, /* tp_iternext */
34260 : SwigPyBuiltin__gpgme_io_event_done_data_methods, /* tp_methods */
34261 : 0, /* tp_members */
34262 : SwigPyBuiltin__gpgme_io_event_done_data_getset, /* tp_getset */
34263 : 0, /* tp_base */
34264 : 0, /* tp_dict */
34265 : (descrgetfunc) 0, /* tp_descr_get */
34266 : (descrsetfunc) 0, /* tp_descr_set */
34267 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
34268 : (initproc) _wrap_new_gpgme_io_event_done_data, /* tp_init */
34269 : (allocfunc) 0, /* tp_alloc */
34270 : (newfunc) 0, /* tp_new */
34271 : (freefunc) 0, /* tp_free */
34272 : (inquiry) 0, /* tp_is_gc */
34273 : (PyObject*) 0, /* tp_bases */
34274 : (PyObject*) 0, /* tp_mro */
34275 : (PyObject*) 0, /* tp_cache */
34276 : (PyObject*) 0, /* tp_subclasses */
34277 : (PyObject*) 0, /* tp_weaklist */
34278 : (destructor) 0, /* tp_del */
34279 : #if PY_VERSION_HEX >= 0x02060000
34280 : (int) 0, /* tp_version_tag */
34281 : #endif
34282 : },
34283 : {
34284 : (binaryfunc) 0, /* nb_add */
34285 : (binaryfunc) 0, /* nb_subtract */
34286 : (binaryfunc) 0, /* nb_multiply */
34287 : #if PY_VERSION_HEX < 0x03000000
34288 : (binaryfunc) 0, /* nb_divide */
34289 : #endif
34290 : (binaryfunc) 0, /* nb_remainder */
34291 : (binaryfunc) 0, /* nb_divmod */
34292 : (ternaryfunc) 0, /* nb_power */
34293 : (unaryfunc) 0, /* nb_negative */
34294 : (unaryfunc) 0, /* nb_positive */
34295 : (unaryfunc) 0, /* nb_absolute */
34296 : (inquiry) 0, /* nb_nonzero */
34297 : (unaryfunc) 0, /* nb_invert */
34298 : (binaryfunc) 0, /* nb_lshift */
34299 : (binaryfunc) 0, /* nb_rshift */
34300 : (binaryfunc) 0, /* nb_and */
34301 : (binaryfunc) 0, /* nb_xor */
34302 : (binaryfunc) 0, /* nb_or */
34303 : #if PY_VERSION_HEX < 0x03000000
34304 : (coercion) 0, /* nb_coerce */
34305 : #endif
34306 : (unaryfunc) 0, /* nb_int */
34307 : #if PY_VERSION_HEX >= 0x03000000
34308 : (void*) 0, /* nb_reserved */
34309 : #else
34310 : (unaryfunc) 0, /* nb_long */
34311 : #endif
34312 : (unaryfunc) 0, /* nb_float */
34313 : #if PY_VERSION_HEX < 0x03000000
34314 : (unaryfunc) 0, /* nb_oct */
34315 : (unaryfunc) 0, /* nb_hex */
34316 : #endif
34317 : (binaryfunc) 0, /* nb_inplace_add */
34318 : (binaryfunc) 0, /* nb_inplace_subtract */
34319 : (binaryfunc) 0, /* nb_inplace_multiply */
34320 : #if PY_VERSION_HEX < 0x03000000
34321 : (binaryfunc) 0, /* nb_inplace_divide */
34322 : #endif
34323 : (binaryfunc) 0, /* nb_inplace_remainder */
34324 : (ternaryfunc) 0, /* nb_inplace_power */
34325 : (binaryfunc) 0, /* nb_inplace_lshift */
34326 : (binaryfunc) 0, /* nb_inplace_rshift */
34327 : (binaryfunc) 0, /* nb_inplace_and */
34328 : (binaryfunc) 0, /* nb_inplace_xor */
34329 : (binaryfunc) 0, /* nb_inplace_or */
34330 : (binaryfunc) 0, /* nb_floor_divide */
34331 : (binaryfunc) 0, /* nb_true_divide */
34332 : (binaryfunc) 0, /* nb_inplace_floor_divide */
34333 : (binaryfunc) 0, /* nb_inplace_true_divide */
34334 : #if PY_VERSION_HEX >= 0x02050000
34335 : (unaryfunc) 0, /* nb_index */
34336 : #endif
34337 : },
34338 : {
34339 : (lenfunc) 0, /* mp_length */
34340 : (binaryfunc) 0, /* mp_subscript */
34341 : (objobjargproc) 0, /* mp_ass_subscript */
34342 : },
34343 : {
34344 : (lenfunc) 0, /* sq_length */
34345 : (binaryfunc) 0, /* sq_concat */
34346 : (ssizeargfunc) 0, /* sq_repeat */
34347 : (ssizeargfunc) 0, /* sq_item */
34348 : #if PY_VERSION_HEX >= 0x03000000
34349 : (void*) 0, /* was_sq_slice */
34350 : #else
34351 : (ssizessizeargfunc) 0, /* sq_slice */
34352 : #endif
34353 : (ssizeobjargproc) 0, /* sq_ass_item */
34354 : #if PY_VERSION_HEX >= 0x03000000
34355 : (void*) 0, /* was_sq_ass_slice */
34356 : #else
34357 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
34358 : #endif
34359 : (objobjproc) 0, /* sq_contains */
34360 : (binaryfunc) 0, /* sq_inplace_concat */
34361 : (ssizeargfunc) 0, /* sq_inplace_repeat */
34362 : },
34363 : {
34364 : #if PY_VERSION_HEX < 0x03000000
34365 : (readbufferproc) 0, /* bf_getreadbuffer */
34366 : (writebufferproc) 0, /* bf_getwritebuffer */
34367 : (segcountproc) 0, /* bf_getsegcount */
34368 : (charbufferproc) 0, /* bf_getcharbuffer */
34369 : #endif
34370 : #if PY_VERSION_HEX >= 0x02060000
34371 : (getbufferproc) 0, /* bf_getbuffer */
34372 : (releasebufferproc) 0, /* bf_releasebuffer */
34373 : #endif
34374 : },
34375 : (PyObject*) 0, /* ht_name */
34376 : (PyObject*) 0, /* ht_slots */
34377 : };
34378 :
34379 : SWIGINTERN SwigPyClientData SwigPyBuiltin__gpgme_io_event_done_data_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__gpgme_io_event_done_data_type};
34380 :
34381 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_gpgme_io_cbs)
34382 : static SwigPyGetSet gpgme_io_cbs_event_getset = { _wrap_gpgme_io_cbs_event_get, _wrap_gpgme_io_cbs_event_set };
34383 : static SwigPyGetSet gpgme_io_cbs_event_priv_getset = { _wrap_gpgme_io_cbs_event_priv_get, _wrap_gpgme_io_cbs_event_priv_set };
34384 : static SwigPyGetSet gpgme_io_cbs_add_priv_getset = { _wrap_gpgme_io_cbs_add_priv_get, _wrap_gpgme_io_cbs_add_priv_set };
34385 : static SwigPyGetSet gpgme_io_cbs_remove_getset = { _wrap_gpgme_io_cbs_remove_get, _wrap_gpgme_io_cbs_remove_set };
34386 : static SwigPyGetSet gpgme_io_cbs_add_getset = { _wrap_gpgme_io_cbs_add_get, _wrap_gpgme_io_cbs_add_set };
34387 : SWIGINTERN PyGetSetDef SwigPyBuiltin__gpgme_io_cbs_getset[] = {
34388 : { (char*) "event", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_io_cbs.event", (void*) &gpgme_io_cbs_event_getset }
34389 : ,
34390 : { (char*) "event_priv", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_io_cbs.event_priv", (void*) &gpgme_io_cbs_event_priv_getset }
34391 : ,
34392 : { (char*) "add_priv", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_io_cbs.add_priv", (void*) &gpgme_io_cbs_add_priv_getset }
34393 : ,
34394 : { (char*) "remove", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_io_cbs.remove", (void*) &gpgme_io_cbs_remove_getset }
34395 : ,
34396 : { (char*) "add", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_io_cbs.add", (void*) &gpgme_io_cbs_add_getset }
34397 : ,
34398 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
34399 : };
34400 :
34401 : SWIGINTERN PyObject *
34402 0 : SwigPyBuiltin__gpgme_io_cbs_richcompare(PyObject *self, PyObject *other, int op) {
34403 0 : PyObject *result = NULL;
34404 0 : PyObject *tuple = PyTuple_New(1);
34405 : assert(tuple);
34406 0 : PyTuple_SET_ITEM(tuple, 0, other);
34407 0 : Py_XINCREF(other);
34408 : if (!result) {
34409 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
34410 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
34411 : } else {
34412 0 : result = Py_NotImplemented;
34413 0 : Py_INCREF(result);
34414 : }
34415 : }
34416 0 : Py_DECREF(tuple);
34417 0 : return result;
34418 : }
34419 :
34420 : SWIGINTERN PyMethodDef SwigPyBuiltin__gpgme_io_cbs_methods[] = {
34421 : { NULL, NULL, 0, NULL } /* Sentinel */
34422 : };
34423 :
34424 : static PyHeapTypeObject SwigPyBuiltin__gpgme_io_cbs_type = {
34425 : {
34426 : #if PY_VERSION_HEX >= 0x03000000
34427 : PyVarObject_HEAD_INIT(NULL, 0)
34428 : #else
34429 : PyObject_HEAD_INIT(NULL)
34430 : 0, /* ob_size */
34431 : #endif
34432 : "gpgme_io_cbs", /* tp_name */
34433 : sizeof(SwigPyObject), /* tp_basicsize */
34434 : 0, /* tp_itemsize */
34435 : (destructor) _wrap_delete_gpgme_io_cbs_closure, /* tp_dealloc */
34436 : (printfunc) 0, /* tp_print */
34437 : (getattrfunc) 0, /* tp_getattr */
34438 : (setattrfunc) 0, /* tp_setattr */
34439 : #if PY_VERSION_HEX >= 0x03000000
34440 : 0, /* tp_compare */
34441 : #else
34442 : (cmpfunc) 0, /* tp_compare */
34443 : #endif
34444 : (reprfunc) 0, /* tp_repr */
34445 : &SwigPyBuiltin__gpgme_io_cbs_type.as_number, /* tp_as_number */
34446 : &SwigPyBuiltin__gpgme_io_cbs_type.as_sequence, /* tp_as_sequence */
34447 : &SwigPyBuiltin__gpgme_io_cbs_type.as_mapping, /* tp_as_mapping */
34448 : (hashfunc) 0, /* tp_hash */
34449 : (ternaryfunc) 0, /* tp_call */
34450 : (reprfunc) 0, /* tp_str */
34451 : (getattrofunc) 0, /* tp_getattro */
34452 : (setattrofunc) 0, /* tp_setattro */
34453 : &SwigPyBuiltin__gpgme_io_cbs_type.as_buffer, /* tp_as_buffer */
34454 : #if PY_VERSION_HEX >= 0x03000000
34455 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
34456 : #else
34457 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
34458 : #endif
34459 : "::gpgme_io_cbs", /* tp_doc */
34460 : (traverseproc) 0, /* tp_traverse */
34461 : (inquiry) 0, /* tp_clear */
34462 : (richcmpfunc) SwigPyBuiltin__gpgme_io_cbs_richcompare, /* feature:python:tp_richcompare */
34463 : 0, /* tp_weaklistoffset */
34464 : (getiterfunc) 0, /* tp_iter */
34465 : (iternextfunc) 0, /* tp_iternext */
34466 : SwigPyBuiltin__gpgme_io_cbs_methods, /* tp_methods */
34467 : 0, /* tp_members */
34468 : SwigPyBuiltin__gpgme_io_cbs_getset, /* tp_getset */
34469 : 0, /* tp_base */
34470 : 0, /* tp_dict */
34471 : (descrgetfunc) 0, /* tp_descr_get */
34472 : (descrsetfunc) 0, /* tp_descr_set */
34473 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
34474 : (initproc) _wrap_new_gpgme_io_cbs, /* tp_init */
34475 : (allocfunc) 0, /* tp_alloc */
34476 : (newfunc) 0, /* tp_new */
34477 : (freefunc) 0, /* tp_free */
34478 : (inquiry) 0, /* tp_is_gc */
34479 : (PyObject*) 0, /* tp_bases */
34480 : (PyObject*) 0, /* tp_mro */
34481 : (PyObject*) 0, /* tp_cache */
34482 : (PyObject*) 0, /* tp_subclasses */
34483 : (PyObject*) 0, /* tp_weaklist */
34484 : (destructor) 0, /* tp_del */
34485 : #if PY_VERSION_HEX >= 0x02060000
34486 : (int) 0, /* tp_version_tag */
34487 : #endif
34488 : },
34489 : {
34490 : (binaryfunc) 0, /* nb_add */
34491 : (binaryfunc) 0, /* nb_subtract */
34492 : (binaryfunc) 0, /* nb_multiply */
34493 : #if PY_VERSION_HEX < 0x03000000
34494 : (binaryfunc) 0, /* nb_divide */
34495 : #endif
34496 : (binaryfunc) 0, /* nb_remainder */
34497 : (binaryfunc) 0, /* nb_divmod */
34498 : (ternaryfunc) 0, /* nb_power */
34499 : (unaryfunc) 0, /* nb_negative */
34500 : (unaryfunc) 0, /* nb_positive */
34501 : (unaryfunc) 0, /* nb_absolute */
34502 : (inquiry) 0, /* nb_nonzero */
34503 : (unaryfunc) 0, /* nb_invert */
34504 : (binaryfunc) 0, /* nb_lshift */
34505 : (binaryfunc) 0, /* nb_rshift */
34506 : (binaryfunc) 0, /* nb_and */
34507 : (binaryfunc) 0, /* nb_xor */
34508 : (binaryfunc) 0, /* nb_or */
34509 : #if PY_VERSION_HEX < 0x03000000
34510 : (coercion) 0, /* nb_coerce */
34511 : #endif
34512 : (unaryfunc) 0, /* nb_int */
34513 : #if PY_VERSION_HEX >= 0x03000000
34514 : (void*) 0, /* nb_reserved */
34515 : #else
34516 : (unaryfunc) 0, /* nb_long */
34517 : #endif
34518 : (unaryfunc) 0, /* nb_float */
34519 : #if PY_VERSION_HEX < 0x03000000
34520 : (unaryfunc) 0, /* nb_oct */
34521 : (unaryfunc) 0, /* nb_hex */
34522 : #endif
34523 : (binaryfunc) 0, /* nb_inplace_add */
34524 : (binaryfunc) 0, /* nb_inplace_subtract */
34525 : (binaryfunc) 0, /* nb_inplace_multiply */
34526 : #if PY_VERSION_HEX < 0x03000000
34527 : (binaryfunc) 0, /* nb_inplace_divide */
34528 : #endif
34529 : (binaryfunc) 0, /* nb_inplace_remainder */
34530 : (ternaryfunc) 0, /* nb_inplace_power */
34531 : (binaryfunc) 0, /* nb_inplace_lshift */
34532 : (binaryfunc) 0, /* nb_inplace_rshift */
34533 : (binaryfunc) 0, /* nb_inplace_and */
34534 : (binaryfunc) 0, /* nb_inplace_xor */
34535 : (binaryfunc) 0, /* nb_inplace_or */
34536 : (binaryfunc) 0, /* nb_floor_divide */
34537 : (binaryfunc) 0, /* nb_true_divide */
34538 : (binaryfunc) 0, /* nb_inplace_floor_divide */
34539 : (binaryfunc) 0, /* nb_inplace_true_divide */
34540 : #if PY_VERSION_HEX >= 0x02050000
34541 : (unaryfunc) 0, /* nb_index */
34542 : #endif
34543 : },
34544 : {
34545 : (lenfunc) 0, /* mp_length */
34546 : (binaryfunc) 0, /* mp_subscript */
34547 : (objobjargproc) 0, /* mp_ass_subscript */
34548 : },
34549 : {
34550 : (lenfunc) 0, /* sq_length */
34551 : (binaryfunc) 0, /* sq_concat */
34552 : (ssizeargfunc) 0, /* sq_repeat */
34553 : (ssizeargfunc) 0, /* sq_item */
34554 : #if PY_VERSION_HEX >= 0x03000000
34555 : (void*) 0, /* was_sq_slice */
34556 : #else
34557 : (ssizessizeargfunc) 0, /* sq_slice */
34558 : #endif
34559 : (ssizeobjargproc) 0, /* sq_ass_item */
34560 : #if PY_VERSION_HEX >= 0x03000000
34561 : (void*) 0, /* was_sq_ass_slice */
34562 : #else
34563 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
34564 : #endif
34565 : (objobjproc) 0, /* sq_contains */
34566 : (binaryfunc) 0, /* sq_inplace_concat */
34567 : (ssizeargfunc) 0, /* sq_inplace_repeat */
34568 : },
34569 : {
34570 : #if PY_VERSION_HEX < 0x03000000
34571 : (readbufferproc) 0, /* bf_getreadbuffer */
34572 : (writebufferproc) 0, /* bf_getwritebuffer */
34573 : (segcountproc) 0, /* bf_getsegcount */
34574 : (charbufferproc) 0, /* bf_getcharbuffer */
34575 : #endif
34576 : #if PY_VERSION_HEX >= 0x02060000
34577 : (getbufferproc) 0, /* bf_getbuffer */
34578 : (releasebufferproc) 0, /* bf_releasebuffer */
34579 : #endif
34580 : },
34581 : (PyObject*) 0, /* ht_name */
34582 : (PyObject*) 0, /* ht_slots */
34583 : };
34584 :
34585 : SWIGINTERN SwigPyClientData SwigPyBuiltin__gpgme_io_cbs_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__gpgme_io_cbs_type};
34586 :
34587 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_gpgme_data_cbs)
34588 : static SwigPyGetSet gpgme_data_cbs_seek_getset = { _wrap_gpgme_data_cbs_seek_get, _wrap_gpgme_data_cbs_seek_set };
34589 : static SwigPyGetSet gpgme_data_cbs_write_getset = { _wrap_gpgme_data_cbs_write_get, _wrap_gpgme_data_cbs_write_set };
34590 : static SwigPyGetSet gpgme_data_cbs_read_getset = { _wrap_gpgme_data_cbs_read_get, _wrap_gpgme_data_cbs_read_set };
34591 : static SwigPyGetSet gpgme_data_cbs_release_getset = { _wrap_gpgme_data_cbs_release_get, _wrap_gpgme_data_cbs_release_set };
34592 : SWIGINTERN PyGetSetDef SwigPyBuiltin__gpgme_data_cbs_getset[] = {
34593 : { (char*) "seek", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_data_cbs.seek", (void*) &gpgme_data_cbs_seek_getset }
34594 : ,
34595 : { (char*) "write", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_data_cbs.write", (void*) &gpgme_data_cbs_write_getset }
34596 : ,
34597 : { (char*) "read", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_data_cbs.read", (void*) &gpgme_data_cbs_read_getset }
34598 : ,
34599 : { (char*) "release", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_data_cbs.release", (void*) &gpgme_data_cbs_release_getset }
34600 : ,
34601 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
34602 : };
34603 :
34604 : SWIGINTERN PyObject *
34605 0 : SwigPyBuiltin__gpgme_data_cbs_richcompare(PyObject *self, PyObject *other, int op) {
34606 0 : PyObject *result = NULL;
34607 0 : PyObject *tuple = PyTuple_New(1);
34608 : assert(tuple);
34609 0 : PyTuple_SET_ITEM(tuple, 0, other);
34610 0 : Py_XINCREF(other);
34611 : if (!result) {
34612 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
34613 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
34614 : } else {
34615 0 : result = Py_NotImplemented;
34616 0 : Py_INCREF(result);
34617 : }
34618 : }
34619 0 : Py_DECREF(tuple);
34620 0 : return result;
34621 : }
34622 :
34623 : SWIGINTERN PyMethodDef SwigPyBuiltin__gpgme_data_cbs_methods[] = {
34624 : { NULL, NULL, 0, NULL } /* Sentinel */
34625 : };
34626 :
34627 : static PyHeapTypeObject SwigPyBuiltin__gpgme_data_cbs_type = {
34628 : {
34629 : #if PY_VERSION_HEX >= 0x03000000
34630 : PyVarObject_HEAD_INIT(NULL, 0)
34631 : #else
34632 : PyObject_HEAD_INIT(NULL)
34633 : 0, /* ob_size */
34634 : #endif
34635 : "gpgme_data_cbs", /* tp_name */
34636 : sizeof(SwigPyObject), /* tp_basicsize */
34637 : 0, /* tp_itemsize */
34638 : (destructor) _wrap_delete_gpgme_data_cbs_closure, /* tp_dealloc */
34639 : (printfunc) 0, /* tp_print */
34640 : (getattrfunc) 0, /* tp_getattr */
34641 : (setattrfunc) 0, /* tp_setattr */
34642 : #if PY_VERSION_HEX >= 0x03000000
34643 : 0, /* tp_compare */
34644 : #else
34645 : (cmpfunc) 0, /* tp_compare */
34646 : #endif
34647 : (reprfunc) 0, /* tp_repr */
34648 : &SwigPyBuiltin__gpgme_data_cbs_type.as_number, /* tp_as_number */
34649 : &SwigPyBuiltin__gpgme_data_cbs_type.as_sequence, /* tp_as_sequence */
34650 : &SwigPyBuiltin__gpgme_data_cbs_type.as_mapping, /* tp_as_mapping */
34651 : (hashfunc) 0, /* tp_hash */
34652 : (ternaryfunc) 0, /* tp_call */
34653 : (reprfunc) 0, /* tp_str */
34654 : (getattrofunc) 0, /* tp_getattro */
34655 : (setattrofunc) 0, /* tp_setattro */
34656 : &SwigPyBuiltin__gpgme_data_cbs_type.as_buffer, /* tp_as_buffer */
34657 : #if PY_VERSION_HEX >= 0x03000000
34658 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
34659 : #else
34660 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
34661 : #endif
34662 : "::gpgme_data_cbs", /* tp_doc */
34663 : (traverseproc) 0, /* tp_traverse */
34664 : (inquiry) 0, /* tp_clear */
34665 : (richcmpfunc) SwigPyBuiltin__gpgme_data_cbs_richcompare, /* feature:python:tp_richcompare */
34666 : 0, /* tp_weaklistoffset */
34667 : (getiterfunc) 0, /* tp_iter */
34668 : (iternextfunc) 0, /* tp_iternext */
34669 : SwigPyBuiltin__gpgme_data_cbs_methods, /* tp_methods */
34670 : 0, /* tp_members */
34671 : SwigPyBuiltin__gpgme_data_cbs_getset, /* tp_getset */
34672 : 0, /* tp_base */
34673 : 0, /* tp_dict */
34674 : (descrgetfunc) 0, /* tp_descr_get */
34675 : (descrsetfunc) 0, /* tp_descr_set */
34676 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
34677 : (initproc) _wrap_new_gpgme_data_cbs, /* tp_init */
34678 : (allocfunc) 0, /* tp_alloc */
34679 : (newfunc) 0, /* tp_new */
34680 : (freefunc) 0, /* tp_free */
34681 : (inquiry) 0, /* tp_is_gc */
34682 : (PyObject*) 0, /* tp_bases */
34683 : (PyObject*) 0, /* tp_mro */
34684 : (PyObject*) 0, /* tp_cache */
34685 : (PyObject*) 0, /* tp_subclasses */
34686 : (PyObject*) 0, /* tp_weaklist */
34687 : (destructor) 0, /* tp_del */
34688 : #if PY_VERSION_HEX >= 0x02060000
34689 : (int) 0, /* tp_version_tag */
34690 : #endif
34691 : },
34692 : {
34693 : (binaryfunc) 0, /* nb_add */
34694 : (binaryfunc) 0, /* nb_subtract */
34695 : (binaryfunc) 0, /* nb_multiply */
34696 : #if PY_VERSION_HEX < 0x03000000
34697 : (binaryfunc) 0, /* nb_divide */
34698 : #endif
34699 : (binaryfunc) 0, /* nb_remainder */
34700 : (binaryfunc) 0, /* nb_divmod */
34701 : (ternaryfunc) 0, /* nb_power */
34702 : (unaryfunc) 0, /* nb_negative */
34703 : (unaryfunc) 0, /* nb_positive */
34704 : (unaryfunc) 0, /* nb_absolute */
34705 : (inquiry) 0, /* nb_nonzero */
34706 : (unaryfunc) 0, /* nb_invert */
34707 : (binaryfunc) 0, /* nb_lshift */
34708 : (binaryfunc) 0, /* nb_rshift */
34709 : (binaryfunc) 0, /* nb_and */
34710 : (binaryfunc) 0, /* nb_xor */
34711 : (binaryfunc) 0, /* nb_or */
34712 : #if PY_VERSION_HEX < 0x03000000
34713 : (coercion) 0, /* nb_coerce */
34714 : #endif
34715 : (unaryfunc) 0, /* nb_int */
34716 : #if PY_VERSION_HEX >= 0x03000000
34717 : (void*) 0, /* nb_reserved */
34718 : #else
34719 : (unaryfunc) 0, /* nb_long */
34720 : #endif
34721 : (unaryfunc) 0, /* nb_float */
34722 : #if PY_VERSION_HEX < 0x03000000
34723 : (unaryfunc) 0, /* nb_oct */
34724 : (unaryfunc) 0, /* nb_hex */
34725 : #endif
34726 : (binaryfunc) 0, /* nb_inplace_add */
34727 : (binaryfunc) 0, /* nb_inplace_subtract */
34728 : (binaryfunc) 0, /* nb_inplace_multiply */
34729 : #if PY_VERSION_HEX < 0x03000000
34730 : (binaryfunc) 0, /* nb_inplace_divide */
34731 : #endif
34732 : (binaryfunc) 0, /* nb_inplace_remainder */
34733 : (ternaryfunc) 0, /* nb_inplace_power */
34734 : (binaryfunc) 0, /* nb_inplace_lshift */
34735 : (binaryfunc) 0, /* nb_inplace_rshift */
34736 : (binaryfunc) 0, /* nb_inplace_and */
34737 : (binaryfunc) 0, /* nb_inplace_xor */
34738 : (binaryfunc) 0, /* nb_inplace_or */
34739 : (binaryfunc) 0, /* nb_floor_divide */
34740 : (binaryfunc) 0, /* nb_true_divide */
34741 : (binaryfunc) 0, /* nb_inplace_floor_divide */
34742 : (binaryfunc) 0, /* nb_inplace_true_divide */
34743 : #if PY_VERSION_HEX >= 0x02050000
34744 : (unaryfunc) 0, /* nb_index */
34745 : #endif
34746 : },
34747 : {
34748 : (lenfunc) 0, /* mp_length */
34749 : (binaryfunc) 0, /* mp_subscript */
34750 : (objobjargproc) 0, /* mp_ass_subscript */
34751 : },
34752 : {
34753 : (lenfunc) 0, /* sq_length */
34754 : (binaryfunc) 0, /* sq_concat */
34755 : (ssizeargfunc) 0, /* sq_repeat */
34756 : (ssizeargfunc) 0, /* sq_item */
34757 : #if PY_VERSION_HEX >= 0x03000000
34758 : (void*) 0, /* was_sq_slice */
34759 : #else
34760 : (ssizessizeargfunc) 0, /* sq_slice */
34761 : #endif
34762 : (ssizeobjargproc) 0, /* sq_ass_item */
34763 : #if PY_VERSION_HEX >= 0x03000000
34764 : (void*) 0, /* was_sq_ass_slice */
34765 : #else
34766 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
34767 : #endif
34768 : (objobjproc) 0, /* sq_contains */
34769 : (binaryfunc) 0, /* sq_inplace_concat */
34770 : (ssizeargfunc) 0, /* sq_inplace_repeat */
34771 : },
34772 : {
34773 : #if PY_VERSION_HEX < 0x03000000
34774 : (readbufferproc) 0, /* bf_getreadbuffer */
34775 : (writebufferproc) 0, /* bf_getwritebuffer */
34776 : (segcountproc) 0, /* bf_getsegcount */
34777 : (charbufferproc) 0, /* bf_getcharbuffer */
34778 : #endif
34779 : #if PY_VERSION_HEX >= 0x02060000
34780 : (getbufferproc) 0, /* bf_getbuffer */
34781 : (releasebufferproc) 0, /* bf_releasebuffer */
34782 : #endif
34783 : },
34784 : (PyObject*) 0, /* ht_name */
34785 : (PyObject*) 0, /* ht_slots */
34786 : };
34787 :
34788 : SWIGINTERN SwigPyClientData SwigPyBuiltin__gpgme_data_cbs_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__gpgme_data_cbs_type};
34789 :
34790 11 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_op_encrypt_result)
34791 : static SwigPyGetSet _gpgme_op_encrypt_result_invalid_recipients_getset = { _wrap__gpgme_op_encrypt_result_invalid_recipients_get, _wrap__gpgme_op_encrypt_result_invalid_recipients_set };
34792 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_op_encrypt_result_getset[] = {
34793 : { (char*) "invalid_recipients", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_encrypt_result.invalid_recipients", (void*) &_gpgme_op_encrypt_result_invalid_recipients_getset }
34794 : ,
34795 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
34796 : };
34797 :
34798 : SWIGINTERN PyObject *
34799 0 : SwigPyBuiltin___gpgme_op_encrypt_result_richcompare(PyObject *self, PyObject *other, int op) {
34800 0 : PyObject *result = NULL;
34801 0 : PyObject *tuple = PyTuple_New(1);
34802 : assert(tuple);
34803 0 : PyTuple_SET_ITEM(tuple, 0, other);
34804 0 : Py_XINCREF(other);
34805 : if (!result) {
34806 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
34807 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
34808 : } else {
34809 0 : result = Py_NotImplemented;
34810 0 : Py_INCREF(result);
34811 : }
34812 : }
34813 0 : Py_DECREF(tuple);
34814 0 : return result;
34815 : }
34816 :
34817 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_op_encrypt_result_methods[] = {
34818 : { NULL, NULL, 0, NULL } /* Sentinel */
34819 : };
34820 :
34821 : static PyHeapTypeObject SwigPyBuiltin___gpgme_op_encrypt_result_type = {
34822 : {
34823 : #if PY_VERSION_HEX >= 0x03000000
34824 : PyVarObject_HEAD_INIT(NULL, 0)
34825 : #else
34826 : PyObject_HEAD_INIT(NULL)
34827 : 0, /* ob_size */
34828 : #endif
34829 : "_gpgme_op_encrypt_result", /* tp_name */
34830 : sizeof(SwigPyObject), /* tp_basicsize */
34831 : 0, /* tp_itemsize */
34832 : (destructor) _wrap_delete__gpgme_op_encrypt_result_closure, /* tp_dealloc */
34833 : (printfunc) 0, /* tp_print */
34834 : (getattrfunc) 0, /* tp_getattr */
34835 : (setattrfunc) 0, /* tp_setattr */
34836 : #if PY_VERSION_HEX >= 0x03000000
34837 : 0, /* tp_compare */
34838 : #else
34839 : (cmpfunc) 0, /* tp_compare */
34840 : #endif
34841 : (reprfunc) 0, /* tp_repr */
34842 : &SwigPyBuiltin___gpgme_op_encrypt_result_type.as_number, /* tp_as_number */
34843 : &SwigPyBuiltin___gpgme_op_encrypt_result_type.as_sequence, /* tp_as_sequence */
34844 : &SwigPyBuiltin___gpgme_op_encrypt_result_type.as_mapping, /* tp_as_mapping */
34845 : (hashfunc) 0, /* tp_hash */
34846 : (ternaryfunc) 0, /* tp_call */
34847 : (reprfunc) 0, /* tp_str */
34848 : (getattrofunc) 0, /* tp_getattro */
34849 : (setattrofunc) 0, /* tp_setattro */
34850 : &SwigPyBuiltin___gpgme_op_encrypt_result_type.as_buffer, /* tp_as_buffer */
34851 : #if PY_VERSION_HEX >= 0x03000000
34852 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
34853 : #else
34854 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
34855 : #endif
34856 : "::_gpgme_op_encrypt_result", /* tp_doc */
34857 : (traverseproc) 0, /* tp_traverse */
34858 : (inquiry) 0, /* tp_clear */
34859 : (richcmpfunc) SwigPyBuiltin___gpgme_op_encrypt_result_richcompare, /* feature:python:tp_richcompare */
34860 : 0, /* tp_weaklistoffset */
34861 : (getiterfunc) 0, /* tp_iter */
34862 : (iternextfunc) 0, /* tp_iternext */
34863 : SwigPyBuiltin___gpgme_op_encrypt_result_methods, /* tp_methods */
34864 : 0, /* tp_members */
34865 : SwigPyBuiltin___gpgme_op_encrypt_result_getset, /* tp_getset */
34866 : 0, /* tp_base */
34867 : 0, /* tp_dict */
34868 : (descrgetfunc) 0, /* tp_descr_get */
34869 : (descrsetfunc) 0, /* tp_descr_set */
34870 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
34871 : (initproc) _wrap_new__gpgme_op_encrypt_result, /* tp_init */
34872 : (allocfunc) 0, /* tp_alloc */
34873 : (newfunc) 0, /* tp_new */
34874 : (freefunc) 0, /* tp_free */
34875 : (inquiry) 0, /* tp_is_gc */
34876 : (PyObject*) 0, /* tp_bases */
34877 : (PyObject*) 0, /* tp_mro */
34878 : (PyObject*) 0, /* tp_cache */
34879 : (PyObject*) 0, /* tp_subclasses */
34880 : (PyObject*) 0, /* tp_weaklist */
34881 : (destructor) 0, /* tp_del */
34882 : #if PY_VERSION_HEX >= 0x02060000
34883 : (int) 0, /* tp_version_tag */
34884 : #endif
34885 : },
34886 : {
34887 : (binaryfunc) 0, /* nb_add */
34888 : (binaryfunc) 0, /* nb_subtract */
34889 : (binaryfunc) 0, /* nb_multiply */
34890 : #if PY_VERSION_HEX < 0x03000000
34891 : (binaryfunc) 0, /* nb_divide */
34892 : #endif
34893 : (binaryfunc) 0, /* nb_remainder */
34894 : (binaryfunc) 0, /* nb_divmod */
34895 : (ternaryfunc) 0, /* nb_power */
34896 : (unaryfunc) 0, /* nb_negative */
34897 : (unaryfunc) 0, /* nb_positive */
34898 : (unaryfunc) 0, /* nb_absolute */
34899 : (inquiry) 0, /* nb_nonzero */
34900 : (unaryfunc) 0, /* nb_invert */
34901 : (binaryfunc) 0, /* nb_lshift */
34902 : (binaryfunc) 0, /* nb_rshift */
34903 : (binaryfunc) 0, /* nb_and */
34904 : (binaryfunc) 0, /* nb_xor */
34905 : (binaryfunc) 0, /* nb_or */
34906 : #if PY_VERSION_HEX < 0x03000000
34907 : (coercion) 0, /* nb_coerce */
34908 : #endif
34909 : (unaryfunc) 0, /* nb_int */
34910 : #if PY_VERSION_HEX >= 0x03000000
34911 : (void*) 0, /* nb_reserved */
34912 : #else
34913 : (unaryfunc) 0, /* nb_long */
34914 : #endif
34915 : (unaryfunc) 0, /* nb_float */
34916 : #if PY_VERSION_HEX < 0x03000000
34917 : (unaryfunc) 0, /* nb_oct */
34918 : (unaryfunc) 0, /* nb_hex */
34919 : #endif
34920 : (binaryfunc) 0, /* nb_inplace_add */
34921 : (binaryfunc) 0, /* nb_inplace_subtract */
34922 : (binaryfunc) 0, /* nb_inplace_multiply */
34923 : #if PY_VERSION_HEX < 0x03000000
34924 : (binaryfunc) 0, /* nb_inplace_divide */
34925 : #endif
34926 : (binaryfunc) 0, /* nb_inplace_remainder */
34927 : (ternaryfunc) 0, /* nb_inplace_power */
34928 : (binaryfunc) 0, /* nb_inplace_lshift */
34929 : (binaryfunc) 0, /* nb_inplace_rshift */
34930 : (binaryfunc) 0, /* nb_inplace_and */
34931 : (binaryfunc) 0, /* nb_inplace_xor */
34932 : (binaryfunc) 0, /* nb_inplace_or */
34933 : (binaryfunc) 0, /* nb_floor_divide */
34934 : (binaryfunc) 0, /* nb_true_divide */
34935 : (binaryfunc) 0, /* nb_inplace_floor_divide */
34936 : (binaryfunc) 0, /* nb_inplace_true_divide */
34937 : #if PY_VERSION_HEX >= 0x02050000
34938 : (unaryfunc) 0, /* nb_index */
34939 : #endif
34940 : },
34941 : {
34942 : (lenfunc) 0, /* mp_length */
34943 : (binaryfunc) 0, /* mp_subscript */
34944 : (objobjargproc) 0, /* mp_ass_subscript */
34945 : },
34946 : {
34947 : (lenfunc) 0, /* sq_length */
34948 : (binaryfunc) 0, /* sq_concat */
34949 : (ssizeargfunc) 0, /* sq_repeat */
34950 : (ssizeargfunc) 0, /* sq_item */
34951 : #if PY_VERSION_HEX >= 0x03000000
34952 : (void*) 0, /* was_sq_slice */
34953 : #else
34954 : (ssizessizeargfunc) 0, /* sq_slice */
34955 : #endif
34956 : (ssizeobjargproc) 0, /* sq_ass_item */
34957 : #if PY_VERSION_HEX >= 0x03000000
34958 : (void*) 0, /* was_sq_ass_slice */
34959 : #else
34960 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
34961 : #endif
34962 : (objobjproc) 0, /* sq_contains */
34963 : (binaryfunc) 0, /* sq_inplace_concat */
34964 : (ssizeargfunc) 0, /* sq_inplace_repeat */
34965 : },
34966 : {
34967 : #if PY_VERSION_HEX < 0x03000000
34968 : (readbufferproc) 0, /* bf_getreadbuffer */
34969 : (writebufferproc) 0, /* bf_getwritebuffer */
34970 : (segcountproc) 0, /* bf_getsegcount */
34971 : (charbufferproc) 0, /* bf_getcharbuffer */
34972 : #endif
34973 : #if PY_VERSION_HEX >= 0x02060000
34974 : (getbufferproc) 0, /* bf_getbuffer */
34975 : (releasebufferproc) 0, /* bf_releasebuffer */
34976 : #endif
34977 : },
34978 : (PyObject*) 0, /* ht_name */
34979 : (PyObject*) 0, /* ht_slots */
34980 : };
34981 :
34982 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_op_encrypt_result_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_op_encrypt_result_type};
34983 :
34984 12 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_recipient)
34985 : static SwigPyGetSet _gpgme_recipient_keyid_getset = { _wrap__gpgme_recipient_keyid_get, _wrap__gpgme_recipient_keyid_set };
34986 : static SwigPyGetSet _gpgme_recipient_pubkey_algo_getset = { _wrap__gpgme_recipient_pubkey_algo_get, _wrap__gpgme_recipient_pubkey_algo_set };
34987 : static SwigPyGetSet _gpgme_recipient__keyid_getset = { _wrap__gpgme_recipient__keyid_get, _wrap__gpgme_recipient__keyid_set };
34988 : static SwigPyGetSet _gpgme_recipient_status_getset = { _wrap__gpgme_recipient_status_get, _wrap__gpgme_recipient_status_set };
34989 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_recipient_getset[] = {
34990 : { (char*) "keyid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_recipient.keyid", (void*) &_gpgme_recipient_keyid_getset }
34991 : ,
34992 : { (char*) "pubkey_algo", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_recipient.pubkey_algo", (void*) &_gpgme_recipient_pubkey_algo_getset }
34993 : ,
34994 : { (char*) "_keyid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_recipient._keyid", (void*) &_gpgme_recipient__keyid_getset }
34995 : ,
34996 : { (char*) "status", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_recipient.status", (void*) &_gpgme_recipient_status_getset }
34997 : ,
34998 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
34999 : };
35000 :
35001 : SWIGINTERN PyObject *
35002 0 : SwigPyBuiltin___gpgme_recipient_richcompare(PyObject *self, PyObject *other, int op) {
35003 0 : PyObject *result = NULL;
35004 0 : PyObject *tuple = PyTuple_New(1);
35005 : assert(tuple);
35006 0 : PyTuple_SET_ITEM(tuple, 0, other);
35007 0 : Py_XINCREF(other);
35008 : if (!result) {
35009 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
35010 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
35011 : } else {
35012 0 : result = Py_NotImplemented;
35013 0 : Py_INCREF(result);
35014 : }
35015 : }
35016 0 : Py_DECREF(tuple);
35017 0 : return result;
35018 : }
35019 :
35020 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_recipient_methods[] = {
35021 : { NULL, NULL, 0, NULL } /* Sentinel */
35022 : };
35023 :
35024 : static PyHeapTypeObject SwigPyBuiltin___gpgme_recipient_type = {
35025 : {
35026 : #if PY_VERSION_HEX >= 0x03000000
35027 : PyVarObject_HEAD_INIT(NULL, 0)
35028 : #else
35029 : PyObject_HEAD_INIT(NULL)
35030 : 0, /* ob_size */
35031 : #endif
35032 : "_gpgme_recipient", /* tp_name */
35033 : sizeof(SwigPyObject), /* tp_basicsize */
35034 : 0, /* tp_itemsize */
35035 : (destructor) _wrap_delete__gpgme_recipient_closure, /* tp_dealloc */
35036 : (printfunc) 0, /* tp_print */
35037 : (getattrfunc) 0, /* tp_getattr */
35038 : (setattrfunc) 0, /* tp_setattr */
35039 : #if PY_VERSION_HEX >= 0x03000000
35040 : 0, /* tp_compare */
35041 : #else
35042 : (cmpfunc) 0, /* tp_compare */
35043 : #endif
35044 : (reprfunc) 0, /* tp_repr */
35045 : &SwigPyBuiltin___gpgme_recipient_type.as_number, /* tp_as_number */
35046 : &SwigPyBuiltin___gpgme_recipient_type.as_sequence, /* tp_as_sequence */
35047 : &SwigPyBuiltin___gpgme_recipient_type.as_mapping, /* tp_as_mapping */
35048 : (hashfunc) 0, /* tp_hash */
35049 : (ternaryfunc) 0, /* tp_call */
35050 : (reprfunc) 0, /* tp_str */
35051 : (getattrofunc) 0, /* tp_getattro */
35052 : (setattrofunc) 0, /* tp_setattro */
35053 : &SwigPyBuiltin___gpgme_recipient_type.as_buffer, /* tp_as_buffer */
35054 : #if PY_VERSION_HEX >= 0x03000000
35055 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
35056 : #else
35057 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
35058 : #endif
35059 : "::_gpgme_recipient", /* tp_doc */
35060 : (traverseproc) 0, /* tp_traverse */
35061 : (inquiry) 0, /* tp_clear */
35062 : (richcmpfunc) SwigPyBuiltin___gpgme_recipient_richcompare, /* feature:python:tp_richcompare */
35063 : 0, /* tp_weaklistoffset */
35064 : (getiterfunc) 0, /* tp_iter */
35065 : (iternextfunc) 0, /* tp_iternext */
35066 : SwigPyBuiltin___gpgme_recipient_methods, /* tp_methods */
35067 : 0, /* tp_members */
35068 : SwigPyBuiltin___gpgme_recipient_getset, /* tp_getset */
35069 : 0, /* tp_base */
35070 : 0, /* tp_dict */
35071 : (descrgetfunc) 0, /* tp_descr_get */
35072 : (descrsetfunc) 0, /* tp_descr_set */
35073 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
35074 : (initproc) _wrap_new__gpgme_recipient, /* tp_init */
35075 : (allocfunc) 0, /* tp_alloc */
35076 : (newfunc) 0, /* tp_new */
35077 : (freefunc) 0, /* tp_free */
35078 : (inquiry) 0, /* tp_is_gc */
35079 : (PyObject*) 0, /* tp_bases */
35080 : (PyObject*) 0, /* tp_mro */
35081 : (PyObject*) 0, /* tp_cache */
35082 : (PyObject*) 0, /* tp_subclasses */
35083 : (PyObject*) 0, /* tp_weaklist */
35084 : (destructor) 0, /* tp_del */
35085 : #if PY_VERSION_HEX >= 0x02060000
35086 : (int) 0, /* tp_version_tag */
35087 : #endif
35088 : },
35089 : {
35090 : (binaryfunc) 0, /* nb_add */
35091 : (binaryfunc) 0, /* nb_subtract */
35092 : (binaryfunc) 0, /* nb_multiply */
35093 : #if PY_VERSION_HEX < 0x03000000
35094 : (binaryfunc) 0, /* nb_divide */
35095 : #endif
35096 : (binaryfunc) 0, /* nb_remainder */
35097 : (binaryfunc) 0, /* nb_divmod */
35098 : (ternaryfunc) 0, /* nb_power */
35099 : (unaryfunc) 0, /* nb_negative */
35100 : (unaryfunc) 0, /* nb_positive */
35101 : (unaryfunc) 0, /* nb_absolute */
35102 : (inquiry) 0, /* nb_nonzero */
35103 : (unaryfunc) 0, /* nb_invert */
35104 : (binaryfunc) 0, /* nb_lshift */
35105 : (binaryfunc) 0, /* nb_rshift */
35106 : (binaryfunc) 0, /* nb_and */
35107 : (binaryfunc) 0, /* nb_xor */
35108 : (binaryfunc) 0, /* nb_or */
35109 : #if PY_VERSION_HEX < 0x03000000
35110 : (coercion) 0, /* nb_coerce */
35111 : #endif
35112 : (unaryfunc) 0, /* nb_int */
35113 : #if PY_VERSION_HEX >= 0x03000000
35114 : (void*) 0, /* nb_reserved */
35115 : #else
35116 : (unaryfunc) 0, /* nb_long */
35117 : #endif
35118 : (unaryfunc) 0, /* nb_float */
35119 : #if PY_VERSION_HEX < 0x03000000
35120 : (unaryfunc) 0, /* nb_oct */
35121 : (unaryfunc) 0, /* nb_hex */
35122 : #endif
35123 : (binaryfunc) 0, /* nb_inplace_add */
35124 : (binaryfunc) 0, /* nb_inplace_subtract */
35125 : (binaryfunc) 0, /* nb_inplace_multiply */
35126 : #if PY_VERSION_HEX < 0x03000000
35127 : (binaryfunc) 0, /* nb_inplace_divide */
35128 : #endif
35129 : (binaryfunc) 0, /* nb_inplace_remainder */
35130 : (ternaryfunc) 0, /* nb_inplace_power */
35131 : (binaryfunc) 0, /* nb_inplace_lshift */
35132 : (binaryfunc) 0, /* nb_inplace_rshift */
35133 : (binaryfunc) 0, /* nb_inplace_and */
35134 : (binaryfunc) 0, /* nb_inplace_xor */
35135 : (binaryfunc) 0, /* nb_inplace_or */
35136 : (binaryfunc) 0, /* nb_floor_divide */
35137 : (binaryfunc) 0, /* nb_true_divide */
35138 : (binaryfunc) 0, /* nb_inplace_floor_divide */
35139 : (binaryfunc) 0, /* nb_inplace_true_divide */
35140 : #if PY_VERSION_HEX >= 0x02050000
35141 : (unaryfunc) 0, /* nb_index */
35142 : #endif
35143 : },
35144 : {
35145 : (lenfunc) 0, /* mp_length */
35146 : (binaryfunc) 0, /* mp_subscript */
35147 : (objobjargproc) 0, /* mp_ass_subscript */
35148 : },
35149 : {
35150 : (lenfunc) 0, /* sq_length */
35151 : (binaryfunc) 0, /* sq_concat */
35152 : (ssizeargfunc) 0, /* sq_repeat */
35153 : (ssizeargfunc) 0, /* sq_item */
35154 : #if PY_VERSION_HEX >= 0x03000000
35155 : (void*) 0, /* was_sq_slice */
35156 : #else
35157 : (ssizessizeargfunc) 0, /* sq_slice */
35158 : #endif
35159 : (ssizeobjargproc) 0, /* sq_ass_item */
35160 : #if PY_VERSION_HEX >= 0x03000000
35161 : (void*) 0, /* was_sq_ass_slice */
35162 : #else
35163 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
35164 : #endif
35165 : (objobjproc) 0, /* sq_contains */
35166 : (binaryfunc) 0, /* sq_inplace_concat */
35167 : (ssizeargfunc) 0, /* sq_inplace_repeat */
35168 : },
35169 : {
35170 : #if PY_VERSION_HEX < 0x03000000
35171 : (readbufferproc) 0, /* bf_getreadbuffer */
35172 : (writebufferproc) 0, /* bf_getwritebuffer */
35173 : (segcountproc) 0, /* bf_getsegcount */
35174 : (charbufferproc) 0, /* bf_getcharbuffer */
35175 : #endif
35176 : #if PY_VERSION_HEX >= 0x02060000
35177 : (getbufferproc) 0, /* bf_getbuffer */
35178 : (releasebufferproc) 0, /* bf_releasebuffer */
35179 : #endif
35180 : },
35181 : (PyObject*) 0, /* ht_name */
35182 : (PyObject*) 0, /* ht_slots */
35183 : };
35184 :
35185 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_recipient_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_recipient_type};
35186 :
35187 8 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_op_decrypt_result)
35188 : static SwigPyGetSet _gpgme_op_decrypt_result__unused_getset = { _wrap__gpgme_op_decrypt_result__unused_get, _wrap__gpgme_op_decrypt_result__unused_set };
35189 : static SwigPyGetSet _gpgme_op_decrypt_result_unsupported_algorithm_getset = { _wrap__gpgme_op_decrypt_result_unsupported_algorithm_get, _wrap__gpgme_op_decrypt_result_unsupported_algorithm_set };
35190 : static SwigPyGetSet _gpgme_op_decrypt_result_recipients_getset = { _wrap__gpgme_op_decrypt_result_recipients_get, _wrap__gpgme_op_decrypt_result_recipients_set };
35191 : static SwigPyGetSet _gpgme_op_decrypt_result_wrong_key_usage_getset = { _wrap__gpgme_op_decrypt_result_wrong_key_usage_get, _wrap__gpgme_op_decrypt_result_wrong_key_usage_set };
35192 : static SwigPyGetSet _gpgme_op_decrypt_result_file_name_getset = { _wrap__gpgme_op_decrypt_result_file_name_get, _wrap__gpgme_op_decrypt_result_file_name_set };
35193 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_op_decrypt_result_getset[] = {
35194 : { (char*) "_unused", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_decrypt_result._unused", (void*) &_gpgme_op_decrypt_result__unused_getset }
35195 : ,
35196 : { (char*) "unsupported_algorithm", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_decrypt_result.unsupported_algorithm", (void*) &_gpgme_op_decrypt_result_unsupported_algorithm_getset }
35197 : ,
35198 : { (char*) "recipients", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_decrypt_result.recipients", (void*) &_gpgme_op_decrypt_result_recipients_getset }
35199 : ,
35200 : { (char*) "wrong_key_usage", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_decrypt_result.wrong_key_usage", (void*) &_gpgme_op_decrypt_result_wrong_key_usage_getset }
35201 : ,
35202 : { (char*) "file_name", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_decrypt_result.file_name", (void*) &_gpgme_op_decrypt_result_file_name_getset }
35203 : ,
35204 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
35205 : };
35206 :
35207 : SWIGINTERN PyObject *
35208 0 : SwigPyBuiltin___gpgme_op_decrypt_result_richcompare(PyObject *self, PyObject *other, int op) {
35209 0 : PyObject *result = NULL;
35210 0 : PyObject *tuple = PyTuple_New(1);
35211 : assert(tuple);
35212 0 : PyTuple_SET_ITEM(tuple, 0, other);
35213 0 : Py_XINCREF(other);
35214 : if (!result) {
35215 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
35216 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
35217 : } else {
35218 0 : result = Py_NotImplemented;
35219 0 : Py_INCREF(result);
35220 : }
35221 : }
35222 0 : Py_DECREF(tuple);
35223 0 : return result;
35224 : }
35225 :
35226 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_op_decrypt_result_methods[] = {
35227 : { NULL, NULL, 0, NULL } /* Sentinel */
35228 : };
35229 :
35230 : static PyHeapTypeObject SwigPyBuiltin___gpgme_op_decrypt_result_type = {
35231 : {
35232 : #if PY_VERSION_HEX >= 0x03000000
35233 : PyVarObject_HEAD_INIT(NULL, 0)
35234 : #else
35235 : PyObject_HEAD_INIT(NULL)
35236 : 0, /* ob_size */
35237 : #endif
35238 : "_gpgme_op_decrypt_result", /* tp_name */
35239 : sizeof(SwigPyObject), /* tp_basicsize */
35240 : 0, /* tp_itemsize */
35241 : (destructor) _wrap_delete__gpgme_op_decrypt_result_closure, /* tp_dealloc */
35242 : (printfunc) 0, /* tp_print */
35243 : (getattrfunc) 0, /* tp_getattr */
35244 : (setattrfunc) 0, /* tp_setattr */
35245 : #if PY_VERSION_HEX >= 0x03000000
35246 : 0, /* tp_compare */
35247 : #else
35248 : (cmpfunc) 0, /* tp_compare */
35249 : #endif
35250 : (reprfunc) 0, /* tp_repr */
35251 : &SwigPyBuiltin___gpgme_op_decrypt_result_type.as_number, /* tp_as_number */
35252 : &SwigPyBuiltin___gpgme_op_decrypt_result_type.as_sequence, /* tp_as_sequence */
35253 : &SwigPyBuiltin___gpgme_op_decrypt_result_type.as_mapping, /* tp_as_mapping */
35254 : (hashfunc) 0, /* tp_hash */
35255 : (ternaryfunc) 0, /* tp_call */
35256 : (reprfunc) 0, /* tp_str */
35257 : (getattrofunc) 0, /* tp_getattro */
35258 : (setattrofunc) 0, /* tp_setattro */
35259 : &SwigPyBuiltin___gpgme_op_decrypt_result_type.as_buffer, /* tp_as_buffer */
35260 : #if PY_VERSION_HEX >= 0x03000000
35261 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
35262 : #else
35263 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
35264 : #endif
35265 : "::_gpgme_op_decrypt_result", /* tp_doc */
35266 : (traverseproc) 0, /* tp_traverse */
35267 : (inquiry) 0, /* tp_clear */
35268 : (richcmpfunc) SwigPyBuiltin___gpgme_op_decrypt_result_richcompare, /* feature:python:tp_richcompare */
35269 : 0, /* tp_weaklistoffset */
35270 : (getiterfunc) 0, /* tp_iter */
35271 : (iternextfunc) 0, /* tp_iternext */
35272 : SwigPyBuiltin___gpgme_op_decrypt_result_methods, /* tp_methods */
35273 : 0, /* tp_members */
35274 : SwigPyBuiltin___gpgme_op_decrypt_result_getset, /* tp_getset */
35275 : 0, /* tp_base */
35276 : 0, /* tp_dict */
35277 : (descrgetfunc) 0, /* tp_descr_get */
35278 : (descrsetfunc) 0, /* tp_descr_set */
35279 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
35280 : (initproc) _wrap_new__gpgme_op_decrypt_result, /* tp_init */
35281 : (allocfunc) 0, /* tp_alloc */
35282 : (newfunc) 0, /* tp_new */
35283 : (freefunc) 0, /* tp_free */
35284 : (inquiry) 0, /* tp_is_gc */
35285 : (PyObject*) 0, /* tp_bases */
35286 : (PyObject*) 0, /* tp_mro */
35287 : (PyObject*) 0, /* tp_cache */
35288 : (PyObject*) 0, /* tp_subclasses */
35289 : (PyObject*) 0, /* tp_weaklist */
35290 : (destructor) 0, /* tp_del */
35291 : #if PY_VERSION_HEX >= 0x02060000
35292 : (int) 0, /* tp_version_tag */
35293 : #endif
35294 : },
35295 : {
35296 : (binaryfunc) 0, /* nb_add */
35297 : (binaryfunc) 0, /* nb_subtract */
35298 : (binaryfunc) 0, /* nb_multiply */
35299 : #if PY_VERSION_HEX < 0x03000000
35300 : (binaryfunc) 0, /* nb_divide */
35301 : #endif
35302 : (binaryfunc) 0, /* nb_remainder */
35303 : (binaryfunc) 0, /* nb_divmod */
35304 : (ternaryfunc) 0, /* nb_power */
35305 : (unaryfunc) 0, /* nb_negative */
35306 : (unaryfunc) 0, /* nb_positive */
35307 : (unaryfunc) 0, /* nb_absolute */
35308 : (inquiry) 0, /* nb_nonzero */
35309 : (unaryfunc) 0, /* nb_invert */
35310 : (binaryfunc) 0, /* nb_lshift */
35311 : (binaryfunc) 0, /* nb_rshift */
35312 : (binaryfunc) 0, /* nb_and */
35313 : (binaryfunc) 0, /* nb_xor */
35314 : (binaryfunc) 0, /* nb_or */
35315 : #if PY_VERSION_HEX < 0x03000000
35316 : (coercion) 0, /* nb_coerce */
35317 : #endif
35318 : (unaryfunc) 0, /* nb_int */
35319 : #if PY_VERSION_HEX >= 0x03000000
35320 : (void*) 0, /* nb_reserved */
35321 : #else
35322 : (unaryfunc) 0, /* nb_long */
35323 : #endif
35324 : (unaryfunc) 0, /* nb_float */
35325 : #if PY_VERSION_HEX < 0x03000000
35326 : (unaryfunc) 0, /* nb_oct */
35327 : (unaryfunc) 0, /* nb_hex */
35328 : #endif
35329 : (binaryfunc) 0, /* nb_inplace_add */
35330 : (binaryfunc) 0, /* nb_inplace_subtract */
35331 : (binaryfunc) 0, /* nb_inplace_multiply */
35332 : #if PY_VERSION_HEX < 0x03000000
35333 : (binaryfunc) 0, /* nb_inplace_divide */
35334 : #endif
35335 : (binaryfunc) 0, /* nb_inplace_remainder */
35336 : (ternaryfunc) 0, /* nb_inplace_power */
35337 : (binaryfunc) 0, /* nb_inplace_lshift */
35338 : (binaryfunc) 0, /* nb_inplace_rshift */
35339 : (binaryfunc) 0, /* nb_inplace_and */
35340 : (binaryfunc) 0, /* nb_inplace_xor */
35341 : (binaryfunc) 0, /* nb_inplace_or */
35342 : (binaryfunc) 0, /* nb_floor_divide */
35343 : (binaryfunc) 0, /* nb_true_divide */
35344 : (binaryfunc) 0, /* nb_inplace_floor_divide */
35345 : (binaryfunc) 0, /* nb_inplace_true_divide */
35346 : #if PY_VERSION_HEX >= 0x02050000
35347 : (unaryfunc) 0, /* nb_index */
35348 : #endif
35349 : },
35350 : {
35351 : (lenfunc) 0, /* mp_length */
35352 : (binaryfunc) 0, /* mp_subscript */
35353 : (objobjargproc) 0, /* mp_ass_subscript */
35354 : },
35355 : {
35356 : (lenfunc) 0, /* sq_length */
35357 : (binaryfunc) 0, /* sq_concat */
35358 : (ssizeargfunc) 0, /* sq_repeat */
35359 : (ssizeargfunc) 0, /* sq_item */
35360 : #if PY_VERSION_HEX >= 0x03000000
35361 : (void*) 0, /* was_sq_slice */
35362 : #else
35363 : (ssizessizeargfunc) 0, /* sq_slice */
35364 : #endif
35365 : (ssizeobjargproc) 0, /* sq_ass_item */
35366 : #if PY_VERSION_HEX >= 0x03000000
35367 : (void*) 0, /* was_sq_ass_slice */
35368 : #else
35369 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
35370 : #endif
35371 : (objobjproc) 0, /* sq_contains */
35372 : (binaryfunc) 0, /* sq_inplace_concat */
35373 : (ssizeargfunc) 0, /* sq_inplace_repeat */
35374 : },
35375 : {
35376 : #if PY_VERSION_HEX < 0x03000000
35377 : (readbufferproc) 0, /* bf_getreadbuffer */
35378 : (writebufferproc) 0, /* bf_getwritebuffer */
35379 : (segcountproc) 0, /* bf_getsegcount */
35380 : (charbufferproc) 0, /* bf_getcharbuffer */
35381 : #endif
35382 : #if PY_VERSION_HEX >= 0x02060000
35383 : (getbufferproc) 0, /* bf_getbuffer */
35384 : (releasebufferproc) 0, /* bf_releasebuffer */
35385 : #endif
35386 : },
35387 : (PyObject*) 0, /* ht_name */
35388 : (PyObject*) 0, /* ht_slots */
35389 : };
35390 :
35391 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_op_decrypt_result_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_op_decrypt_result_type};
35392 :
35393 46 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_new_signature)
35394 : static SwigPyGetSet _gpgme_new_signature__obsolete_class_getset = { _wrap__gpgme_new_signature__obsolete_class_get, _wrap__gpgme_new_signature__obsolete_class_set };
35395 : static SwigPyGetSet _gpgme_new_signature_sig_class_getset = { _wrap__gpgme_new_signature_sig_class_get, _wrap__gpgme_new_signature_sig_class_set };
35396 : static SwigPyGetSet _gpgme_new_signature_pubkey_algo_getset = { _wrap__gpgme_new_signature_pubkey_algo_get, _wrap__gpgme_new_signature_pubkey_algo_set };
35397 : static SwigPyGetSet _gpgme_new_signature_hash_algo_getset = { _wrap__gpgme_new_signature_hash_algo_get, _wrap__gpgme_new_signature_hash_algo_set };
35398 : static SwigPyGetSet _gpgme_new_signature_fpr_getset = { _wrap__gpgme_new_signature_fpr_get, _wrap__gpgme_new_signature_fpr_set };
35399 : static SwigPyGetSet _gpgme_new_signature_type_getset = { _wrap__gpgme_new_signature_type_get, _wrap__gpgme_new_signature_type_set };
35400 : static SwigPyGetSet _gpgme_new_signature_timestamp_getset = { _wrap__gpgme_new_signature_timestamp_get, _wrap__gpgme_new_signature_timestamp_set };
35401 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_new_signature_getset[] = {
35402 : { (char*) "_obsolete_class", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_new_signature._obsolete_class", (void*) &_gpgme_new_signature__obsolete_class_getset }
35403 : ,
35404 : { (char*) "sig_class", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_new_signature.sig_class", (void*) &_gpgme_new_signature_sig_class_getset }
35405 : ,
35406 : { (char*) "pubkey_algo", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_new_signature.pubkey_algo", (void*) &_gpgme_new_signature_pubkey_algo_getset }
35407 : ,
35408 : { (char*) "hash_algo", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_new_signature.hash_algo", (void*) &_gpgme_new_signature_hash_algo_getset }
35409 : ,
35410 : { (char*) "fpr", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_new_signature.fpr", (void*) &_gpgme_new_signature_fpr_getset }
35411 : ,
35412 : { (char*) "type", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_new_signature.type", (void*) &_gpgme_new_signature_type_getset }
35413 : ,
35414 : { (char*) "timestamp", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_new_signature.timestamp", (void*) &_gpgme_new_signature_timestamp_getset }
35415 : ,
35416 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
35417 : };
35418 :
35419 : SWIGINTERN PyObject *
35420 0 : SwigPyBuiltin___gpgme_new_signature_richcompare(PyObject *self, PyObject *other, int op) {
35421 0 : PyObject *result = NULL;
35422 0 : PyObject *tuple = PyTuple_New(1);
35423 : assert(tuple);
35424 0 : PyTuple_SET_ITEM(tuple, 0, other);
35425 0 : Py_XINCREF(other);
35426 : if (!result) {
35427 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
35428 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
35429 : } else {
35430 0 : result = Py_NotImplemented;
35431 0 : Py_INCREF(result);
35432 : }
35433 : }
35434 0 : Py_DECREF(tuple);
35435 0 : return result;
35436 : }
35437 :
35438 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_new_signature_methods[] = {
35439 : { NULL, NULL, 0, NULL } /* Sentinel */
35440 : };
35441 :
35442 : static PyHeapTypeObject SwigPyBuiltin___gpgme_new_signature_type = {
35443 : {
35444 : #if PY_VERSION_HEX >= 0x03000000
35445 : PyVarObject_HEAD_INIT(NULL, 0)
35446 : #else
35447 : PyObject_HEAD_INIT(NULL)
35448 : 0, /* ob_size */
35449 : #endif
35450 : "_gpgme_new_signature", /* tp_name */
35451 : sizeof(SwigPyObject), /* tp_basicsize */
35452 : 0, /* tp_itemsize */
35453 : (destructor) _wrap_delete__gpgme_new_signature_closure, /* tp_dealloc */
35454 : (printfunc) 0, /* tp_print */
35455 : (getattrfunc) 0, /* tp_getattr */
35456 : (setattrfunc) 0, /* tp_setattr */
35457 : #if PY_VERSION_HEX >= 0x03000000
35458 : 0, /* tp_compare */
35459 : #else
35460 : (cmpfunc) 0, /* tp_compare */
35461 : #endif
35462 : (reprfunc) 0, /* tp_repr */
35463 : &SwigPyBuiltin___gpgme_new_signature_type.as_number, /* tp_as_number */
35464 : &SwigPyBuiltin___gpgme_new_signature_type.as_sequence, /* tp_as_sequence */
35465 : &SwigPyBuiltin___gpgme_new_signature_type.as_mapping, /* tp_as_mapping */
35466 : (hashfunc) 0, /* tp_hash */
35467 : (ternaryfunc) 0, /* tp_call */
35468 : (reprfunc) 0, /* tp_str */
35469 : (getattrofunc) 0, /* tp_getattro */
35470 : (setattrofunc) 0, /* tp_setattro */
35471 : &SwigPyBuiltin___gpgme_new_signature_type.as_buffer, /* tp_as_buffer */
35472 : #if PY_VERSION_HEX >= 0x03000000
35473 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
35474 : #else
35475 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
35476 : #endif
35477 : "::_gpgme_new_signature", /* tp_doc */
35478 : (traverseproc) 0, /* tp_traverse */
35479 : (inquiry) 0, /* tp_clear */
35480 : (richcmpfunc) SwigPyBuiltin___gpgme_new_signature_richcompare, /* feature:python:tp_richcompare */
35481 : 0, /* tp_weaklistoffset */
35482 : (getiterfunc) 0, /* tp_iter */
35483 : (iternextfunc) 0, /* tp_iternext */
35484 : SwigPyBuiltin___gpgme_new_signature_methods, /* tp_methods */
35485 : 0, /* tp_members */
35486 : SwigPyBuiltin___gpgme_new_signature_getset, /* tp_getset */
35487 : 0, /* tp_base */
35488 : 0, /* tp_dict */
35489 : (descrgetfunc) 0, /* tp_descr_get */
35490 : (descrsetfunc) 0, /* tp_descr_set */
35491 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
35492 : (initproc) _wrap_new__gpgme_new_signature, /* tp_init */
35493 : (allocfunc) 0, /* tp_alloc */
35494 : (newfunc) 0, /* tp_new */
35495 : (freefunc) 0, /* tp_free */
35496 : (inquiry) 0, /* tp_is_gc */
35497 : (PyObject*) 0, /* tp_bases */
35498 : (PyObject*) 0, /* tp_mro */
35499 : (PyObject*) 0, /* tp_cache */
35500 : (PyObject*) 0, /* tp_subclasses */
35501 : (PyObject*) 0, /* tp_weaklist */
35502 : (destructor) 0, /* tp_del */
35503 : #if PY_VERSION_HEX >= 0x02060000
35504 : (int) 0, /* tp_version_tag */
35505 : #endif
35506 : },
35507 : {
35508 : (binaryfunc) 0, /* nb_add */
35509 : (binaryfunc) 0, /* nb_subtract */
35510 : (binaryfunc) 0, /* nb_multiply */
35511 : #if PY_VERSION_HEX < 0x03000000
35512 : (binaryfunc) 0, /* nb_divide */
35513 : #endif
35514 : (binaryfunc) 0, /* nb_remainder */
35515 : (binaryfunc) 0, /* nb_divmod */
35516 : (ternaryfunc) 0, /* nb_power */
35517 : (unaryfunc) 0, /* nb_negative */
35518 : (unaryfunc) 0, /* nb_positive */
35519 : (unaryfunc) 0, /* nb_absolute */
35520 : (inquiry) 0, /* nb_nonzero */
35521 : (unaryfunc) 0, /* nb_invert */
35522 : (binaryfunc) 0, /* nb_lshift */
35523 : (binaryfunc) 0, /* nb_rshift */
35524 : (binaryfunc) 0, /* nb_and */
35525 : (binaryfunc) 0, /* nb_xor */
35526 : (binaryfunc) 0, /* nb_or */
35527 : #if PY_VERSION_HEX < 0x03000000
35528 : (coercion) 0, /* nb_coerce */
35529 : #endif
35530 : (unaryfunc) 0, /* nb_int */
35531 : #if PY_VERSION_HEX >= 0x03000000
35532 : (void*) 0, /* nb_reserved */
35533 : #else
35534 : (unaryfunc) 0, /* nb_long */
35535 : #endif
35536 : (unaryfunc) 0, /* nb_float */
35537 : #if PY_VERSION_HEX < 0x03000000
35538 : (unaryfunc) 0, /* nb_oct */
35539 : (unaryfunc) 0, /* nb_hex */
35540 : #endif
35541 : (binaryfunc) 0, /* nb_inplace_add */
35542 : (binaryfunc) 0, /* nb_inplace_subtract */
35543 : (binaryfunc) 0, /* nb_inplace_multiply */
35544 : #if PY_VERSION_HEX < 0x03000000
35545 : (binaryfunc) 0, /* nb_inplace_divide */
35546 : #endif
35547 : (binaryfunc) 0, /* nb_inplace_remainder */
35548 : (ternaryfunc) 0, /* nb_inplace_power */
35549 : (binaryfunc) 0, /* nb_inplace_lshift */
35550 : (binaryfunc) 0, /* nb_inplace_rshift */
35551 : (binaryfunc) 0, /* nb_inplace_and */
35552 : (binaryfunc) 0, /* nb_inplace_xor */
35553 : (binaryfunc) 0, /* nb_inplace_or */
35554 : (binaryfunc) 0, /* nb_floor_divide */
35555 : (binaryfunc) 0, /* nb_true_divide */
35556 : (binaryfunc) 0, /* nb_inplace_floor_divide */
35557 : (binaryfunc) 0, /* nb_inplace_true_divide */
35558 : #if PY_VERSION_HEX >= 0x02050000
35559 : (unaryfunc) 0, /* nb_index */
35560 : #endif
35561 : },
35562 : {
35563 : (lenfunc) 0, /* mp_length */
35564 : (binaryfunc) 0, /* mp_subscript */
35565 : (objobjargproc) 0, /* mp_ass_subscript */
35566 : },
35567 : {
35568 : (lenfunc) 0, /* sq_length */
35569 : (binaryfunc) 0, /* sq_concat */
35570 : (ssizeargfunc) 0, /* sq_repeat */
35571 : (ssizeargfunc) 0, /* sq_item */
35572 : #if PY_VERSION_HEX >= 0x03000000
35573 : (void*) 0, /* was_sq_slice */
35574 : #else
35575 : (ssizessizeargfunc) 0, /* sq_slice */
35576 : #endif
35577 : (ssizeobjargproc) 0, /* sq_ass_item */
35578 : #if PY_VERSION_HEX >= 0x03000000
35579 : (void*) 0, /* was_sq_ass_slice */
35580 : #else
35581 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
35582 : #endif
35583 : (objobjproc) 0, /* sq_contains */
35584 : (binaryfunc) 0, /* sq_inplace_concat */
35585 : (ssizeargfunc) 0, /* sq_inplace_repeat */
35586 : },
35587 : {
35588 : #if PY_VERSION_HEX < 0x03000000
35589 : (readbufferproc) 0, /* bf_getreadbuffer */
35590 : (writebufferproc) 0, /* bf_getwritebuffer */
35591 : (segcountproc) 0, /* bf_getsegcount */
35592 : (charbufferproc) 0, /* bf_getcharbuffer */
35593 : #endif
35594 : #if PY_VERSION_HEX >= 0x02060000
35595 : (getbufferproc) 0, /* bf_getbuffer */
35596 : (releasebufferproc) 0, /* bf_releasebuffer */
35597 : #endif
35598 : },
35599 : (PyObject*) 0, /* ht_name */
35600 : (PyObject*) 0, /* ht_slots */
35601 : };
35602 :
35603 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_new_signature_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_new_signature_type};
35604 :
35605 19 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_op_sign_result)
35606 : static SwigPyGetSet _gpgme_op_sign_result_invalid_signers_getset = { _wrap__gpgme_op_sign_result_invalid_signers_get, _wrap__gpgme_op_sign_result_invalid_signers_set };
35607 : static SwigPyGetSet _gpgme_op_sign_result_signatures_getset = { _wrap__gpgme_op_sign_result_signatures_get, _wrap__gpgme_op_sign_result_signatures_set };
35608 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_op_sign_result_getset[] = {
35609 : { (char*) "invalid_signers", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_sign_result.invalid_signers", (void*) &_gpgme_op_sign_result_invalid_signers_getset }
35610 : ,
35611 : { (char*) "signatures", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_sign_result.signatures", (void*) &_gpgme_op_sign_result_signatures_getset }
35612 : ,
35613 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
35614 : };
35615 :
35616 : SWIGINTERN PyObject *
35617 0 : SwigPyBuiltin___gpgme_op_sign_result_richcompare(PyObject *self, PyObject *other, int op) {
35618 0 : PyObject *result = NULL;
35619 0 : PyObject *tuple = PyTuple_New(1);
35620 : assert(tuple);
35621 0 : PyTuple_SET_ITEM(tuple, 0, other);
35622 0 : Py_XINCREF(other);
35623 : if (!result) {
35624 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
35625 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
35626 : } else {
35627 0 : result = Py_NotImplemented;
35628 0 : Py_INCREF(result);
35629 : }
35630 : }
35631 0 : Py_DECREF(tuple);
35632 0 : return result;
35633 : }
35634 :
35635 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_op_sign_result_methods[] = {
35636 : { NULL, NULL, 0, NULL } /* Sentinel */
35637 : };
35638 :
35639 : static PyHeapTypeObject SwigPyBuiltin___gpgme_op_sign_result_type = {
35640 : {
35641 : #if PY_VERSION_HEX >= 0x03000000
35642 : PyVarObject_HEAD_INIT(NULL, 0)
35643 : #else
35644 : PyObject_HEAD_INIT(NULL)
35645 : 0, /* ob_size */
35646 : #endif
35647 : "_gpgme_op_sign_result", /* tp_name */
35648 : sizeof(SwigPyObject), /* tp_basicsize */
35649 : 0, /* tp_itemsize */
35650 : (destructor) _wrap_delete__gpgme_op_sign_result_closure, /* tp_dealloc */
35651 : (printfunc) 0, /* tp_print */
35652 : (getattrfunc) 0, /* tp_getattr */
35653 : (setattrfunc) 0, /* tp_setattr */
35654 : #if PY_VERSION_HEX >= 0x03000000
35655 : 0, /* tp_compare */
35656 : #else
35657 : (cmpfunc) 0, /* tp_compare */
35658 : #endif
35659 : (reprfunc) 0, /* tp_repr */
35660 : &SwigPyBuiltin___gpgme_op_sign_result_type.as_number, /* tp_as_number */
35661 : &SwigPyBuiltin___gpgme_op_sign_result_type.as_sequence, /* tp_as_sequence */
35662 : &SwigPyBuiltin___gpgme_op_sign_result_type.as_mapping, /* tp_as_mapping */
35663 : (hashfunc) 0, /* tp_hash */
35664 : (ternaryfunc) 0, /* tp_call */
35665 : (reprfunc) 0, /* tp_str */
35666 : (getattrofunc) 0, /* tp_getattro */
35667 : (setattrofunc) 0, /* tp_setattro */
35668 : &SwigPyBuiltin___gpgme_op_sign_result_type.as_buffer, /* tp_as_buffer */
35669 : #if PY_VERSION_HEX >= 0x03000000
35670 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
35671 : #else
35672 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
35673 : #endif
35674 : "::_gpgme_op_sign_result", /* tp_doc */
35675 : (traverseproc) 0, /* tp_traverse */
35676 : (inquiry) 0, /* tp_clear */
35677 : (richcmpfunc) SwigPyBuiltin___gpgme_op_sign_result_richcompare, /* feature:python:tp_richcompare */
35678 : 0, /* tp_weaklistoffset */
35679 : (getiterfunc) 0, /* tp_iter */
35680 : (iternextfunc) 0, /* tp_iternext */
35681 : SwigPyBuiltin___gpgme_op_sign_result_methods, /* tp_methods */
35682 : 0, /* tp_members */
35683 : SwigPyBuiltin___gpgme_op_sign_result_getset, /* tp_getset */
35684 : 0, /* tp_base */
35685 : 0, /* tp_dict */
35686 : (descrgetfunc) 0, /* tp_descr_get */
35687 : (descrsetfunc) 0, /* tp_descr_set */
35688 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
35689 : (initproc) _wrap_new__gpgme_op_sign_result, /* tp_init */
35690 : (allocfunc) 0, /* tp_alloc */
35691 : (newfunc) 0, /* tp_new */
35692 : (freefunc) 0, /* tp_free */
35693 : (inquiry) 0, /* tp_is_gc */
35694 : (PyObject*) 0, /* tp_bases */
35695 : (PyObject*) 0, /* tp_mro */
35696 : (PyObject*) 0, /* tp_cache */
35697 : (PyObject*) 0, /* tp_subclasses */
35698 : (PyObject*) 0, /* tp_weaklist */
35699 : (destructor) 0, /* tp_del */
35700 : #if PY_VERSION_HEX >= 0x02060000
35701 : (int) 0, /* tp_version_tag */
35702 : #endif
35703 : },
35704 : {
35705 : (binaryfunc) 0, /* nb_add */
35706 : (binaryfunc) 0, /* nb_subtract */
35707 : (binaryfunc) 0, /* nb_multiply */
35708 : #if PY_VERSION_HEX < 0x03000000
35709 : (binaryfunc) 0, /* nb_divide */
35710 : #endif
35711 : (binaryfunc) 0, /* nb_remainder */
35712 : (binaryfunc) 0, /* nb_divmod */
35713 : (ternaryfunc) 0, /* nb_power */
35714 : (unaryfunc) 0, /* nb_negative */
35715 : (unaryfunc) 0, /* nb_positive */
35716 : (unaryfunc) 0, /* nb_absolute */
35717 : (inquiry) 0, /* nb_nonzero */
35718 : (unaryfunc) 0, /* nb_invert */
35719 : (binaryfunc) 0, /* nb_lshift */
35720 : (binaryfunc) 0, /* nb_rshift */
35721 : (binaryfunc) 0, /* nb_and */
35722 : (binaryfunc) 0, /* nb_xor */
35723 : (binaryfunc) 0, /* nb_or */
35724 : #if PY_VERSION_HEX < 0x03000000
35725 : (coercion) 0, /* nb_coerce */
35726 : #endif
35727 : (unaryfunc) 0, /* nb_int */
35728 : #if PY_VERSION_HEX >= 0x03000000
35729 : (void*) 0, /* nb_reserved */
35730 : #else
35731 : (unaryfunc) 0, /* nb_long */
35732 : #endif
35733 : (unaryfunc) 0, /* nb_float */
35734 : #if PY_VERSION_HEX < 0x03000000
35735 : (unaryfunc) 0, /* nb_oct */
35736 : (unaryfunc) 0, /* nb_hex */
35737 : #endif
35738 : (binaryfunc) 0, /* nb_inplace_add */
35739 : (binaryfunc) 0, /* nb_inplace_subtract */
35740 : (binaryfunc) 0, /* nb_inplace_multiply */
35741 : #if PY_VERSION_HEX < 0x03000000
35742 : (binaryfunc) 0, /* nb_inplace_divide */
35743 : #endif
35744 : (binaryfunc) 0, /* nb_inplace_remainder */
35745 : (ternaryfunc) 0, /* nb_inplace_power */
35746 : (binaryfunc) 0, /* nb_inplace_lshift */
35747 : (binaryfunc) 0, /* nb_inplace_rshift */
35748 : (binaryfunc) 0, /* nb_inplace_and */
35749 : (binaryfunc) 0, /* nb_inplace_xor */
35750 : (binaryfunc) 0, /* nb_inplace_or */
35751 : (binaryfunc) 0, /* nb_floor_divide */
35752 : (binaryfunc) 0, /* nb_true_divide */
35753 : (binaryfunc) 0, /* nb_inplace_floor_divide */
35754 : (binaryfunc) 0, /* nb_inplace_true_divide */
35755 : #if PY_VERSION_HEX >= 0x02050000
35756 : (unaryfunc) 0, /* nb_index */
35757 : #endif
35758 : },
35759 : {
35760 : (lenfunc) 0, /* mp_length */
35761 : (binaryfunc) 0, /* mp_subscript */
35762 : (objobjargproc) 0, /* mp_ass_subscript */
35763 : },
35764 : {
35765 : (lenfunc) 0, /* sq_length */
35766 : (binaryfunc) 0, /* sq_concat */
35767 : (ssizeargfunc) 0, /* sq_repeat */
35768 : (ssizeargfunc) 0, /* sq_item */
35769 : #if PY_VERSION_HEX >= 0x03000000
35770 : (void*) 0, /* was_sq_slice */
35771 : #else
35772 : (ssizessizeargfunc) 0, /* sq_slice */
35773 : #endif
35774 : (ssizeobjargproc) 0, /* sq_ass_item */
35775 : #if PY_VERSION_HEX >= 0x03000000
35776 : (void*) 0, /* was_sq_ass_slice */
35777 : #else
35778 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
35779 : #endif
35780 : (objobjproc) 0, /* sq_contains */
35781 : (binaryfunc) 0, /* sq_inplace_concat */
35782 : (ssizeargfunc) 0, /* sq_inplace_repeat */
35783 : },
35784 : {
35785 : #if PY_VERSION_HEX < 0x03000000
35786 : (readbufferproc) 0, /* bf_getreadbuffer */
35787 : (writebufferproc) 0, /* bf_getwritebuffer */
35788 : (segcountproc) 0, /* bf_getsegcount */
35789 : (charbufferproc) 0, /* bf_getcharbuffer */
35790 : #endif
35791 : #if PY_VERSION_HEX >= 0x02060000
35792 : (getbufferproc) 0, /* bf_getbuffer */
35793 : (releasebufferproc) 0, /* bf_releasebuffer */
35794 : #endif
35795 : },
35796 : (PyObject*) 0, /* ht_name */
35797 : (PyObject*) 0, /* ht_slots */
35798 : };
35799 :
35800 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_op_sign_result_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_op_sign_result_type};
35801 :
35802 28 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_signature)
35803 : static SwigPyGetSet _gpgme_signature_chain_model_getset = { _wrap__gpgme_signature_chain_model_get, _wrap__gpgme_signature_chain_model_set };
35804 : static SwigPyGetSet _gpgme_signature__unused_getset = { _wrap__gpgme_signature__unused_get, _wrap__gpgme_signature__unused_set };
35805 : static SwigPyGetSet _gpgme_signature_validity_reason_getset = { _wrap__gpgme_signature_validity_reason_get, _wrap__gpgme_signature_validity_reason_set };
35806 : static SwigPyGetSet _gpgme_signature_pka_trust_getset = { _wrap__gpgme_signature_pka_trust_get, _wrap__gpgme_signature_pka_trust_set };
35807 : static SwigPyGetSet _gpgme_signature_summary_getset = { _wrap__gpgme_signature_summary_get, _wrap__gpgme_signature_summary_set };
35808 : static SwigPyGetSet _gpgme_signature_validity_getset = { _wrap__gpgme_signature_validity_get, _wrap__gpgme_signature_validity_set };
35809 : static SwigPyGetSet _gpgme_signature_key_getset = { _wrap__gpgme_signature_key_get, _wrap__gpgme_signature_key_set };
35810 : static SwigPyGetSet _gpgme_signature_fpr_getset = { _wrap__gpgme_signature_fpr_get, _wrap__gpgme_signature_fpr_set };
35811 : static SwigPyGetSet _gpgme_signature_wrong_key_usage_getset = { _wrap__gpgme_signature_wrong_key_usage_get, _wrap__gpgme_signature_wrong_key_usage_set };
35812 : static SwigPyGetSet _gpgme_signature_pubkey_algo_getset = { _wrap__gpgme_signature_pubkey_algo_get, _wrap__gpgme_signature_pubkey_algo_set };
35813 : static SwigPyGetSet _gpgme_signature_hash_algo_getset = { _wrap__gpgme_signature_hash_algo_get, _wrap__gpgme_signature_hash_algo_set };
35814 : static SwigPyGetSet _gpgme_signature_notations_getset = { _wrap__gpgme_signature_notations_get, _wrap__gpgme_signature_notations_set };
35815 : static SwigPyGetSet _gpgme_signature_status_getset = { _wrap__gpgme_signature_status_get, _wrap__gpgme_signature_status_set };
35816 : static SwigPyGetSet _gpgme_signature_timestamp_getset = { _wrap__gpgme_signature_timestamp_get, _wrap__gpgme_signature_timestamp_set };
35817 : static SwigPyGetSet _gpgme_signature_exp_timestamp_getset = { _wrap__gpgme_signature_exp_timestamp_get, _wrap__gpgme_signature_exp_timestamp_set };
35818 : static SwigPyGetSet _gpgme_signature_pka_address_getset = { _wrap__gpgme_signature_pka_address_get, _wrap__gpgme_signature_pka_address_set };
35819 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_signature_getset[] = {
35820 : { (char*) "chain_model", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.chain_model", (void*) &_gpgme_signature_chain_model_getset }
35821 : ,
35822 : { (char*) "_unused", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature._unused", (void*) &_gpgme_signature__unused_getset }
35823 : ,
35824 : { (char*) "validity_reason", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.validity_reason", (void*) &_gpgme_signature_validity_reason_getset }
35825 : ,
35826 : { (char*) "pka_trust", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.pka_trust", (void*) &_gpgme_signature_pka_trust_getset }
35827 : ,
35828 : { (char*) "summary", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.summary", (void*) &_gpgme_signature_summary_getset }
35829 : ,
35830 : { (char*) "validity", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.validity", (void*) &_gpgme_signature_validity_getset }
35831 : ,
35832 : { (char*) "key", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.key", (void*) &_gpgme_signature_key_getset }
35833 : ,
35834 : { (char*) "fpr", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.fpr", (void*) &_gpgme_signature_fpr_getset }
35835 : ,
35836 : { (char*) "wrong_key_usage", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.wrong_key_usage", (void*) &_gpgme_signature_wrong_key_usage_getset }
35837 : ,
35838 : { (char*) "pubkey_algo", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.pubkey_algo", (void*) &_gpgme_signature_pubkey_algo_getset }
35839 : ,
35840 : { (char*) "hash_algo", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.hash_algo", (void*) &_gpgme_signature_hash_algo_getset }
35841 : ,
35842 : { (char*) "notations", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.notations", (void*) &_gpgme_signature_notations_getset }
35843 : ,
35844 : { (char*) "status", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.status", (void*) &_gpgme_signature_status_getset }
35845 : ,
35846 : { (char*) "timestamp", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.timestamp", (void*) &_gpgme_signature_timestamp_getset }
35847 : ,
35848 : { (char*) "exp_timestamp", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.exp_timestamp", (void*) &_gpgme_signature_exp_timestamp_getset }
35849 : ,
35850 : { (char*) "pka_address", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_signature.pka_address", (void*) &_gpgme_signature_pka_address_getset }
35851 : ,
35852 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
35853 : };
35854 :
35855 : SWIGINTERN PyObject *
35856 0 : SwigPyBuiltin___gpgme_signature_richcompare(PyObject *self, PyObject *other, int op) {
35857 0 : PyObject *result = NULL;
35858 0 : PyObject *tuple = PyTuple_New(1);
35859 : assert(tuple);
35860 0 : PyTuple_SET_ITEM(tuple, 0, other);
35861 0 : Py_XINCREF(other);
35862 : if (!result) {
35863 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
35864 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
35865 : } else {
35866 0 : result = Py_NotImplemented;
35867 0 : Py_INCREF(result);
35868 : }
35869 : }
35870 0 : Py_DECREF(tuple);
35871 0 : return result;
35872 : }
35873 :
35874 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_signature_methods[] = {
35875 : { NULL, NULL, 0, NULL } /* Sentinel */
35876 : };
35877 :
35878 : static PyHeapTypeObject SwigPyBuiltin___gpgme_signature_type = {
35879 : {
35880 : #if PY_VERSION_HEX >= 0x03000000
35881 : PyVarObject_HEAD_INIT(NULL, 0)
35882 : #else
35883 : PyObject_HEAD_INIT(NULL)
35884 : 0, /* ob_size */
35885 : #endif
35886 : "_gpgme_signature", /* tp_name */
35887 : sizeof(SwigPyObject), /* tp_basicsize */
35888 : 0, /* tp_itemsize */
35889 : (destructor) _wrap_delete__gpgme_signature_closure, /* tp_dealloc */
35890 : (printfunc) 0, /* tp_print */
35891 : (getattrfunc) 0, /* tp_getattr */
35892 : (setattrfunc) 0, /* tp_setattr */
35893 : #if PY_VERSION_HEX >= 0x03000000
35894 : 0, /* tp_compare */
35895 : #else
35896 : (cmpfunc) 0, /* tp_compare */
35897 : #endif
35898 : (reprfunc) 0, /* tp_repr */
35899 : &SwigPyBuiltin___gpgme_signature_type.as_number, /* tp_as_number */
35900 : &SwigPyBuiltin___gpgme_signature_type.as_sequence, /* tp_as_sequence */
35901 : &SwigPyBuiltin___gpgme_signature_type.as_mapping, /* tp_as_mapping */
35902 : (hashfunc) 0, /* tp_hash */
35903 : (ternaryfunc) 0, /* tp_call */
35904 : (reprfunc) 0, /* tp_str */
35905 : (getattrofunc) 0, /* tp_getattro */
35906 : (setattrofunc) 0, /* tp_setattro */
35907 : &SwigPyBuiltin___gpgme_signature_type.as_buffer, /* tp_as_buffer */
35908 : #if PY_VERSION_HEX >= 0x03000000
35909 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
35910 : #else
35911 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
35912 : #endif
35913 : "::_gpgme_signature", /* tp_doc */
35914 : (traverseproc) 0, /* tp_traverse */
35915 : (inquiry) 0, /* tp_clear */
35916 : (richcmpfunc) SwigPyBuiltin___gpgme_signature_richcompare, /* feature:python:tp_richcompare */
35917 : 0, /* tp_weaklistoffset */
35918 : (getiterfunc) 0, /* tp_iter */
35919 : (iternextfunc) 0, /* tp_iternext */
35920 : SwigPyBuiltin___gpgme_signature_methods, /* tp_methods */
35921 : 0, /* tp_members */
35922 : SwigPyBuiltin___gpgme_signature_getset, /* tp_getset */
35923 : 0, /* tp_base */
35924 : 0, /* tp_dict */
35925 : (descrgetfunc) 0, /* tp_descr_get */
35926 : (descrsetfunc) 0, /* tp_descr_set */
35927 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
35928 : (initproc) _wrap_new__gpgme_signature, /* tp_init */
35929 : (allocfunc) 0, /* tp_alloc */
35930 : (newfunc) 0, /* tp_new */
35931 : (freefunc) 0, /* tp_free */
35932 : (inquiry) 0, /* tp_is_gc */
35933 : (PyObject*) 0, /* tp_bases */
35934 : (PyObject*) 0, /* tp_mro */
35935 : (PyObject*) 0, /* tp_cache */
35936 : (PyObject*) 0, /* tp_subclasses */
35937 : (PyObject*) 0, /* tp_weaklist */
35938 : (destructor) 0, /* tp_del */
35939 : #if PY_VERSION_HEX >= 0x02060000
35940 : (int) 0, /* tp_version_tag */
35941 : #endif
35942 : },
35943 : {
35944 : (binaryfunc) 0, /* nb_add */
35945 : (binaryfunc) 0, /* nb_subtract */
35946 : (binaryfunc) 0, /* nb_multiply */
35947 : #if PY_VERSION_HEX < 0x03000000
35948 : (binaryfunc) 0, /* nb_divide */
35949 : #endif
35950 : (binaryfunc) 0, /* nb_remainder */
35951 : (binaryfunc) 0, /* nb_divmod */
35952 : (ternaryfunc) 0, /* nb_power */
35953 : (unaryfunc) 0, /* nb_negative */
35954 : (unaryfunc) 0, /* nb_positive */
35955 : (unaryfunc) 0, /* nb_absolute */
35956 : (inquiry) 0, /* nb_nonzero */
35957 : (unaryfunc) 0, /* nb_invert */
35958 : (binaryfunc) 0, /* nb_lshift */
35959 : (binaryfunc) 0, /* nb_rshift */
35960 : (binaryfunc) 0, /* nb_and */
35961 : (binaryfunc) 0, /* nb_xor */
35962 : (binaryfunc) 0, /* nb_or */
35963 : #if PY_VERSION_HEX < 0x03000000
35964 : (coercion) 0, /* nb_coerce */
35965 : #endif
35966 : (unaryfunc) 0, /* nb_int */
35967 : #if PY_VERSION_HEX >= 0x03000000
35968 : (void*) 0, /* nb_reserved */
35969 : #else
35970 : (unaryfunc) 0, /* nb_long */
35971 : #endif
35972 : (unaryfunc) 0, /* nb_float */
35973 : #if PY_VERSION_HEX < 0x03000000
35974 : (unaryfunc) 0, /* nb_oct */
35975 : (unaryfunc) 0, /* nb_hex */
35976 : #endif
35977 : (binaryfunc) 0, /* nb_inplace_add */
35978 : (binaryfunc) 0, /* nb_inplace_subtract */
35979 : (binaryfunc) 0, /* nb_inplace_multiply */
35980 : #if PY_VERSION_HEX < 0x03000000
35981 : (binaryfunc) 0, /* nb_inplace_divide */
35982 : #endif
35983 : (binaryfunc) 0, /* nb_inplace_remainder */
35984 : (ternaryfunc) 0, /* nb_inplace_power */
35985 : (binaryfunc) 0, /* nb_inplace_lshift */
35986 : (binaryfunc) 0, /* nb_inplace_rshift */
35987 : (binaryfunc) 0, /* nb_inplace_and */
35988 : (binaryfunc) 0, /* nb_inplace_xor */
35989 : (binaryfunc) 0, /* nb_inplace_or */
35990 : (binaryfunc) 0, /* nb_floor_divide */
35991 : (binaryfunc) 0, /* nb_true_divide */
35992 : (binaryfunc) 0, /* nb_inplace_floor_divide */
35993 : (binaryfunc) 0, /* nb_inplace_true_divide */
35994 : #if PY_VERSION_HEX >= 0x02050000
35995 : (unaryfunc) 0, /* nb_index */
35996 : #endif
35997 : },
35998 : {
35999 : (lenfunc) 0, /* mp_length */
36000 : (binaryfunc) 0, /* mp_subscript */
36001 : (objobjargproc) 0, /* mp_ass_subscript */
36002 : },
36003 : {
36004 : (lenfunc) 0, /* sq_length */
36005 : (binaryfunc) 0, /* sq_concat */
36006 : (ssizeargfunc) 0, /* sq_repeat */
36007 : (ssizeargfunc) 0, /* sq_item */
36008 : #if PY_VERSION_HEX >= 0x03000000
36009 : (void*) 0, /* was_sq_slice */
36010 : #else
36011 : (ssizessizeargfunc) 0, /* sq_slice */
36012 : #endif
36013 : (ssizeobjargproc) 0, /* sq_ass_item */
36014 : #if PY_VERSION_HEX >= 0x03000000
36015 : (void*) 0, /* was_sq_ass_slice */
36016 : #else
36017 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
36018 : #endif
36019 : (objobjproc) 0, /* sq_contains */
36020 : (binaryfunc) 0, /* sq_inplace_concat */
36021 : (ssizeargfunc) 0, /* sq_inplace_repeat */
36022 : },
36023 : {
36024 : #if PY_VERSION_HEX < 0x03000000
36025 : (readbufferproc) 0, /* bf_getreadbuffer */
36026 : (writebufferproc) 0, /* bf_getwritebuffer */
36027 : (segcountproc) 0, /* bf_getsegcount */
36028 : (charbufferproc) 0, /* bf_getcharbuffer */
36029 : #endif
36030 : #if PY_VERSION_HEX >= 0x02060000
36031 : (getbufferproc) 0, /* bf_getbuffer */
36032 : (releasebufferproc) 0, /* bf_releasebuffer */
36033 : #endif
36034 : },
36035 : (PyObject*) 0, /* ht_name */
36036 : (PyObject*) 0, /* ht_slots */
36037 : };
36038 :
36039 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_signature_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_signature_type};
36040 :
36041 17 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_op_verify_result)
36042 : static SwigPyGetSet _gpgme_op_verify_result_signatures_getset = { _wrap__gpgme_op_verify_result_signatures_get, _wrap__gpgme_op_verify_result_signatures_set };
36043 : static SwigPyGetSet _gpgme_op_verify_result_file_name_getset = { _wrap__gpgme_op_verify_result_file_name_get, _wrap__gpgme_op_verify_result_file_name_set };
36044 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_op_verify_result_getset[] = {
36045 : { (char*) "signatures", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_verify_result.signatures", (void*) &_gpgme_op_verify_result_signatures_getset }
36046 : ,
36047 : { (char*) "file_name", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_verify_result.file_name", (void*) &_gpgme_op_verify_result_file_name_getset }
36048 : ,
36049 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
36050 : };
36051 :
36052 : SWIGINTERN PyObject *
36053 0 : SwigPyBuiltin___gpgme_op_verify_result_richcompare(PyObject *self, PyObject *other, int op) {
36054 0 : PyObject *result = NULL;
36055 0 : PyObject *tuple = PyTuple_New(1);
36056 : assert(tuple);
36057 0 : PyTuple_SET_ITEM(tuple, 0, other);
36058 0 : Py_XINCREF(other);
36059 : if (!result) {
36060 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
36061 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
36062 : } else {
36063 0 : result = Py_NotImplemented;
36064 0 : Py_INCREF(result);
36065 : }
36066 : }
36067 0 : Py_DECREF(tuple);
36068 0 : return result;
36069 : }
36070 :
36071 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_op_verify_result_methods[] = {
36072 : { NULL, NULL, 0, NULL } /* Sentinel */
36073 : };
36074 :
36075 : static PyHeapTypeObject SwigPyBuiltin___gpgme_op_verify_result_type = {
36076 : {
36077 : #if PY_VERSION_HEX >= 0x03000000
36078 : PyVarObject_HEAD_INIT(NULL, 0)
36079 : #else
36080 : PyObject_HEAD_INIT(NULL)
36081 : 0, /* ob_size */
36082 : #endif
36083 : "_gpgme_op_verify_result", /* tp_name */
36084 : sizeof(SwigPyObject), /* tp_basicsize */
36085 : 0, /* tp_itemsize */
36086 : (destructor) _wrap_delete__gpgme_op_verify_result_closure, /* tp_dealloc */
36087 : (printfunc) 0, /* tp_print */
36088 : (getattrfunc) 0, /* tp_getattr */
36089 : (setattrfunc) 0, /* tp_setattr */
36090 : #if PY_VERSION_HEX >= 0x03000000
36091 : 0, /* tp_compare */
36092 : #else
36093 : (cmpfunc) 0, /* tp_compare */
36094 : #endif
36095 : (reprfunc) 0, /* tp_repr */
36096 : &SwigPyBuiltin___gpgme_op_verify_result_type.as_number, /* tp_as_number */
36097 : &SwigPyBuiltin___gpgme_op_verify_result_type.as_sequence, /* tp_as_sequence */
36098 : &SwigPyBuiltin___gpgme_op_verify_result_type.as_mapping, /* tp_as_mapping */
36099 : (hashfunc) 0, /* tp_hash */
36100 : (ternaryfunc) 0, /* tp_call */
36101 : (reprfunc) 0, /* tp_str */
36102 : (getattrofunc) 0, /* tp_getattro */
36103 : (setattrofunc) 0, /* tp_setattro */
36104 : &SwigPyBuiltin___gpgme_op_verify_result_type.as_buffer, /* tp_as_buffer */
36105 : #if PY_VERSION_HEX >= 0x03000000
36106 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
36107 : #else
36108 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
36109 : #endif
36110 : "::_gpgme_op_verify_result", /* tp_doc */
36111 : (traverseproc) 0, /* tp_traverse */
36112 : (inquiry) 0, /* tp_clear */
36113 : (richcmpfunc) SwigPyBuiltin___gpgme_op_verify_result_richcompare, /* feature:python:tp_richcompare */
36114 : 0, /* tp_weaklistoffset */
36115 : (getiterfunc) 0, /* tp_iter */
36116 : (iternextfunc) 0, /* tp_iternext */
36117 : SwigPyBuiltin___gpgme_op_verify_result_methods, /* tp_methods */
36118 : 0, /* tp_members */
36119 : SwigPyBuiltin___gpgme_op_verify_result_getset, /* tp_getset */
36120 : 0, /* tp_base */
36121 : 0, /* tp_dict */
36122 : (descrgetfunc) 0, /* tp_descr_get */
36123 : (descrsetfunc) 0, /* tp_descr_set */
36124 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
36125 : (initproc) _wrap_new__gpgme_op_verify_result, /* tp_init */
36126 : (allocfunc) 0, /* tp_alloc */
36127 : (newfunc) 0, /* tp_new */
36128 : (freefunc) 0, /* tp_free */
36129 : (inquiry) 0, /* tp_is_gc */
36130 : (PyObject*) 0, /* tp_bases */
36131 : (PyObject*) 0, /* tp_mro */
36132 : (PyObject*) 0, /* tp_cache */
36133 : (PyObject*) 0, /* tp_subclasses */
36134 : (PyObject*) 0, /* tp_weaklist */
36135 : (destructor) 0, /* tp_del */
36136 : #if PY_VERSION_HEX >= 0x02060000
36137 : (int) 0, /* tp_version_tag */
36138 : #endif
36139 : },
36140 : {
36141 : (binaryfunc) 0, /* nb_add */
36142 : (binaryfunc) 0, /* nb_subtract */
36143 : (binaryfunc) 0, /* nb_multiply */
36144 : #if PY_VERSION_HEX < 0x03000000
36145 : (binaryfunc) 0, /* nb_divide */
36146 : #endif
36147 : (binaryfunc) 0, /* nb_remainder */
36148 : (binaryfunc) 0, /* nb_divmod */
36149 : (ternaryfunc) 0, /* nb_power */
36150 : (unaryfunc) 0, /* nb_negative */
36151 : (unaryfunc) 0, /* nb_positive */
36152 : (unaryfunc) 0, /* nb_absolute */
36153 : (inquiry) 0, /* nb_nonzero */
36154 : (unaryfunc) 0, /* nb_invert */
36155 : (binaryfunc) 0, /* nb_lshift */
36156 : (binaryfunc) 0, /* nb_rshift */
36157 : (binaryfunc) 0, /* nb_and */
36158 : (binaryfunc) 0, /* nb_xor */
36159 : (binaryfunc) 0, /* nb_or */
36160 : #if PY_VERSION_HEX < 0x03000000
36161 : (coercion) 0, /* nb_coerce */
36162 : #endif
36163 : (unaryfunc) 0, /* nb_int */
36164 : #if PY_VERSION_HEX >= 0x03000000
36165 : (void*) 0, /* nb_reserved */
36166 : #else
36167 : (unaryfunc) 0, /* nb_long */
36168 : #endif
36169 : (unaryfunc) 0, /* nb_float */
36170 : #if PY_VERSION_HEX < 0x03000000
36171 : (unaryfunc) 0, /* nb_oct */
36172 : (unaryfunc) 0, /* nb_hex */
36173 : #endif
36174 : (binaryfunc) 0, /* nb_inplace_add */
36175 : (binaryfunc) 0, /* nb_inplace_subtract */
36176 : (binaryfunc) 0, /* nb_inplace_multiply */
36177 : #if PY_VERSION_HEX < 0x03000000
36178 : (binaryfunc) 0, /* nb_inplace_divide */
36179 : #endif
36180 : (binaryfunc) 0, /* nb_inplace_remainder */
36181 : (ternaryfunc) 0, /* nb_inplace_power */
36182 : (binaryfunc) 0, /* nb_inplace_lshift */
36183 : (binaryfunc) 0, /* nb_inplace_rshift */
36184 : (binaryfunc) 0, /* nb_inplace_and */
36185 : (binaryfunc) 0, /* nb_inplace_xor */
36186 : (binaryfunc) 0, /* nb_inplace_or */
36187 : (binaryfunc) 0, /* nb_floor_divide */
36188 : (binaryfunc) 0, /* nb_true_divide */
36189 : (binaryfunc) 0, /* nb_inplace_floor_divide */
36190 : (binaryfunc) 0, /* nb_inplace_true_divide */
36191 : #if PY_VERSION_HEX >= 0x02050000
36192 : (unaryfunc) 0, /* nb_index */
36193 : #endif
36194 : },
36195 : {
36196 : (lenfunc) 0, /* mp_length */
36197 : (binaryfunc) 0, /* mp_subscript */
36198 : (objobjargproc) 0, /* mp_ass_subscript */
36199 : },
36200 : {
36201 : (lenfunc) 0, /* sq_length */
36202 : (binaryfunc) 0, /* sq_concat */
36203 : (ssizeargfunc) 0, /* sq_repeat */
36204 : (ssizeargfunc) 0, /* sq_item */
36205 : #if PY_VERSION_HEX >= 0x03000000
36206 : (void*) 0, /* was_sq_slice */
36207 : #else
36208 : (ssizessizeargfunc) 0, /* sq_slice */
36209 : #endif
36210 : (ssizeobjargproc) 0, /* sq_ass_item */
36211 : #if PY_VERSION_HEX >= 0x03000000
36212 : (void*) 0, /* was_sq_ass_slice */
36213 : #else
36214 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
36215 : #endif
36216 : (objobjproc) 0, /* sq_contains */
36217 : (binaryfunc) 0, /* sq_inplace_concat */
36218 : (ssizeargfunc) 0, /* sq_inplace_repeat */
36219 : },
36220 : {
36221 : #if PY_VERSION_HEX < 0x03000000
36222 : (readbufferproc) 0, /* bf_getreadbuffer */
36223 : (writebufferproc) 0, /* bf_getwritebuffer */
36224 : (segcountproc) 0, /* bf_getsegcount */
36225 : (charbufferproc) 0, /* bf_getcharbuffer */
36226 : #endif
36227 : #if PY_VERSION_HEX >= 0x02060000
36228 : (getbufferproc) 0, /* bf_getbuffer */
36229 : (releasebufferproc) 0, /* bf_releasebuffer */
36230 : #endif
36231 : },
36232 : (PyObject*) 0, /* ht_name */
36233 : (PyObject*) 0, /* ht_slots */
36234 : };
36235 :
36236 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_op_verify_result_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_op_verify_result_type};
36237 :
36238 6 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_import_status)
36239 : static SwigPyGetSet _gpgme_import_status_result_getset = { _wrap__gpgme_import_status_result_get, _wrap__gpgme_import_status_result_set };
36240 : static SwigPyGetSet _gpgme_import_status_fpr_getset = { _wrap__gpgme_import_status_fpr_get, _wrap__gpgme_import_status_fpr_set };
36241 : static SwigPyGetSet _gpgme_import_status_status_getset = { _wrap__gpgme_import_status_status_get, _wrap__gpgme_import_status_status_set };
36242 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_import_status_getset[] = {
36243 : { (char*) "result", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_import_status.result", (void*) &_gpgme_import_status_result_getset }
36244 : ,
36245 : { (char*) "fpr", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_import_status.fpr", (void*) &_gpgme_import_status_fpr_getset }
36246 : ,
36247 : { (char*) "status", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_import_status.status", (void*) &_gpgme_import_status_status_getset }
36248 : ,
36249 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
36250 : };
36251 :
36252 : SWIGINTERN PyObject *
36253 0 : SwigPyBuiltin___gpgme_import_status_richcompare(PyObject *self, PyObject *other, int op) {
36254 0 : PyObject *result = NULL;
36255 0 : PyObject *tuple = PyTuple_New(1);
36256 : assert(tuple);
36257 0 : PyTuple_SET_ITEM(tuple, 0, other);
36258 0 : Py_XINCREF(other);
36259 : if (!result) {
36260 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
36261 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
36262 : } else {
36263 0 : result = Py_NotImplemented;
36264 0 : Py_INCREF(result);
36265 : }
36266 : }
36267 0 : Py_DECREF(tuple);
36268 0 : return result;
36269 : }
36270 :
36271 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_import_status_methods[] = {
36272 : { NULL, NULL, 0, NULL } /* Sentinel */
36273 : };
36274 :
36275 : static PyHeapTypeObject SwigPyBuiltin___gpgme_import_status_type = {
36276 : {
36277 : #if PY_VERSION_HEX >= 0x03000000
36278 : PyVarObject_HEAD_INIT(NULL, 0)
36279 : #else
36280 : PyObject_HEAD_INIT(NULL)
36281 : 0, /* ob_size */
36282 : #endif
36283 : "_gpgme_import_status", /* tp_name */
36284 : sizeof(SwigPyObject), /* tp_basicsize */
36285 : 0, /* tp_itemsize */
36286 : (destructor) _wrap_delete__gpgme_import_status_closure, /* tp_dealloc */
36287 : (printfunc) 0, /* tp_print */
36288 : (getattrfunc) 0, /* tp_getattr */
36289 : (setattrfunc) 0, /* tp_setattr */
36290 : #if PY_VERSION_HEX >= 0x03000000
36291 : 0, /* tp_compare */
36292 : #else
36293 : (cmpfunc) 0, /* tp_compare */
36294 : #endif
36295 : (reprfunc) 0, /* tp_repr */
36296 : &SwigPyBuiltin___gpgme_import_status_type.as_number, /* tp_as_number */
36297 : &SwigPyBuiltin___gpgme_import_status_type.as_sequence, /* tp_as_sequence */
36298 : &SwigPyBuiltin___gpgme_import_status_type.as_mapping, /* tp_as_mapping */
36299 : (hashfunc) 0, /* tp_hash */
36300 : (ternaryfunc) 0, /* tp_call */
36301 : (reprfunc) 0, /* tp_str */
36302 : (getattrofunc) 0, /* tp_getattro */
36303 : (setattrofunc) 0, /* tp_setattro */
36304 : &SwigPyBuiltin___gpgme_import_status_type.as_buffer, /* tp_as_buffer */
36305 : #if PY_VERSION_HEX >= 0x03000000
36306 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
36307 : #else
36308 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
36309 : #endif
36310 : "::_gpgme_import_status", /* tp_doc */
36311 : (traverseproc) 0, /* tp_traverse */
36312 : (inquiry) 0, /* tp_clear */
36313 : (richcmpfunc) SwigPyBuiltin___gpgme_import_status_richcompare, /* feature:python:tp_richcompare */
36314 : 0, /* tp_weaklistoffset */
36315 : (getiterfunc) 0, /* tp_iter */
36316 : (iternextfunc) 0, /* tp_iternext */
36317 : SwigPyBuiltin___gpgme_import_status_methods, /* tp_methods */
36318 : 0, /* tp_members */
36319 : SwigPyBuiltin___gpgme_import_status_getset, /* tp_getset */
36320 : 0, /* tp_base */
36321 : 0, /* tp_dict */
36322 : (descrgetfunc) 0, /* tp_descr_get */
36323 : (descrsetfunc) 0, /* tp_descr_set */
36324 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
36325 : (initproc) _wrap_new__gpgme_import_status, /* tp_init */
36326 : (allocfunc) 0, /* tp_alloc */
36327 : (newfunc) 0, /* tp_new */
36328 : (freefunc) 0, /* tp_free */
36329 : (inquiry) 0, /* tp_is_gc */
36330 : (PyObject*) 0, /* tp_bases */
36331 : (PyObject*) 0, /* tp_mro */
36332 : (PyObject*) 0, /* tp_cache */
36333 : (PyObject*) 0, /* tp_subclasses */
36334 : (PyObject*) 0, /* tp_weaklist */
36335 : (destructor) 0, /* tp_del */
36336 : #if PY_VERSION_HEX >= 0x02060000
36337 : (int) 0, /* tp_version_tag */
36338 : #endif
36339 : },
36340 : {
36341 : (binaryfunc) 0, /* nb_add */
36342 : (binaryfunc) 0, /* nb_subtract */
36343 : (binaryfunc) 0, /* nb_multiply */
36344 : #if PY_VERSION_HEX < 0x03000000
36345 : (binaryfunc) 0, /* nb_divide */
36346 : #endif
36347 : (binaryfunc) 0, /* nb_remainder */
36348 : (binaryfunc) 0, /* nb_divmod */
36349 : (ternaryfunc) 0, /* nb_power */
36350 : (unaryfunc) 0, /* nb_negative */
36351 : (unaryfunc) 0, /* nb_positive */
36352 : (unaryfunc) 0, /* nb_absolute */
36353 : (inquiry) 0, /* nb_nonzero */
36354 : (unaryfunc) 0, /* nb_invert */
36355 : (binaryfunc) 0, /* nb_lshift */
36356 : (binaryfunc) 0, /* nb_rshift */
36357 : (binaryfunc) 0, /* nb_and */
36358 : (binaryfunc) 0, /* nb_xor */
36359 : (binaryfunc) 0, /* nb_or */
36360 : #if PY_VERSION_HEX < 0x03000000
36361 : (coercion) 0, /* nb_coerce */
36362 : #endif
36363 : (unaryfunc) 0, /* nb_int */
36364 : #if PY_VERSION_HEX >= 0x03000000
36365 : (void*) 0, /* nb_reserved */
36366 : #else
36367 : (unaryfunc) 0, /* nb_long */
36368 : #endif
36369 : (unaryfunc) 0, /* nb_float */
36370 : #if PY_VERSION_HEX < 0x03000000
36371 : (unaryfunc) 0, /* nb_oct */
36372 : (unaryfunc) 0, /* nb_hex */
36373 : #endif
36374 : (binaryfunc) 0, /* nb_inplace_add */
36375 : (binaryfunc) 0, /* nb_inplace_subtract */
36376 : (binaryfunc) 0, /* nb_inplace_multiply */
36377 : #if PY_VERSION_HEX < 0x03000000
36378 : (binaryfunc) 0, /* nb_inplace_divide */
36379 : #endif
36380 : (binaryfunc) 0, /* nb_inplace_remainder */
36381 : (ternaryfunc) 0, /* nb_inplace_power */
36382 : (binaryfunc) 0, /* nb_inplace_lshift */
36383 : (binaryfunc) 0, /* nb_inplace_rshift */
36384 : (binaryfunc) 0, /* nb_inplace_and */
36385 : (binaryfunc) 0, /* nb_inplace_xor */
36386 : (binaryfunc) 0, /* nb_inplace_or */
36387 : (binaryfunc) 0, /* nb_floor_divide */
36388 : (binaryfunc) 0, /* nb_true_divide */
36389 : (binaryfunc) 0, /* nb_inplace_floor_divide */
36390 : (binaryfunc) 0, /* nb_inplace_true_divide */
36391 : #if PY_VERSION_HEX >= 0x02050000
36392 : (unaryfunc) 0, /* nb_index */
36393 : #endif
36394 : },
36395 : {
36396 : (lenfunc) 0, /* mp_length */
36397 : (binaryfunc) 0, /* mp_subscript */
36398 : (objobjargproc) 0, /* mp_ass_subscript */
36399 : },
36400 : {
36401 : (lenfunc) 0, /* sq_length */
36402 : (binaryfunc) 0, /* sq_concat */
36403 : (ssizeargfunc) 0, /* sq_repeat */
36404 : (ssizeargfunc) 0, /* sq_item */
36405 : #if PY_VERSION_HEX >= 0x03000000
36406 : (void*) 0, /* was_sq_slice */
36407 : #else
36408 : (ssizessizeargfunc) 0, /* sq_slice */
36409 : #endif
36410 : (ssizeobjargproc) 0, /* sq_ass_item */
36411 : #if PY_VERSION_HEX >= 0x03000000
36412 : (void*) 0, /* was_sq_ass_slice */
36413 : #else
36414 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
36415 : #endif
36416 : (objobjproc) 0, /* sq_contains */
36417 : (binaryfunc) 0, /* sq_inplace_concat */
36418 : (ssizeargfunc) 0, /* sq_inplace_repeat */
36419 : },
36420 : {
36421 : #if PY_VERSION_HEX < 0x03000000
36422 : (readbufferproc) 0, /* bf_getreadbuffer */
36423 : (writebufferproc) 0, /* bf_getwritebuffer */
36424 : (segcountproc) 0, /* bf_getsegcount */
36425 : (charbufferproc) 0, /* bf_getcharbuffer */
36426 : #endif
36427 : #if PY_VERSION_HEX >= 0x02060000
36428 : (getbufferproc) 0, /* bf_getbuffer */
36429 : (releasebufferproc) 0, /* bf_releasebuffer */
36430 : #endif
36431 : },
36432 : (PyObject*) 0, /* ht_name */
36433 : (PyObject*) 0, /* ht_slots */
36434 : };
36435 :
36436 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_import_status_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_import_status_type};
36437 :
36438 2 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_op_import_result)
36439 : static SwigPyGetSet _gpgme_op_import_result_imported_getset = { _wrap__gpgme_op_import_result_imported_get, _wrap__gpgme_op_import_result_imported_set };
36440 : static SwigPyGetSet _gpgme_op_import_result_secret_imported_getset = { _wrap__gpgme_op_import_result_secret_imported_get, _wrap__gpgme_op_import_result_secret_imported_set };
36441 : static SwigPyGetSet _gpgme_op_import_result_not_imported_getset = { _wrap__gpgme_op_import_result_not_imported_get, _wrap__gpgme_op_import_result_not_imported_set };
36442 : static SwigPyGetSet _gpgme_op_import_result_skipped_new_keys_getset = { _wrap__gpgme_op_import_result_skipped_new_keys_get, _wrap__gpgme_op_import_result_skipped_new_keys_set };
36443 : static SwigPyGetSet _gpgme_op_import_result_secret_read_getset = { _wrap__gpgme_op_import_result_secret_read_get, _wrap__gpgme_op_import_result_secret_read_set };
36444 : static SwigPyGetSet _gpgme_op_import_result_considered_getset = { _wrap__gpgme_op_import_result_considered_get, _wrap__gpgme_op_import_result_considered_set };
36445 : static SwigPyGetSet _gpgme_op_import_result_no_user_id_getset = { _wrap__gpgme_op_import_result_no_user_id_get, _wrap__gpgme_op_import_result_no_user_id_set };
36446 : static SwigPyGetSet _gpgme_op_import_result_new_sub_keys_getset = { _wrap__gpgme_op_import_result_new_sub_keys_get, _wrap__gpgme_op_import_result_new_sub_keys_set };
36447 : static SwigPyGetSet _gpgme_op_import_result_imports_getset = { _wrap__gpgme_op_import_result_imports_get, _wrap__gpgme_op_import_result_imports_set };
36448 : static SwigPyGetSet _gpgme_op_import_result_unchanged_getset = { _wrap__gpgme_op_import_result_unchanged_get, _wrap__gpgme_op_import_result_unchanged_set };
36449 : static SwigPyGetSet _gpgme_op_import_result_new_signatures_getset = { _wrap__gpgme_op_import_result_new_signatures_get, _wrap__gpgme_op_import_result_new_signatures_set };
36450 : static SwigPyGetSet _gpgme_op_import_result_secret_unchanged_getset = { _wrap__gpgme_op_import_result_secret_unchanged_get, _wrap__gpgme_op_import_result_secret_unchanged_set };
36451 : static SwigPyGetSet _gpgme_op_import_result_imported_rsa_getset = { _wrap__gpgme_op_import_result_imported_rsa_get, _wrap__gpgme_op_import_result_imported_rsa_set };
36452 : static SwigPyGetSet _gpgme_op_import_result_new_revocations_getset = { _wrap__gpgme_op_import_result_new_revocations_get, _wrap__gpgme_op_import_result_new_revocations_set };
36453 : static SwigPyGetSet _gpgme_op_import_result_new_user_ids_getset = { _wrap__gpgme_op_import_result_new_user_ids_get, _wrap__gpgme_op_import_result_new_user_ids_set };
36454 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_op_import_result_getset[] = {
36455 : { (char*) "imported", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.imported", (void*) &_gpgme_op_import_result_imported_getset }
36456 : ,
36457 : { (char*) "secret_imported", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.secret_imported", (void*) &_gpgme_op_import_result_secret_imported_getset }
36458 : ,
36459 : { (char*) "not_imported", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.not_imported", (void*) &_gpgme_op_import_result_not_imported_getset }
36460 : ,
36461 : { (char*) "skipped_new_keys", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.skipped_new_keys", (void*) &_gpgme_op_import_result_skipped_new_keys_getset }
36462 : ,
36463 : { (char*) "secret_read", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.secret_read", (void*) &_gpgme_op_import_result_secret_read_getset }
36464 : ,
36465 : { (char*) "considered", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.considered", (void*) &_gpgme_op_import_result_considered_getset }
36466 : ,
36467 : { (char*) "no_user_id", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.no_user_id", (void*) &_gpgme_op_import_result_no_user_id_getset }
36468 : ,
36469 : { (char*) "new_sub_keys", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.new_sub_keys", (void*) &_gpgme_op_import_result_new_sub_keys_getset }
36470 : ,
36471 : { (char*) "imports", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.imports", (void*) &_gpgme_op_import_result_imports_getset }
36472 : ,
36473 : { (char*) "unchanged", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.unchanged", (void*) &_gpgme_op_import_result_unchanged_getset }
36474 : ,
36475 : { (char*) "new_signatures", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.new_signatures", (void*) &_gpgme_op_import_result_new_signatures_getset }
36476 : ,
36477 : { (char*) "secret_unchanged", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.secret_unchanged", (void*) &_gpgme_op_import_result_secret_unchanged_getset }
36478 : ,
36479 : { (char*) "imported_rsa", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.imported_rsa", (void*) &_gpgme_op_import_result_imported_rsa_getset }
36480 : ,
36481 : { (char*) "new_revocations", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.new_revocations", (void*) &_gpgme_op_import_result_new_revocations_getset }
36482 : ,
36483 : { (char*) "new_user_ids", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_import_result.new_user_ids", (void*) &_gpgme_op_import_result_new_user_ids_getset }
36484 : ,
36485 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
36486 : };
36487 :
36488 : SWIGINTERN PyObject *
36489 0 : SwigPyBuiltin___gpgme_op_import_result_richcompare(PyObject *self, PyObject *other, int op) {
36490 0 : PyObject *result = NULL;
36491 0 : PyObject *tuple = PyTuple_New(1);
36492 : assert(tuple);
36493 0 : PyTuple_SET_ITEM(tuple, 0, other);
36494 0 : Py_XINCREF(other);
36495 : if (!result) {
36496 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
36497 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
36498 : } else {
36499 0 : result = Py_NotImplemented;
36500 0 : Py_INCREF(result);
36501 : }
36502 : }
36503 0 : Py_DECREF(tuple);
36504 0 : return result;
36505 : }
36506 :
36507 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_op_import_result_methods[] = {
36508 : { NULL, NULL, 0, NULL } /* Sentinel */
36509 : };
36510 :
36511 : static PyHeapTypeObject SwigPyBuiltin___gpgme_op_import_result_type = {
36512 : {
36513 : #if PY_VERSION_HEX >= 0x03000000
36514 : PyVarObject_HEAD_INIT(NULL, 0)
36515 : #else
36516 : PyObject_HEAD_INIT(NULL)
36517 : 0, /* ob_size */
36518 : #endif
36519 : "_gpgme_op_import_result", /* tp_name */
36520 : sizeof(SwigPyObject), /* tp_basicsize */
36521 : 0, /* tp_itemsize */
36522 : (destructor) _wrap_delete__gpgme_op_import_result_closure, /* tp_dealloc */
36523 : (printfunc) 0, /* tp_print */
36524 : (getattrfunc) 0, /* tp_getattr */
36525 : (setattrfunc) 0, /* tp_setattr */
36526 : #if PY_VERSION_HEX >= 0x03000000
36527 : 0, /* tp_compare */
36528 : #else
36529 : (cmpfunc) 0, /* tp_compare */
36530 : #endif
36531 : (reprfunc) 0, /* tp_repr */
36532 : &SwigPyBuiltin___gpgme_op_import_result_type.as_number, /* tp_as_number */
36533 : &SwigPyBuiltin___gpgme_op_import_result_type.as_sequence, /* tp_as_sequence */
36534 : &SwigPyBuiltin___gpgme_op_import_result_type.as_mapping, /* tp_as_mapping */
36535 : (hashfunc) 0, /* tp_hash */
36536 : (ternaryfunc) 0, /* tp_call */
36537 : (reprfunc) 0, /* tp_str */
36538 : (getattrofunc) 0, /* tp_getattro */
36539 : (setattrofunc) 0, /* tp_setattro */
36540 : &SwigPyBuiltin___gpgme_op_import_result_type.as_buffer, /* tp_as_buffer */
36541 : #if PY_VERSION_HEX >= 0x03000000
36542 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
36543 : #else
36544 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
36545 : #endif
36546 : "::_gpgme_op_import_result", /* tp_doc */
36547 : (traverseproc) 0, /* tp_traverse */
36548 : (inquiry) 0, /* tp_clear */
36549 : (richcmpfunc) SwigPyBuiltin___gpgme_op_import_result_richcompare, /* feature:python:tp_richcompare */
36550 : 0, /* tp_weaklistoffset */
36551 : (getiterfunc) 0, /* tp_iter */
36552 : (iternextfunc) 0, /* tp_iternext */
36553 : SwigPyBuiltin___gpgme_op_import_result_methods, /* tp_methods */
36554 : 0, /* tp_members */
36555 : SwigPyBuiltin___gpgme_op_import_result_getset, /* tp_getset */
36556 : 0, /* tp_base */
36557 : 0, /* tp_dict */
36558 : (descrgetfunc) 0, /* tp_descr_get */
36559 : (descrsetfunc) 0, /* tp_descr_set */
36560 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
36561 : (initproc) _wrap_new__gpgme_op_import_result, /* tp_init */
36562 : (allocfunc) 0, /* tp_alloc */
36563 : (newfunc) 0, /* tp_new */
36564 : (freefunc) 0, /* tp_free */
36565 : (inquiry) 0, /* tp_is_gc */
36566 : (PyObject*) 0, /* tp_bases */
36567 : (PyObject*) 0, /* tp_mro */
36568 : (PyObject*) 0, /* tp_cache */
36569 : (PyObject*) 0, /* tp_subclasses */
36570 : (PyObject*) 0, /* tp_weaklist */
36571 : (destructor) 0, /* tp_del */
36572 : #if PY_VERSION_HEX >= 0x02060000
36573 : (int) 0, /* tp_version_tag */
36574 : #endif
36575 : },
36576 : {
36577 : (binaryfunc) 0, /* nb_add */
36578 : (binaryfunc) 0, /* nb_subtract */
36579 : (binaryfunc) 0, /* nb_multiply */
36580 : #if PY_VERSION_HEX < 0x03000000
36581 : (binaryfunc) 0, /* nb_divide */
36582 : #endif
36583 : (binaryfunc) 0, /* nb_remainder */
36584 : (binaryfunc) 0, /* nb_divmod */
36585 : (ternaryfunc) 0, /* nb_power */
36586 : (unaryfunc) 0, /* nb_negative */
36587 : (unaryfunc) 0, /* nb_positive */
36588 : (unaryfunc) 0, /* nb_absolute */
36589 : (inquiry) 0, /* nb_nonzero */
36590 : (unaryfunc) 0, /* nb_invert */
36591 : (binaryfunc) 0, /* nb_lshift */
36592 : (binaryfunc) 0, /* nb_rshift */
36593 : (binaryfunc) 0, /* nb_and */
36594 : (binaryfunc) 0, /* nb_xor */
36595 : (binaryfunc) 0, /* nb_or */
36596 : #if PY_VERSION_HEX < 0x03000000
36597 : (coercion) 0, /* nb_coerce */
36598 : #endif
36599 : (unaryfunc) 0, /* nb_int */
36600 : #if PY_VERSION_HEX >= 0x03000000
36601 : (void*) 0, /* nb_reserved */
36602 : #else
36603 : (unaryfunc) 0, /* nb_long */
36604 : #endif
36605 : (unaryfunc) 0, /* nb_float */
36606 : #if PY_VERSION_HEX < 0x03000000
36607 : (unaryfunc) 0, /* nb_oct */
36608 : (unaryfunc) 0, /* nb_hex */
36609 : #endif
36610 : (binaryfunc) 0, /* nb_inplace_add */
36611 : (binaryfunc) 0, /* nb_inplace_subtract */
36612 : (binaryfunc) 0, /* nb_inplace_multiply */
36613 : #if PY_VERSION_HEX < 0x03000000
36614 : (binaryfunc) 0, /* nb_inplace_divide */
36615 : #endif
36616 : (binaryfunc) 0, /* nb_inplace_remainder */
36617 : (ternaryfunc) 0, /* nb_inplace_power */
36618 : (binaryfunc) 0, /* nb_inplace_lshift */
36619 : (binaryfunc) 0, /* nb_inplace_rshift */
36620 : (binaryfunc) 0, /* nb_inplace_and */
36621 : (binaryfunc) 0, /* nb_inplace_xor */
36622 : (binaryfunc) 0, /* nb_inplace_or */
36623 : (binaryfunc) 0, /* nb_floor_divide */
36624 : (binaryfunc) 0, /* nb_true_divide */
36625 : (binaryfunc) 0, /* nb_inplace_floor_divide */
36626 : (binaryfunc) 0, /* nb_inplace_true_divide */
36627 : #if PY_VERSION_HEX >= 0x02050000
36628 : (unaryfunc) 0, /* nb_index */
36629 : #endif
36630 : },
36631 : {
36632 : (lenfunc) 0, /* mp_length */
36633 : (binaryfunc) 0, /* mp_subscript */
36634 : (objobjargproc) 0, /* mp_ass_subscript */
36635 : },
36636 : {
36637 : (lenfunc) 0, /* sq_length */
36638 : (binaryfunc) 0, /* sq_concat */
36639 : (ssizeargfunc) 0, /* sq_repeat */
36640 : (ssizeargfunc) 0, /* sq_item */
36641 : #if PY_VERSION_HEX >= 0x03000000
36642 : (void*) 0, /* was_sq_slice */
36643 : #else
36644 : (ssizessizeargfunc) 0, /* sq_slice */
36645 : #endif
36646 : (ssizeobjargproc) 0, /* sq_ass_item */
36647 : #if PY_VERSION_HEX >= 0x03000000
36648 : (void*) 0, /* was_sq_ass_slice */
36649 : #else
36650 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
36651 : #endif
36652 : (objobjproc) 0, /* sq_contains */
36653 : (binaryfunc) 0, /* sq_inplace_concat */
36654 : (ssizeargfunc) 0, /* sq_inplace_repeat */
36655 : },
36656 : {
36657 : #if PY_VERSION_HEX < 0x03000000
36658 : (readbufferproc) 0, /* bf_getreadbuffer */
36659 : (writebufferproc) 0, /* bf_getwritebuffer */
36660 : (segcountproc) 0, /* bf_getsegcount */
36661 : (charbufferproc) 0, /* bf_getcharbuffer */
36662 : #endif
36663 : #if PY_VERSION_HEX >= 0x02060000
36664 : (getbufferproc) 0, /* bf_getbuffer */
36665 : (releasebufferproc) 0, /* bf_releasebuffer */
36666 : #endif
36667 : },
36668 : (PyObject*) 0, /* ht_name */
36669 : (PyObject*) 0, /* ht_slots */
36670 : };
36671 :
36672 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_op_import_result_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_op_import_result_type};
36673 :
36674 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_op_genkey_result)
36675 : static SwigPyGetSet _gpgme_op_genkey_result__unused_getset = { _wrap__gpgme_op_genkey_result__unused_get, _wrap__gpgme_op_genkey_result__unused_set };
36676 : static SwigPyGetSet _gpgme_op_genkey_result_sub_getset = { _wrap__gpgme_op_genkey_result_sub_get, _wrap__gpgme_op_genkey_result_sub_set };
36677 : static SwigPyGetSet _gpgme_op_genkey_result_fpr_getset = { _wrap__gpgme_op_genkey_result_fpr_get, _wrap__gpgme_op_genkey_result_fpr_set };
36678 : static SwigPyGetSet _gpgme_op_genkey_result_primary_getset = { _wrap__gpgme_op_genkey_result_primary_get, _wrap__gpgme_op_genkey_result_primary_set };
36679 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_op_genkey_result_getset[] = {
36680 : { (char*) "_unused", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_genkey_result._unused", (void*) &_gpgme_op_genkey_result__unused_getset }
36681 : ,
36682 : { (char*) "sub", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_genkey_result.sub", (void*) &_gpgme_op_genkey_result_sub_getset }
36683 : ,
36684 : { (char*) "fpr", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_genkey_result.fpr", (void*) &_gpgme_op_genkey_result_fpr_getset }
36685 : ,
36686 : { (char*) "primary", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_genkey_result.primary", (void*) &_gpgme_op_genkey_result_primary_getset }
36687 : ,
36688 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
36689 : };
36690 :
36691 : SWIGINTERN PyObject *
36692 0 : SwigPyBuiltin___gpgme_op_genkey_result_richcompare(PyObject *self, PyObject *other, int op) {
36693 0 : PyObject *result = NULL;
36694 0 : PyObject *tuple = PyTuple_New(1);
36695 : assert(tuple);
36696 0 : PyTuple_SET_ITEM(tuple, 0, other);
36697 0 : Py_XINCREF(other);
36698 : if (!result) {
36699 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
36700 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
36701 : } else {
36702 0 : result = Py_NotImplemented;
36703 0 : Py_INCREF(result);
36704 : }
36705 : }
36706 0 : Py_DECREF(tuple);
36707 0 : return result;
36708 : }
36709 :
36710 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_op_genkey_result_methods[] = {
36711 : { NULL, NULL, 0, NULL } /* Sentinel */
36712 : };
36713 :
36714 : static PyHeapTypeObject SwigPyBuiltin___gpgme_op_genkey_result_type = {
36715 : {
36716 : #if PY_VERSION_HEX >= 0x03000000
36717 : PyVarObject_HEAD_INIT(NULL, 0)
36718 : #else
36719 : PyObject_HEAD_INIT(NULL)
36720 : 0, /* ob_size */
36721 : #endif
36722 : "_gpgme_op_genkey_result", /* tp_name */
36723 : sizeof(SwigPyObject), /* tp_basicsize */
36724 : 0, /* tp_itemsize */
36725 : (destructor) _wrap_delete__gpgme_op_genkey_result_closure, /* tp_dealloc */
36726 : (printfunc) 0, /* tp_print */
36727 : (getattrfunc) 0, /* tp_getattr */
36728 : (setattrfunc) 0, /* tp_setattr */
36729 : #if PY_VERSION_HEX >= 0x03000000
36730 : 0, /* tp_compare */
36731 : #else
36732 : (cmpfunc) 0, /* tp_compare */
36733 : #endif
36734 : (reprfunc) 0, /* tp_repr */
36735 : &SwigPyBuiltin___gpgme_op_genkey_result_type.as_number, /* tp_as_number */
36736 : &SwigPyBuiltin___gpgme_op_genkey_result_type.as_sequence, /* tp_as_sequence */
36737 : &SwigPyBuiltin___gpgme_op_genkey_result_type.as_mapping, /* tp_as_mapping */
36738 : (hashfunc) 0, /* tp_hash */
36739 : (ternaryfunc) 0, /* tp_call */
36740 : (reprfunc) 0, /* tp_str */
36741 : (getattrofunc) 0, /* tp_getattro */
36742 : (setattrofunc) 0, /* tp_setattro */
36743 : &SwigPyBuiltin___gpgme_op_genkey_result_type.as_buffer, /* tp_as_buffer */
36744 : #if PY_VERSION_HEX >= 0x03000000
36745 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
36746 : #else
36747 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
36748 : #endif
36749 : "::_gpgme_op_genkey_result", /* tp_doc */
36750 : (traverseproc) 0, /* tp_traverse */
36751 : (inquiry) 0, /* tp_clear */
36752 : (richcmpfunc) SwigPyBuiltin___gpgme_op_genkey_result_richcompare, /* feature:python:tp_richcompare */
36753 : 0, /* tp_weaklistoffset */
36754 : (getiterfunc) 0, /* tp_iter */
36755 : (iternextfunc) 0, /* tp_iternext */
36756 : SwigPyBuiltin___gpgme_op_genkey_result_methods, /* tp_methods */
36757 : 0, /* tp_members */
36758 : SwigPyBuiltin___gpgme_op_genkey_result_getset, /* tp_getset */
36759 : 0, /* tp_base */
36760 : 0, /* tp_dict */
36761 : (descrgetfunc) 0, /* tp_descr_get */
36762 : (descrsetfunc) 0, /* tp_descr_set */
36763 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
36764 : (initproc) _wrap_new__gpgme_op_genkey_result, /* tp_init */
36765 : (allocfunc) 0, /* tp_alloc */
36766 : (newfunc) 0, /* tp_new */
36767 : (freefunc) 0, /* tp_free */
36768 : (inquiry) 0, /* tp_is_gc */
36769 : (PyObject*) 0, /* tp_bases */
36770 : (PyObject*) 0, /* tp_mro */
36771 : (PyObject*) 0, /* tp_cache */
36772 : (PyObject*) 0, /* tp_subclasses */
36773 : (PyObject*) 0, /* tp_weaklist */
36774 : (destructor) 0, /* tp_del */
36775 : #if PY_VERSION_HEX >= 0x02060000
36776 : (int) 0, /* tp_version_tag */
36777 : #endif
36778 : },
36779 : {
36780 : (binaryfunc) 0, /* nb_add */
36781 : (binaryfunc) 0, /* nb_subtract */
36782 : (binaryfunc) 0, /* nb_multiply */
36783 : #if PY_VERSION_HEX < 0x03000000
36784 : (binaryfunc) 0, /* nb_divide */
36785 : #endif
36786 : (binaryfunc) 0, /* nb_remainder */
36787 : (binaryfunc) 0, /* nb_divmod */
36788 : (ternaryfunc) 0, /* nb_power */
36789 : (unaryfunc) 0, /* nb_negative */
36790 : (unaryfunc) 0, /* nb_positive */
36791 : (unaryfunc) 0, /* nb_absolute */
36792 : (inquiry) 0, /* nb_nonzero */
36793 : (unaryfunc) 0, /* nb_invert */
36794 : (binaryfunc) 0, /* nb_lshift */
36795 : (binaryfunc) 0, /* nb_rshift */
36796 : (binaryfunc) 0, /* nb_and */
36797 : (binaryfunc) 0, /* nb_xor */
36798 : (binaryfunc) 0, /* nb_or */
36799 : #if PY_VERSION_HEX < 0x03000000
36800 : (coercion) 0, /* nb_coerce */
36801 : #endif
36802 : (unaryfunc) 0, /* nb_int */
36803 : #if PY_VERSION_HEX >= 0x03000000
36804 : (void*) 0, /* nb_reserved */
36805 : #else
36806 : (unaryfunc) 0, /* nb_long */
36807 : #endif
36808 : (unaryfunc) 0, /* nb_float */
36809 : #if PY_VERSION_HEX < 0x03000000
36810 : (unaryfunc) 0, /* nb_oct */
36811 : (unaryfunc) 0, /* nb_hex */
36812 : #endif
36813 : (binaryfunc) 0, /* nb_inplace_add */
36814 : (binaryfunc) 0, /* nb_inplace_subtract */
36815 : (binaryfunc) 0, /* nb_inplace_multiply */
36816 : #if PY_VERSION_HEX < 0x03000000
36817 : (binaryfunc) 0, /* nb_inplace_divide */
36818 : #endif
36819 : (binaryfunc) 0, /* nb_inplace_remainder */
36820 : (ternaryfunc) 0, /* nb_inplace_power */
36821 : (binaryfunc) 0, /* nb_inplace_lshift */
36822 : (binaryfunc) 0, /* nb_inplace_rshift */
36823 : (binaryfunc) 0, /* nb_inplace_and */
36824 : (binaryfunc) 0, /* nb_inplace_xor */
36825 : (binaryfunc) 0, /* nb_inplace_or */
36826 : (binaryfunc) 0, /* nb_floor_divide */
36827 : (binaryfunc) 0, /* nb_true_divide */
36828 : (binaryfunc) 0, /* nb_inplace_floor_divide */
36829 : (binaryfunc) 0, /* nb_inplace_true_divide */
36830 : #if PY_VERSION_HEX >= 0x02050000
36831 : (unaryfunc) 0, /* nb_index */
36832 : #endif
36833 : },
36834 : {
36835 : (lenfunc) 0, /* mp_length */
36836 : (binaryfunc) 0, /* mp_subscript */
36837 : (objobjargproc) 0, /* mp_ass_subscript */
36838 : },
36839 : {
36840 : (lenfunc) 0, /* sq_length */
36841 : (binaryfunc) 0, /* sq_concat */
36842 : (ssizeargfunc) 0, /* sq_repeat */
36843 : (ssizeargfunc) 0, /* sq_item */
36844 : #if PY_VERSION_HEX >= 0x03000000
36845 : (void*) 0, /* was_sq_slice */
36846 : #else
36847 : (ssizessizeargfunc) 0, /* sq_slice */
36848 : #endif
36849 : (ssizeobjargproc) 0, /* sq_ass_item */
36850 : #if PY_VERSION_HEX >= 0x03000000
36851 : (void*) 0, /* was_sq_ass_slice */
36852 : #else
36853 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
36854 : #endif
36855 : (objobjproc) 0, /* sq_contains */
36856 : (binaryfunc) 0, /* sq_inplace_concat */
36857 : (ssizeargfunc) 0, /* sq_inplace_repeat */
36858 : },
36859 : {
36860 : #if PY_VERSION_HEX < 0x03000000
36861 : (readbufferproc) 0, /* bf_getreadbuffer */
36862 : (writebufferproc) 0, /* bf_getwritebuffer */
36863 : (segcountproc) 0, /* bf_getsegcount */
36864 : (charbufferproc) 0, /* bf_getcharbuffer */
36865 : #endif
36866 : #if PY_VERSION_HEX >= 0x02060000
36867 : (getbufferproc) 0, /* bf_getbuffer */
36868 : (releasebufferproc) 0, /* bf_releasebuffer */
36869 : #endif
36870 : },
36871 : (PyObject*) 0, /* ht_name */
36872 : (PyObject*) 0, /* ht_slots */
36873 : };
36874 :
36875 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_op_genkey_result_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_op_genkey_result_type};
36876 :
36877 1 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_op_keylist_result)
36878 : static SwigPyGetSet _gpgme_op_keylist_result__unused_getset = { _wrap__gpgme_op_keylist_result__unused_get, _wrap__gpgme_op_keylist_result__unused_set };
36879 : static SwigPyGetSet _gpgme_op_keylist_result_truncated_getset = { _wrap__gpgme_op_keylist_result_truncated_get, _wrap__gpgme_op_keylist_result_truncated_set };
36880 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_op_keylist_result_getset[] = {
36881 : { (char*) "_unused", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_keylist_result._unused", (void*) &_gpgme_op_keylist_result__unused_getset }
36882 : ,
36883 : { (char*) "truncated", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_keylist_result.truncated", (void*) &_gpgme_op_keylist_result_truncated_getset }
36884 : ,
36885 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
36886 : };
36887 :
36888 : SWIGINTERN PyObject *
36889 0 : SwigPyBuiltin___gpgme_op_keylist_result_richcompare(PyObject *self, PyObject *other, int op) {
36890 0 : PyObject *result = NULL;
36891 0 : PyObject *tuple = PyTuple_New(1);
36892 : assert(tuple);
36893 0 : PyTuple_SET_ITEM(tuple, 0, other);
36894 0 : Py_XINCREF(other);
36895 : if (!result) {
36896 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
36897 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
36898 : } else {
36899 0 : result = Py_NotImplemented;
36900 0 : Py_INCREF(result);
36901 : }
36902 : }
36903 0 : Py_DECREF(tuple);
36904 0 : return result;
36905 : }
36906 :
36907 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_op_keylist_result_methods[] = {
36908 : { NULL, NULL, 0, NULL } /* Sentinel */
36909 : };
36910 :
36911 : static PyHeapTypeObject SwigPyBuiltin___gpgme_op_keylist_result_type = {
36912 : {
36913 : #if PY_VERSION_HEX >= 0x03000000
36914 : PyVarObject_HEAD_INIT(NULL, 0)
36915 : #else
36916 : PyObject_HEAD_INIT(NULL)
36917 : 0, /* ob_size */
36918 : #endif
36919 : "_gpgme_op_keylist_result", /* tp_name */
36920 : sizeof(SwigPyObject), /* tp_basicsize */
36921 : 0, /* tp_itemsize */
36922 : (destructor) _wrap_delete__gpgme_op_keylist_result_closure, /* tp_dealloc */
36923 : (printfunc) 0, /* tp_print */
36924 : (getattrfunc) 0, /* tp_getattr */
36925 : (setattrfunc) 0, /* tp_setattr */
36926 : #if PY_VERSION_HEX >= 0x03000000
36927 : 0, /* tp_compare */
36928 : #else
36929 : (cmpfunc) 0, /* tp_compare */
36930 : #endif
36931 : (reprfunc) 0, /* tp_repr */
36932 : &SwigPyBuiltin___gpgme_op_keylist_result_type.as_number, /* tp_as_number */
36933 : &SwigPyBuiltin___gpgme_op_keylist_result_type.as_sequence, /* tp_as_sequence */
36934 : &SwigPyBuiltin___gpgme_op_keylist_result_type.as_mapping, /* tp_as_mapping */
36935 : (hashfunc) 0, /* tp_hash */
36936 : (ternaryfunc) 0, /* tp_call */
36937 : (reprfunc) 0, /* tp_str */
36938 : (getattrofunc) 0, /* tp_getattro */
36939 : (setattrofunc) 0, /* tp_setattro */
36940 : &SwigPyBuiltin___gpgme_op_keylist_result_type.as_buffer, /* tp_as_buffer */
36941 : #if PY_VERSION_HEX >= 0x03000000
36942 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
36943 : #else
36944 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
36945 : #endif
36946 : "::_gpgme_op_keylist_result", /* tp_doc */
36947 : (traverseproc) 0, /* tp_traverse */
36948 : (inquiry) 0, /* tp_clear */
36949 : (richcmpfunc) SwigPyBuiltin___gpgme_op_keylist_result_richcompare, /* feature:python:tp_richcompare */
36950 : 0, /* tp_weaklistoffset */
36951 : (getiterfunc) 0, /* tp_iter */
36952 : (iternextfunc) 0, /* tp_iternext */
36953 : SwigPyBuiltin___gpgme_op_keylist_result_methods, /* tp_methods */
36954 : 0, /* tp_members */
36955 : SwigPyBuiltin___gpgme_op_keylist_result_getset, /* tp_getset */
36956 : 0, /* tp_base */
36957 : 0, /* tp_dict */
36958 : (descrgetfunc) 0, /* tp_descr_get */
36959 : (descrsetfunc) 0, /* tp_descr_set */
36960 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
36961 : (initproc) _wrap_new__gpgme_op_keylist_result, /* tp_init */
36962 : (allocfunc) 0, /* tp_alloc */
36963 : (newfunc) 0, /* tp_new */
36964 : (freefunc) 0, /* tp_free */
36965 : (inquiry) 0, /* tp_is_gc */
36966 : (PyObject*) 0, /* tp_bases */
36967 : (PyObject*) 0, /* tp_mro */
36968 : (PyObject*) 0, /* tp_cache */
36969 : (PyObject*) 0, /* tp_subclasses */
36970 : (PyObject*) 0, /* tp_weaklist */
36971 : (destructor) 0, /* tp_del */
36972 : #if PY_VERSION_HEX >= 0x02060000
36973 : (int) 0, /* tp_version_tag */
36974 : #endif
36975 : },
36976 : {
36977 : (binaryfunc) 0, /* nb_add */
36978 : (binaryfunc) 0, /* nb_subtract */
36979 : (binaryfunc) 0, /* nb_multiply */
36980 : #if PY_VERSION_HEX < 0x03000000
36981 : (binaryfunc) 0, /* nb_divide */
36982 : #endif
36983 : (binaryfunc) 0, /* nb_remainder */
36984 : (binaryfunc) 0, /* nb_divmod */
36985 : (ternaryfunc) 0, /* nb_power */
36986 : (unaryfunc) 0, /* nb_negative */
36987 : (unaryfunc) 0, /* nb_positive */
36988 : (unaryfunc) 0, /* nb_absolute */
36989 : (inquiry) 0, /* nb_nonzero */
36990 : (unaryfunc) 0, /* nb_invert */
36991 : (binaryfunc) 0, /* nb_lshift */
36992 : (binaryfunc) 0, /* nb_rshift */
36993 : (binaryfunc) 0, /* nb_and */
36994 : (binaryfunc) 0, /* nb_xor */
36995 : (binaryfunc) 0, /* nb_or */
36996 : #if PY_VERSION_HEX < 0x03000000
36997 : (coercion) 0, /* nb_coerce */
36998 : #endif
36999 : (unaryfunc) 0, /* nb_int */
37000 : #if PY_VERSION_HEX >= 0x03000000
37001 : (void*) 0, /* nb_reserved */
37002 : #else
37003 : (unaryfunc) 0, /* nb_long */
37004 : #endif
37005 : (unaryfunc) 0, /* nb_float */
37006 : #if PY_VERSION_HEX < 0x03000000
37007 : (unaryfunc) 0, /* nb_oct */
37008 : (unaryfunc) 0, /* nb_hex */
37009 : #endif
37010 : (binaryfunc) 0, /* nb_inplace_add */
37011 : (binaryfunc) 0, /* nb_inplace_subtract */
37012 : (binaryfunc) 0, /* nb_inplace_multiply */
37013 : #if PY_VERSION_HEX < 0x03000000
37014 : (binaryfunc) 0, /* nb_inplace_divide */
37015 : #endif
37016 : (binaryfunc) 0, /* nb_inplace_remainder */
37017 : (ternaryfunc) 0, /* nb_inplace_power */
37018 : (binaryfunc) 0, /* nb_inplace_lshift */
37019 : (binaryfunc) 0, /* nb_inplace_rshift */
37020 : (binaryfunc) 0, /* nb_inplace_and */
37021 : (binaryfunc) 0, /* nb_inplace_xor */
37022 : (binaryfunc) 0, /* nb_inplace_or */
37023 : (binaryfunc) 0, /* nb_floor_divide */
37024 : (binaryfunc) 0, /* nb_true_divide */
37025 : (binaryfunc) 0, /* nb_inplace_floor_divide */
37026 : (binaryfunc) 0, /* nb_inplace_true_divide */
37027 : #if PY_VERSION_HEX >= 0x02050000
37028 : (unaryfunc) 0, /* nb_index */
37029 : #endif
37030 : },
37031 : {
37032 : (lenfunc) 0, /* mp_length */
37033 : (binaryfunc) 0, /* mp_subscript */
37034 : (objobjargproc) 0, /* mp_ass_subscript */
37035 : },
37036 : {
37037 : (lenfunc) 0, /* sq_length */
37038 : (binaryfunc) 0, /* sq_concat */
37039 : (ssizeargfunc) 0, /* sq_repeat */
37040 : (ssizeargfunc) 0, /* sq_item */
37041 : #if PY_VERSION_HEX >= 0x03000000
37042 : (void*) 0, /* was_sq_slice */
37043 : #else
37044 : (ssizessizeargfunc) 0, /* sq_slice */
37045 : #endif
37046 : (ssizeobjargproc) 0, /* sq_ass_item */
37047 : #if PY_VERSION_HEX >= 0x03000000
37048 : (void*) 0, /* was_sq_ass_slice */
37049 : #else
37050 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
37051 : #endif
37052 : (objobjproc) 0, /* sq_contains */
37053 : (binaryfunc) 0, /* sq_inplace_concat */
37054 : (ssizeargfunc) 0, /* sq_inplace_repeat */
37055 : },
37056 : {
37057 : #if PY_VERSION_HEX < 0x03000000
37058 : (readbufferproc) 0, /* bf_getreadbuffer */
37059 : (writebufferproc) 0, /* bf_getwritebuffer */
37060 : (segcountproc) 0, /* bf_getsegcount */
37061 : (charbufferproc) 0, /* bf_getcharbuffer */
37062 : #endif
37063 : #if PY_VERSION_HEX >= 0x02060000
37064 : (getbufferproc) 0, /* bf_getbuffer */
37065 : (releasebufferproc) 0, /* bf_releasebuffer */
37066 : #endif
37067 : },
37068 : (PyObject*) 0, /* ht_name */
37069 : (PyObject*) 0, /* ht_slots */
37070 : };
37071 :
37072 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_op_keylist_result_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_op_keylist_result_type};
37073 :
37074 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_trust_item)
37075 : static SwigPyGetSet _gpgme_trust_item_owner_trust_getset = { _wrap__gpgme_trust_item_owner_trust_get, _wrap__gpgme_trust_item_owner_trust_set };
37076 : static SwigPyGetSet _gpgme_trust_item__owner_trust_getset = { _wrap__gpgme_trust_item__owner_trust_get, _wrap__gpgme_trust_item__owner_trust_set };
37077 : static SwigPyGetSet _gpgme_trust_item_keyid_getset = { _wrap__gpgme_trust_item_keyid_get, _wrap__gpgme_trust_item_keyid_set };
37078 : static SwigPyGetSet _gpgme_trust_item_name_getset = { _wrap__gpgme_trust_item_name_get, _wrap__gpgme_trust_item_name_set };
37079 : static SwigPyGetSet _gpgme_trust_item__refs_getset = { _wrap__gpgme_trust_item__refs_get, _wrap__gpgme_trust_item__refs_set };
37080 : static SwigPyGetSet _gpgme_trust_item_level_getset = { _wrap__gpgme_trust_item_level_get, _wrap__gpgme_trust_item_level_set };
37081 : static SwigPyGetSet _gpgme_trust_item_validity_getset = { _wrap__gpgme_trust_item_validity_get, _wrap__gpgme_trust_item_validity_set };
37082 : static SwigPyGetSet _gpgme_trust_item__validity_getset = { _wrap__gpgme_trust_item__validity_get, _wrap__gpgme_trust_item__validity_set };
37083 : static SwigPyGetSet _gpgme_trust_item_type_getset = { _wrap__gpgme_trust_item_type_get, _wrap__gpgme_trust_item_type_set };
37084 : static SwigPyGetSet _gpgme_trust_item__keyid_getset = { _wrap__gpgme_trust_item__keyid_get, _wrap__gpgme_trust_item__keyid_set };
37085 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_trust_item_getset[] = {
37086 : { (char*) "owner_trust", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_trust_item.owner_trust", (void*) &_gpgme_trust_item_owner_trust_getset }
37087 : ,
37088 : { (char*) "_owner_trust", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_trust_item._owner_trust", (void*) &_gpgme_trust_item__owner_trust_getset }
37089 : ,
37090 : { (char*) "keyid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_trust_item.keyid", (void*) &_gpgme_trust_item_keyid_getset }
37091 : ,
37092 : { (char*) "name", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_trust_item.name", (void*) &_gpgme_trust_item_name_getset }
37093 : ,
37094 : { (char*) "_refs", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_trust_item._refs", (void*) &_gpgme_trust_item__refs_getset }
37095 : ,
37096 : { (char*) "level", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_trust_item.level", (void*) &_gpgme_trust_item_level_getset }
37097 : ,
37098 : { (char*) "validity", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_trust_item.validity", (void*) &_gpgme_trust_item_validity_getset }
37099 : ,
37100 : { (char*) "_validity", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_trust_item._validity", (void*) &_gpgme_trust_item__validity_getset }
37101 : ,
37102 : { (char*) "type", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_trust_item.type", (void*) &_gpgme_trust_item_type_getset }
37103 : ,
37104 : { (char*) "_keyid", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_trust_item._keyid", (void*) &_gpgme_trust_item__keyid_getset }
37105 : ,
37106 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
37107 : };
37108 :
37109 : SWIGINTERN PyObject *
37110 0 : SwigPyBuiltin___gpgme_trust_item_richcompare(PyObject *self, PyObject *other, int op) {
37111 0 : PyObject *result = NULL;
37112 0 : PyObject *tuple = PyTuple_New(1);
37113 : assert(tuple);
37114 0 : PyTuple_SET_ITEM(tuple, 0, other);
37115 0 : Py_XINCREF(other);
37116 : if (!result) {
37117 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
37118 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
37119 : } else {
37120 0 : result = Py_NotImplemented;
37121 0 : Py_INCREF(result);
37122 : }
37123 : }
37124 0 : Py_DECREF(tuple);
37125 0 : return result;
37126 : }
37127 :
37128 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_trust_item_methods[] = {
37129 : { NULL, NULL, 0, NULL } /* Sentinel */
37130 : };
37131 :
37132 : static PyHeapTypeObject SwigPyBuiltin___gpgme_trust_item_type = {
37133 : {
37134 : #if PY_VERSION_HEX >= 0x03000000
37135 : PyVarObject_HEAD_INIT(NULL, 0)
37136 : #else
37137 : PyObject_HEAD_INIT(NULL)
37138 : 0, /* ob_size */
37139 : #endif
37140 : "_gpgme_trust_item", /* tp_name */
37141 : sizeof(SwigPyObject), /* tp_basicsize */
37142 : 0, /* tp_itemsize */
37143 : (destructor) _wrap_delete__gpgme_trust_item_closure, /* tp_dealloc */
37144 : (printfunc) 0, /* tp_print */
37145 : (getattrfunc) 0, /* tp_getattr */
37146 : (setattrfunc) 0, /* tp_setattr */
37147 : #if PY_VERSION_HEX >= 0x03000000
37148 : 0, /* tp_compare */
37149 : #else
37150 : (cmpfunc) 0, /* tp_compare */
37151 : #endif
37152 : (reprfunc) 0, /* tp_repr */
37153 : &SwigPyBuiltin___gpgme_trust_item_type.as_number, /* tp_as_number */
37154 : &SwigPyBuiltin___gpgme_trust_item_type.as_sequence, /* tp_as_sequence */
37155 : &SwigPyBuiltin___gpgme_trust_item_type.as_mapping, /* tp_as_mapping */
37156 : (hashfunc) 0, /* tp_hash */
37157 : (ternaryfunc) 0, /* tp_call */
37158 : (reprfunc) 0, /* tp_str */
37159 : (getattrofunc) 0, /* tp_getattro */
37160 : (setattrofunc) 0, /* tp_setattro */
37161 : &SwigPyBuiltin___gpgme_trust_item_type.as_buffer, /* tp_as_buffer */
37162 : #if PY_VERSION_HEX >= 0x03000000
37163 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
37164 : #else
37165 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
37166 : #endif
37167 : "::_gpgme_trust_item", /* tp_doc */
37168 : (traverseproc) 0, /* tp_traverse */
37169 : (inquiry) 0, /* tp_clear */
37170 : (richcmpfunc) SwigPyBuiltin___gpgme_trust_item_richcompare, /* feature:python:tp_richcompare */
37171 : 0, /* tp_weaklistoffset */
37172 : (getiterfunc) 0, /* tp_iter */
37173 : (iternextfunc) 0, /* tp_iternext */
37174 : SwigPyBuiltin___gpgme_trust_item_methods, /* tp_methods */
37175 : 0, /* tp_members */
37176 : SwigPyBuiltin___gpgme_trust_item_getset, /* tp_getset */
37177 : 0, /* tp_base */
37178 : 0, /* tp_dict */
37179 : (descrgetfunc) 0, /* tp_descr_get */
37180 : (descrsetfunc) 0, /* tp_descr_set */
37181 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
37182 : (initproc) _wrap_new__gpgme_trust_item, /* tp_init */
37183 : (allocfunc) 0, /* tp_alloc */
37184 : (newfunc) 0, /* tp_new */
37185 : (freefunc) 0, /* tp_free */
37186 : (inquiry) 0, /* tp_is_gc */
37187 : (PyObject*) 0, /* tp_bases */
37188 : (PyObject*) 0, /* tp_mro */
37189 : (PyObject*) 0, /* tp_cache */
37190 : (PyObject*) 0, /* tp_subclasses */
37191 : (PyObject*) 0, /* tp_weaklist */
37192 : (destructor) 0, /* tp_del */
37193 : #if PY_VERSION_HEX >= 0x02060000
37194 : (int) 0, /* tp_version_tag */
37195 : #endif
37196 : },
37197 : {
37198 : (binaryfunc) 0, /* nb_add */
37199 : (binaryfunc) 0, /* nb_subtract */
37200 : (binaryfunc) 0, /* nb_multiply */
37201 : #if PY_VERSION_HEX < 0x03000000
37202 : (binaryfunc) 0, /* nb_divide */
37203 : #endif
37204 : (binaryfunc) 0, /* nb_remainder */
37205 : (binaryfunc) 0, /* nb_divmod */
37206 : (ternaryfunc) 0, /* nb_power */
37207 : (unaryfunc) 0, /* nb_negative */
37208 : (unaryfunc) 0, /* nb_positive */
37209 : (unaryfunc) 0, /* nb_absolute */
37210 : (inquiry) 0, /* nb_nonzero */
37211 : (unaryfunc) 0, /* nb_invert */
37212 : (binaryfunc) 0, /* nb_lshift */
37213 : (binaryfunc) 0, /* nb_rshift */
37214 : (binaryfunc) 0, /* nb_and */
37215 : (binaryfunc) 0, /* nb_xor */
37216 : (binaryfunc) 0, /* nb_or */
37217 : #if PY_VERSION_HEX < 0x03000000
37218 : (coercion) 0, /* nb_coerce */
37219 : #endif
37220 : (unaryfunc) 0, /* nb_int */
37221 : #if PY_VERSION_HEX >= 0x03000000
37222 : (void*) 0, /* nb_reserved */
37223 : #else
37224 : (unaryfunc) 0, /* nb_long */
37225 : #endif
37226 : (unaryfunc) 0, /* nb_float */
37227 : #if PY_VERSION_HEX < 0x03000000
37228 : (unaryfunc) 0, /* nb_oct */
37229 : (unaryfunc) 0, /* nb_hex */
37230 : #endif
37231 : (binaryfunc) 0, /* nb_inplace_add */
37232 : (binaryfunc) 0, /* nb_inplace_subtract */
37233 : (binaryfunc) 0, /* nb_inplace_multiply */
37234 : #if PY_VERSION_HEX < 0x03000000
37235 : (binaryfunc) 0, /* nb_inplace_divide */
37236 : #endif
37237 : (binaryfunc) 0, /* nb_inplace_remainder */
37238 : (ternaryfunc) 0, /* nb_inplace_power */
37239 : (binaryfunc) 0, /* nb_inplace_lshift */
37240 : (binaryfunc) 0, /* nb_inplace_rshift */
37241 : (binaryfunc) 0, /* nb_inplace_and */
37242 : (binaryfunc) 0, /* nb_inplace_xor */
37243 : (binaryfunc) 0, /* nb_inplace_or */
37244 : (binaryfunc) 0, /* nb_floor_divide */
37245 : (binaryfunc) 0, /* nb_true_divide */
37246 : (binaryfunc) 0, /* nb_inplace_floor_divide */
37247 : (binaryfunc) 0, /* nb_inplace_true_divide */
37248 : #if PY_VERSION_HEX >= 0x02050000
37249 : (unaryfunc) 0, /* nb_index */
37250 : #endif
37251 : },
37252 : {
37253 : (lenfunc) 0, /* mp_length */
37254 : (binaryfunc) 0, /* mp_subscript */
37255 : (objobjargproc) 0, /* mp_ass_subscript */
37256 : },
37257 : {
37258 : (lenfunc) 0, /* sq_length */
37259 : (binaryfunc) 0, /* sq_concat */
37260 : (ssizeargfunc) 0, /* sq_repeat */
37261 : (ssizeargfunc) 0, /* sq_item */
37262 : #if PY_VERSION_HEX >= 0x03000000
37263 : (void*) 0, /* was_sq_slice */
37264 : #else
37265 : (ssizessizeargfunc) 0, /* sq_slice */
37266 : #endif
37267 : (ssizeobjargproc) 0, /* sq_ass_item */
37268 : #if PY_VERSION_HEX >= 0x03000000
37269 : (void*) 0, /* was_sq_ass_slice */
37270 : #else
37271 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
37272 : #endif
37273 : (objobjproc) 0, /* sq_contains */
37274 : (binaryfunc) 0, /* sq_inplace_concat */
37275 : (ssizeargfunc) 0, /* sq_inplace_repeat */
37276 : },
37277 : {
37278 : #if PY_VERSION_HEX < 0x03000000
37279 : (readbufferproc) 0, /* bf_getreadbuffer */
37280 : (writebufferproc) 0, /* bf_getwritebuffer */
37281 : (segcountproc) 0, /* bf_getsegcount */
37282 : (charbufferproc) 0, /* bf_getcharbuffer */
37283 : #endif
37284 : #if PY_VERSION_HEX >= 0x02060000
37285 : (getbufferproc) 0, /* bf_getbuffer */
37286 : (releasebufferproc) 0, /* bf_releasebuffer */
37287 : #endif
37288 : },
37289 : (PyObject*) 0, /* ht_name */
37290 : (PyObject*) 0, /* ht_slots */
37291 : };
37292 :
37293 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_trust_item_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_trust_item_type};
37294 :
37295 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_op_assuan_result)
37296 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_op_assuan_result_getset[] = {
37297 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
37298 : };
37299 :
37300 : SWIGINTERN PyObject *
37301 0 : SwigPyBuiltin___gpgme_op_assuan_result_richcompare(PyObject *self, PyObject *other, int op) {
37302 0 : PyObject *result = NULL;
37303 0 : PyObject *tuple = PyTuple_New(1);
37304 : assert(tuple);
37305 0 : PyTuple_SET_ITEM(tuple, 0, other);
37306 0 : Py_XINCREF(other);
37307 : if (!result) {
37308 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
37309 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
37310 : } else {
37311 0 : result = Py_NotImplemented;
37312 0 : Py_INCREF(result);
37313 : }
37314 : }
37315 0 : Py_DECREF(tuple);
37316 0 : return result;
37317 : }
37318 :
37319 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_op_assuan_result_methods[] = {
37320 : { NULL, NULL, 0, NULL } /* Sentinel */
37321 : };
37322 :
37323 : static PyHeapTypeObject SwigPyBuiltin___gpgme_op_assuan_result_type = {
37324 : {
37325 : #if PY_VERSION_HEX >= 0x03000000
37326 : PyVarObject_HEAD_INIT(NULL, 0)
37327 : #else
37328 : PyObject_HEAD_INIT(NULL)
37329 : 0, /* ob_size */
37330 : #endif
37331 : "_gpgme_op_assuan_result", /* tp_name */
37332 : sizeof(SwigPyObject), /* tp_basicsize */
37333 : 0, /* tp_itemsize */
37334 : (destructor) _wrap_delete__gpgme_op_assuan_result_closure, /* tp_dealloc */
37335 : (printfunc) 0, /* tp_print */
37336 : (getattrfunc) 0, /* tp_getattr */
37337 : (setattrfunc) 0, /* tp_setattr */
37338 : #if PY_VERSION_HEX >= 0x03000000
37339 : 0, /* tp_compare */
37340 : #else
37341 : (cmpfunc) 0, /* tp_compare */
37342 : #endif
37343 : (reprfunc) 0, /* tp_repr */
37344 : &SwigPyBuiltin___gpgme_op_assuan_result_type.as_number, /* tp_as_number */
37345 : &SwigPyBuiltin___gpgme_op_assuan_result_type.as_sequence, /* tp_as_sequence */
37346 : &SwigPyBuiltin___gpgme_op_assuan_result_type.as_mapping, /* tp_as_mapping */
37347 : (hashfunc) 0, /* tp_hash */
37348 : (ternaryfunc) 0, /* tp_call */
37349 : (reprfunc) 0, /* tp_str */
37350 : (getattrofunc) 0, /* tp_getattro */
37351 : (setattrofunc) 0, /* tp_setattro */
37352 : &SwigPyBuiltin___gpgme_op_assuan_result_type.as_buffer, /* tp_as_buffer */
37353 : #if PY_VERSION_HEX >= 0x03000000
37354 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
37355 : #else
37356 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
37357 : #endif
37358 : "::_gpgme_op_assuan_result", /* tp_doc */
37359 : (traverseproc) 0, /* tp_traverse */
37360 : (inquiry) 0, /* tp_clear */
37361 : (richcmpfunc) SwigPyBuiltin___gpgme_op_assuan_result_richcompare, /* feature:python:tp_richcompare */
37362 : 0, /* tp_weaklistoffset */
37363 : (getiterfunc) 0, /* tp_iter */
37364 : (iternextfunc) 0, /* tp_iternext */
37365 : SwigPyBuiltin___gpgme_op_assuan_result_methods, /* tp_methods */
37366 : 0, /* tp_members */
37367 : SwigPyBuiltin___gpgme_op_assuan_result_getset, /* tp_getset */
37368 : 0, /* tp_base */
37369 : 0, /* tp_dict */
37370 : (descrgetfunc) 0, /* tp_descr_get */
37371 : (descrsetfunc) 0, /* tp_descr_set */
37372 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
37373 : (initproc) _wrap_new__gpgme_op_assuan_result, /* tp_init */
37374 : (allocfunc) 0, /* tp_alloc */
37375 : (newfunc) 0, /* tp_new */
37376 : (freefunc) 0, /* tp_free */
37377 : (inquiry) 0, /* tp_is_gc */
37378 : (PyObject*) 0, /* tp_bases */
37379 : (PyObject*) 0, /* tp_mro */
37380 : (PyObject*) 0, /* tp_cache */
37381 : (PyObject*) 0, /* tp_subclasses */
37382 : (PyObject*) 0, /* tp_weaklist */
37383 : (destructor) 0, /* tp_del */
37384 : #if PY_VERSION_HEX >= 0x02060000
37385 : (int) 0, /* tp_version_tag */
37386 : #endif
37387 : },
37388 : {
37389 : (binaryfunc) 0, /* nb_add */
37390 : (binaryfunc) 0, /* nb_subtract */
37391 : (binaryfunc) 0, /* nb_multiply */
37392 : #if PY_VERSION_HEX < 0x03000000
37393 : (binaryfunc) 0, /* nb_divide */
37394 : #endif
37395 : (binaryfunc) 0, /* nb_remainder */
37396 : (binaryfunc) 0, /* nb_divmod */
37397 : (ternaryfunc) 0, /* nb_power */
37398 : (unaryfunc) 0, /* nb_negative */
37399 : (unaryfunc) 0, /* nb_positive */
37400 : (unaryfunc) 0, /* nb_absolute */
37401 : (inquiry) 0, /* nb_nonzero */
37402 : (unaryfunc) 0, /* nb_invert */
37403 : (binaryfunc) 0, /* nb_lshift */
37404 : (binaryfunc) 0, /* nb_rshift */
37405 : (binaryfunc) 0, /* nb_and */
37406 : (binaryfunc) 0, /* nb_xor */
37407 : (binaryfunc) 0, /* nb_or */
37408 : #if PY_VERSION_HEX < 0x03000000
37409 : (coercion) 0, /* nb_coerce */
37410 : #endif
37411 : (unaryfunc) 0, /* nb_int */
37412 : #if PY_VERSION_HEX >= 0x03000000
37413 : (void*) 0, /* nb_reserved */
37414 : #else
37415 : (unaryfunc) 0, /* nb_long */
37416 : #endif
37417 : (unaryfunc) 0, /* nb_float */
37418 : #if PY_VERSION_HEX < 0x03000000
37419 : (unaryfunc) 0, /* nb_oct */
37420 : (unaryfunc) 0, /* nb_hex */
37421 : #endif
37422 : (binaryfunc) 0, /* nb_inplace_add */
37423 : (binaryfunc) 0, /* nb_inplace_subtract */
37424 : (binaryfunc) 0, /* nb_inplace_multiply */
37425 : #if PY_VERSION_HEX < 0x03000000
37426 : (binaryfunc) 0, /* nb_inplace_divide */
37427 : #endif
37428 : (binaryfunc) 0, /* nb_inplace_remainder */
37429 : (ternaryfunc) 0, /* nb_inplace_power */
37430 : (binaryfunc) 0, /* nb_inplace_lshift */
37431 : (binaryfunc) 0, /* nb_inplace_rshift */
37432 : (binaryfunc) 0, /* nb_inplace_and */
37433 : (binaryfunc) 0, /* nb_inplace_xor */
37434 : (binaryfunc) 0, /* nb_inplace_or */
37435 : (binaryfunc) 0, /* nb_floor_divide */
37436 : (binaryfunc) 0, /* nb_true_divide */
37437 : (binaryfunc) 0, /* nb_inplace_floor_divide */
37438 : (binaryfunc) 0, /* nb_inplace_true_divide */
37439 : #if PY_VERSION_HEX >= 0x02050000
37440 : (unaryfunc) 0, /* nb_index */
37441 : #endif
37442 : },
37443 : {
37444 : (lenfunc) 0, /* mp_length */
37445 : (binaryfunc) 0, /* mp_subscript */
37446 : (objobjargproc) 0, /* mp_ass_subscript */
37447 : },
37448 : {
37449 : (lenfunc) 0, /* sq_length */
37450 : (binaryfunc) 0, /* sq_concat */
37451 : (ssizeargfunc) 0, /* sq_repeat */
37452 : (ssizeargfunc) 0, /* sq_item */
37453 : #if PY_VERSION_HEX >= 0x03000000
37454 : (void*) 0, /* was_sq_slice */
37455 : #else
37456 : (ssizessizeargfunc) 0, /* sq_slice */
37457 : #endif
37458 : (ssizeobjargproc) 0, /* sq_ass_item */
37459 : #if PY_VERSION_HEX >= 0x03000000
37460 : (void*) 0, /* was_sq_ass_slice */
37461 : #else
37462 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
37463 : #endif
37464 : (objobjproc) 0, /* sq_contains */
37465 : (binaryfunc) 0, /* sq_inplace_concat */
37466 : (ssizeargfunc) 0, /* sq_inplace_repeat */
37467 : },
37468 : {
37469 : #if PY_VERSION_HEX < 0x03000000
37470 : (readbufferproc) 0, /* bf_getreadbuffer */
37471 : (writebufferproc) 0, /* bf_getwritebuffer */
37472 : (segcountproc) 0, /* bf_getsegcount */
37473 : (charbufferproc) 0, /* bf_getcharbuffer */
37474 : #endif
37475 : #if PY_VERSION_HEX >= 0x02060000
37476 : (getbufferproc) 0, /* bf_getbuffer */
37477 : (releasebufferproc) 0, /* bf_releasebuffer */
37478 : #endif
37479 : },
37480 : (PyObject*) 0, /* ht_name */
37481 : (PyObject*) 0, /* ht_slots */
37482 : };
37483 :
37484 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_op_assuan_result_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_op_assuan_result_type};
37485 :
37486 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete__gpgme_op_vfs_mount_result)
37487 : static SwigPyGetSet _gpgme_op_vfs_mount_result_mount_dir_getset = { _wrap__gpgme_op_vfs_mount_result_mount_dir_get, _wrap__gpgme_op_vfs_mount_result_mount_dir_set };
37488 : SWIGINTERN PyGetSetDef SwigPyBuiltin___gpgme_op_vfs_mount_result_getset[] = {
37489 : { (char*) "mount_dir", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"_gpgme_op_vfs_mount_result.mount_dir", (void*) &_gpgme_op_vfs_mount_result_mount_dir_getset }
37490 : ,
37491 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
37492 : };
37493 :
37494 : SWIGINTERN PyObject *
37495 0 : SwigPyBuiltin___gpgme_op_vfs_mount_result_richcompare(PyObject *self, PyObject *other, int op) {
37496 0 : PyObject *result = NULL;
37497 0 : PyObject *tuple = PyTuple_New(1);
37498 : assert(tuple);
37499 0 : PyTuple_SET_ITEM(tuple, 0, other);
37500 0 : Py_XINCREF(other);
37501 : if (!result) {
37502 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
37503 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
37504 : } else {
37505 0 : result = Py_NotImplemented;
37506 0 : Py_INCREF(result);
37507 : }
37508 : }
37509 0 : Py_DECREF(tuple);
37510 0 : return result;
37511 : }
37512 :
37513 : SWIGINTERN PyMethodDef SwigPyBuiltin___gpgme_op_vfs_mount_result_methods[] = {
37514 : { NULL, NULL, 0, NULL } /* Sentinel */
37515 : };
37516 :
37517 : static PyHeapTypeObject SwigPyBuiltin___gpgme_op_vfs_mount_result_type = {
37518 : {
37519 : #if PY_VERSION_HEX >= 0x03000000
37520 : PyVarObject_HEAD_INIT(NULL, 0)
37521 : #else
37522 : PyObject_HEAD_INIT(NULL)
37523 : 0, /* ob_size */
37524 : #endif
37525 : "_gpgme_op_vfs_mount_result", /* tp_name */
37526 : sizeof(SwigPyObject), /* tp_basicsize */
37527 : 0, /* tp_itemsize */
37528 : (destructor) _wrap_delete__gpgme_op_vfs_mount_result_closure, /* tp_dealloc */
37529 : (printfunc) 0, /* tp_print */
37530 : (getattrfunc) 0, /* tp_getattr */
37531 : (setattrfunc) 0, /* tp_setattr */
37532 : #if PY_VERSION_HEX >= 0x03000000
37533 : 0, /* tp_compare */
37534 : #else
37535 : (cmpfunc) 0, /* tp_compare */
37536 : #endif
37537 : (reprfunc) 0, /* tp_repr */
37538 : &SwigPyBuiltin___gpgme_op_vfs_mount_result_type.as_number, /* tp_as_number */
37539 : &SwigPyBuiltin___gpgme_op_vfs_mount_result_type.as_sequence, /* tp_as_sequence */
37540 : &SwigPyBuiltin___gpgme_op_vfs_mount_result_type.as_mapping, /* tp_as_mapping */
37541 : (hashfunc) 0, /* tp_hash */
37542 : (ternaryfunc) 0, /* tp_call */
37543 : (reprfunc) 0, /* tp_str */
37544 : (getattrofunc) 0, /* tp_getattro */
37545 : (setattrofunc) 0, /* tp_setattro */
37546 : &SwigPyBuiltin___gpgme_op_vfs_mount_result_type.as_buffer, /* tp_as_buffer */
37547 : #if PY_VERSION_HEX >= 0x03000000
37548 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
37549 : #else
37550 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
37551 : #endif
37552 : "::_gpgme_op_vfs_mount_result", /* tp_doc */
37553 : (traverseproc) 0, /* tp_traverse */
37554 : (inquiry) 0, /* tp_clear */
37555 : (richcmpfunc) SwigPyBuiltin___gpgme_op_vfs_mount_result_richcompare, /* feature:python:tp_richcompare */
37556 : 0, /* tp_weaklistoffset */
37557 : (getiterfunc) 0, /* tp_iter */
37558 : (iternextfunc) 0, /* tp_iternext */
37559 : SwigPyBuiltin___gpgme_op_vfs_mount_result_methods, /* tp_methods */
37560 : 0, /* tp_members */
37561 : SwigPyBuiltin___gpgme_op_vfs_mount_result_getset, /* tp_getset */
37562 : 0, /* tp_base */
37563 : 0, /* tp_dict */
37564 : (descrgetfunc) 0, /* tp_descr_get */
37565 : (descrsetfunc) 0, /* tp_descr_set */
37566 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
37567 : (initproc) _wrap_new__gpgme_op_vfs_mount_result, /* tp_init */
37568 : (allocfunc) 0, /* tp_alloc */
37569 : (newfunc) 0, /* tp_new */
37570 : (freefunc) 0, /* tp_free */
37571 : (inquiry) 0, /* tp_is_gc */
37572 : (PyObject*) 0, /* tp_bases */
37573 : (PyObject*) 0, /* tp_mro */
37574 : (PyObject*) 0, /* tp_cache */
37575 : (PyObject*) 0, /* tp_subclasses */
37576 : (PyObject*) 0, /* tp_weaklist */
37577 : (destructor) 0, /* tp_del */
37578 : #if PY_VERSION_HEX >= 0x02060000
37579 : (int) 0, /* tp_version_tag */
37580 : #endif
37581 : },
37582 : {
37583 : (binaryfunc) 0, /* nb_add */
37584 : (binaryfunc) 0, /* nb_subtract */
37585 : (binaryfunc) 0, /* nb_multiply */
37586 : #if PY_VERSION_HEX < 0x03000000
37587 : (binaryfunc) 0, /* nb_divide */
37588 : #endif
37589 : (binaryfunc) 0, /* nb_remainder */
37590 : (binaryfunc) 0, /* nb_divmod */
37591 : (ternaryfunc) 0, /* nb_power */
37592 : (unaryfunc) 0, /* nb_negative */
37593 : (unaryfunc) 0, /* nb_positive */
37594 : (unaryfunc) 0, /* nb_absolute */
37595 : (inquiry) 0, /* nb_nonzero */
37596 : (unaryfunc) 0, /* nb_invert */
37597 : (binaryfunc) 0, /* nb_lshift */
37598 : (binaryfunc) 0, /* nb_rshift */
37599 : (binaryfunc) 0, /* nb_and */
37600 : (binaryfunc) 0, /* nb_xor */
37601 : (binaryfunc) 0, /* nb_or */
37602 : #if PY_VERSION_HEX < 0x03000000
37603 : (coercion) 0, /* nb_coerce */
37604 : #endif
37605 : (unaryfunc) 0, /* nb_int */
37606 : #if PY_VERSION_HEX >= 0x03000000
37607 : (void*) 0, /* nb_reserved */
37608 : #else
37609 : (unaryfunc) 0, /* nb_long */
37610 : #endif
37611 : (unaryfunc) 0, /* nb_float */
37612 : #if PY_VERSION_HEX < 0x03000000
37613 : (unaryfunc) 0, /* nb_oct */
37614 : (unaryfunc) 0, /* nb_hex */
37615 : #endif
37616 : (binaryfunc) 0, /* nb_inplace_add */
37617 : (binaryfunc) 0, /* nb_inplace_subtract */
37618 : (binaryfunc) 0, /* nb_inplace_multiply */
37619 : #if PY_VERSION_HEX < 0x03000000
37620 : (binaryfunc) 0, /* nb_inplace_divide */
37621 : #endif
37622 : (binaryfunc) 0, /* nb_inplace_remainder */
37623 : (ternaryfunc) 0, /* nb_inplace_power */
37624 : (binaryfunc) 0, /* nb_inplace_lshift */
37625 : (binaryfunc) 0, /* nb_inplace_rshift */
37626 : (binaryfunc) 0, /* nb_inplace_and */
37627 : (binaryfunc) 0, /* nb_inplace_xor */
37628 : (binaryfunc) 0, /* nb_inplace_or */
37629 : (binaryfunc) 0, /* nb_floor_divide */
37630 : (binaryfunc) 0, /* nb_true_divide */
37631 : (binaryfunc) 0, /* nb_inplace_floor_divide */
37632 : (binaryfunc) 0, /* nb_inplace_true_divide */
37633 : #if PY_VERSION_HEX >= 0x02050000
37634 : (unaryfunc) 0, /* nb_index */
37635 : #endif
37636 : },
37637 : {
37638 : (lenfunc) 0, /* mp_length */
37639 : (binaryfunc) 0, /* mp_subscript */
37640 : (objobjargproc) 0, /* mp_ass_subscript */
37641 : },
37642 : {
37643 : (lenfunc) 0, /* sq_length */
37644 : (binaryfunc) 0, /* sq_concat */
37645 : (ssizeargfunc) 0, /* sq_repeat */
37646 : (ssizeargfunc) 0, /* sq_item */
37647 : #if PY_VERSION_HEX >= 0x03000000
37648 : (void*) 0, /* was_sq_slice */
37649 : #else
37650 : (ssizessizeargfunc) 0, /* sq_slice */
37651 : #endif
37652 : (ssizeobjargproc) 0, /* sq_ass_item */
37653 : #if PY_VERSION_HEX >= 0x03000000
37654 : (void*) 0, /* was_sq_ass_slice */
37655 : #else
37656 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
37657 : #endif
37658 : (objobjproc) 0, /* sq_contains */
37659 : (binaryfunc) 0, /* sq_inplace_concat */
37660 : (ssizeargfunc) 0, /* sq_inplace_repeat */
37661 : },
37662 : {
37663 : #if PY_VERSION_HEX < 0x03000000
37664 : (readbufferproc) 0, /* bf_getreadbuffer */
37665 : (writebufferproc) 0, /* bf_getwritebuffer */
37666 : (segcountproc) 0, /* bf_getsegcount */
37667 : (charbufferproc) 0, /* bf_getcharbuffer */
37668 : #endif
37669 : #if PY_VERSION_HEX >= 0x02060000
37670 : (getbufferproc) 0, /* bf_getbuffer */
37671 : (releasebufferproc) 0, /* bf_releasebuffer */
37672 : #endif
37673 : },
37674 : (PyObject*) 0, /* ht_name */
37675 : (PyObject*) 0, /* ht_slots */
37676 : };
37677 :
37678 : SWIGINTERN SwigPyClientData SwigPyBuiltin___gpgme_op_vfs_mount_result_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin___gpgme_op_vfs_mount_result_type};
37679 :
37680 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_gpgme_conf_arg)
37681 : static SwigPyGetSet gpgme_conf_arg_value_getset = { _wrap_gpgme_conf_arg_value_get, 0 };
37682 : static SwigPyGetSet gpgme_conf_arg_no_arg_getset = { _wrap_gpgme_conf_arg_no_arg_get, _wrap_gpgme_conf_arg_no_arg_set };
37683 : SWIGINTERN PyGetSetDef SwigPyBuiltin__gpgme_conf_arg_getset[] = {
37684 : { (char*) "value", (getter) SwigPyBuiltin_GetterClosure, (setter) 0, (char*)"gpgme_conf_arg.value", (void*) &gpgme_conf_arg_value_getset }
37685 : ,
37686 : { (char*) "no_arg", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_arg.no_arg", (void*) &gpgme_conf_arg_no_arg_getset }
37687 : ,
37688 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
37689 : };
37690 :
37691 : SWIGINTERN PyObject *
37692 0 : SwigPyBuiltin__gpgme_conf_arg_richcompare(PyObject *self, PyObject *other, int op) {
37693 0 : PyObject *result = NULL;
37694 0 : PyObject *tuple = PyTuple_New(1);
37695 : assert(tuple);
37696 0 : PyTuple_SET_ITEM(tuple, 0, other);
37697 0 : Py_XINCREF(other);
37698 : if (!result) {
37699 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
37700 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
37701 : } else {
37702 0 : result = Py_NotImplemented;
37703 0 : Py_INCREF(result);
37704 : }
37705 : }
37706 0 : Py_DECREF(tuple);
37707 0 : return result;
37708 : }
37709 :
37710 : SWIGINTERN PyMethodDef SwigPyBuiltin__gpgme_conf_arg_methods[] = {
37711 : { NULL, NULL, 0, NULL } /* Sentinel */
37712 : };
37713 :
37714 : static PyHeapTypeObject SwigPyBuiltin__gpgme_conf_arg_type = {
37715 : {
37716 : #if PY_VERSION_HEX >= 0x03000000
37717 : PyVarObject_HEAD_INIT(NULL, 0)
37718 : #else
37719 : PyObject_HEAD_INIT(NULL)
37720 : 0, /* ob_size */
37721 : #endif
37722 : "gpgme_conf_arg", /* tp_name */
37723 : sizeof(SwigPyObject), /* tp_basicsize */
37724 : 0, /* tp_itemsize */
37725 : (destructor) _wrap_delete_gpgme_conf_arg_closure, /* tp_dealloc */
37726 : (printfunc) 0, /* tp_print */
37727 : (getattrfunc) 0, /* tp_getattr */
37728 : (setattrfunc) 0, /* tp_setattr */
37729 : #if PY_VERSION_HEX >= 0x03000000
37730 : 0, /* tp_compare */
37731 : #else
37732 : (cmpfunc) 0, /* tp_compare */
37733 : #endif
37734 : (reprfunc) 0, /* tp_repr */
37735 : &SwigPyBuiltin__gpgme_conf_arg_type.as_number, /* tp_as_number */
37736 : &SwigPyBuiltin__gpgme_conf_arg_type.as_sequence, /* tp_as_sequence */
37737 : &SwigPyBuiltin__gpgme_conf_arg_type.as_mapping, /* tp_as_mapping */
37738 : (hashfunc) 0, /* tp_hash */
37739 : (ternaryfunc) 0, /* tp_call */
37740 : (reprfunc) 0, /* tp_str */
37741 : (getattrofunc) 0, /* tp_getattro */
37742 : (setattrofunc) 0, /* tp_setattro */
37743 : &SwigPyBuiltin__gpgme_conf_arg_type.as_buffer, /* tp_as_buffer */
37744 : #if PY_VERSION_HEX >= 0x03000000
37745 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
37746 : #else
37747 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
37748 : #endif
37749 : "::gpgme_conf_arg", /* tp_doc */
37750 : (traverseproc) 0, /* tp_traverse */
37751 : (inquiry) 0, /* tp_clear */
37752 : (richcmpfunc) SwigPyBuiltin__gpgme_conf_arg_richcompare, /* feature:python:tp_richcompare */
37753 : 0, /* tp_weaklistoffset */
37754 : (getiterfunc) 0, /* tp_iter */
37755 : (iternextfunc) 0, /* tp_iternext */
37756 : SwigPyBuiltin__gpgme_conf_arg_methods, /* tp_methods */
37757 : 0, /* tp_members */
37758 : SwigPyBuiltin__gpgme_conf_arg_getset, /* tp_getset */
37759 : 0, /* tp_base */
37760 : 0, /* tp_dict */
37761 : (descrgetfunc) 0, /* tp_descr_get */
37762 : (descrsetfunc) 0, /* tp_descr_set */
37763 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
37764 : (initproc) _wrap_new_gpgme_conf_arg, /* tp_init */
37765 : (allocfunc) 0, /* tp_alloc */
37766 : (newfunc) 0, /* tp_new */
37767 : (freefunc) 0, /* tp_free */
37768 : (inquiry) 0, /* tp_is_gc */
37769 : (PyObject*) 0, /* tp_bases */
37770 : (PyObject*) 0, /* tp_mro */
37771 : (PyObject*) 0, /* tp_cache */
37772 : (PyObject*) 0, /* tp_subclasses */
37773 : (PyObject*) 0, /* tp_weaklist */
37774 : (destructor) 0, /* tp_del */
37775 : #if PY_VERSION_HEX >= 0x02060000
37776 : (int) 0, /* tp_version_tag */
37777 : #endif
37778 : },
37779 : {
37780 : (binaryfunc) 0, /* nb_add */
37781 : (binaryfunc) 0, /* nb_subtract */
37782 : (binaryfunc) 0, /* nb_multiply */
37783 : #if PY_VERSION_HEX < 0x03000000
37784 : (binaryfunc) 0, /* nb_divide */
37785 : #endif
37786 : (binaryfunc) 0, /* nb_remainder */
37787 : (binaryfunc) 0, /* nb_divmod */
37788 : (ternaryfunc) 0, /* nb_power */
37789 : (unaryfunc) 0, /* nb_negative */
37790 : (unaryfunc) 0, /* nb_positive */
37791 : (unaryfunc) 0, /* nb_absolute */
37792 : (inquiry) 0, /* nb_nonzero */
37793 : (unaryfunc) 0, /* nb_invert */
37794 : (binaryfunc) 0, /* nb_lshift */
37795 : (binaryfunc) 0, /* nb_rshift */
37796 : (binaryfunc) 0, /* nb_and */
37797 : (binaryfunc) 0, /* nb_xor */
37798 : (binaryfunc) 0, /* nb_or */
37799 : #if PY_VERSION_HEX < 0x03000000
37800 : (coercion) 0, /* nb_coerce */
37801 : #endif
37802 : (unaryfunc) 0, /* nb_int */
37803 : #if PY_VERSION_HEX >= 0x03000000
37804 : (void*) 0, /* nb_reserved */
37805 : #else
37806 : (unaryfunc) 0, /* nb_long */
37807 : #endif
37808 : (unaryfunc) 0, /* nb_float */
37809 : #if PY_VERSION_HEX < 0x03000000
37810 : (unaryfunc) 0, /* nb_oct */
37811 : (unaryfunc) 0, /* nb_hex */
37812 : #endif
37813 : (binaryfunc) 0, /* nb_inplace_add */
37814 : (binaryfunc) 0, /* nb_inplace_subtract */
37815 : (binaryfunc) 0, /* nb_inplace_multiply */
37816 : #if PY_VERSION_HEX < 0x03000000
37817 : (binaryfunc) 0, /* nb_inplace_divide */
37818 : #endif
37819 : (binaryfunc) 0, /* nb_inplace_remainder */
37820 : (ternaryfunc) 0, /* nb_inplace_power */
37821 : (binaryfunc) 0, /* nb_inplace_lshift */
37822 : (binaryfunc) 0, /* nb_inplace_rshift */
37823 : (binaryfunc) 0, /* nb_inplace_and */
37824 : (binaryfunc) 0, /* nb_inplace_xor */
37825 : (binaryfunc) 0, /* nb_inplace_or */
37826 : (binaryfunc) 0, /* nb_floor_divide */
37827 : (binaryfunc) 0, /* nb_true_divide */
37828 : (binaryfunc) 0, /* nb_inplace_floor_divide */
37829 : (binaryfunc) 0, /* nb_inplace_true_divide */
37830 : #if PY_VERSION_HEX >= 0x02050000
37831 : (unaryfunc) 0, /* nb_index */
37832 : #endif
37833 : },
37834 : {
37835 : (lenfunc) 0, /* mp_length */
37836 : (binaryfunc) 0, /* mp_subscript */
37837 : (objobjargproc) 0, /* mp_ass_subscript */
37838 : },
37839 : {
37840 : (lenfunc) 0, /* sq_length */
37841 : (binaryfunc) 0, /* sq_concat */
37842 : (ssizeargfunc) 0, /* sq_repeat */
37843 : (ssizeargfunc) 0, /* sq_item */
37844 : #if PY_VERSION_HEX >= 0x03000000
37845 : (void*) 0, /* was_sq_slice */
37846 : #else
37847 : (ssizessizeargfunc) 0, /* sq_slice */
37848 : #endif
37849 : (ssizeobjargproc) 0, /* sq_ass_item */
37850 : #if PY_VERSION_HEX >= 0x03000000
37851 : (void*) 0, /* was_sq_ass_slice */
37852 : #else
37853 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
37854 : #endif
37855 : (objobjproc) 0, /* sq_contains */
37856 : (binaryfunc) 0, /* sq_inplace_concat */
37857 : (ssizeargfunc) 0, /* sq_inplace_repeat */
37858 : },
37859 : {
37860 : #if PY_VERSION_HEX < 0x03000000
37861 : (readbufferproc) 0, /* bf_getreadbuffer */
37862 : (writebufferproc) 0, /* bf_getwritebuffer */
37863 : (segcountproc) 0, /* bf_getsegcount */
37864 : (charbufferproc) 0, /* bf_getcharbuffer */
37865 : #endif
37866 : #if PY_VERSION_HEX >= 0x02060000
37867 : (getbufferproc) 0, /* bf_getbuffer */
37868 : (releasebufferproc) 0, /* bf_releasebuffer */
37869 : #endif
37870 : },
37871 : (PyObject*) 0, /* ht_name */
37872 : (PyObject*) 0, /* ht_slots */
37873 : };
37874 :
37875 : SWIGINTERN SwigPyClientData SwigPyBuiltin__gpgme_conf_arg_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__gpgme_conf_arg_type};
37876 :
37877 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_gpgme_conf_arg_value)
37878 : static SwigPyGetSet gpgme_conf_arg_value_int32_getset = { _wrap_gpgme_conf_arg_value_int32_get, _wrap_gpgme_conf_arg_value_int32_set };
37879 : static SwigPyGetSet gpgme_conf_arg_value_count_getset = { _wrap_gpgme_conf_arg_value_count_get, _wrap_gpgme_conf_arg_value_count_set };
37880 : static SwigPyGetSet gpgme_conf_arg_value_string_getset = { _wrap_gpgme_conf_arg_value_string_get, _wrap_gpgme_conf_arg_value_string_set };
37881 : static SwigPyGetSet gpgme_conf_arg_value_uint32_getset = { _wrap_gpgme_conf_arg_value_uint32_get, _wrap_gpgme_conf_arg_value_uint32_set };
37882 : SWIGINTERN PyGetSetDef SwigPyBuiltin__gpgme_conf_arg_value_getset[] = {
37883 : { (char*) "int32", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_arg_value.int32", (void*) &gpgme_conf_arg_value_int32_getset }
37884 : ,
37885 : { (char*) "count", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_arg_value.count", (void*) &gpgme_conf_arg_value_count_getset }
37886 : ,
37887 : { (char*) "string", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_arg_value.string", (void*) &gpgme_conf_arg_value_string_getset }
37888 : ,
37889 : { (char*) "uint32", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_arg_value.uint32", (void*) &gpgme_conf_arg_value_uint32_getset }
37890 : ,
37891 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
37892 : };
37893 :
37894 : SWIGINTERN PyObject *
37895 0 : SwigPyBuiltin__gpgme_conf_arg_value_richcompare(PyObject *self, PyObject *other, int op) {
37896 0 : PyObject *result = NULL;
37897 0 : PyObject *tuple = PyTuple_New(1);
37898 : assert(tuple);
37899 0 : PyTuple_SET_ITEM(tuple, 0, other);
37900 0 : Py_XINCREF(other);
37901 : if (!result) {
37902 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
37903 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
37904 : } else {
37905 0 : result = Py_NotImplemented;
37906 0 : Py_INCREF(result);
37907 : }
37908 : }
37909 0 : Py_DECREF(tuple);
37910 0 : return result;
37911 : }
37912 :
37913 : SWIGINTERN PyMethodDef SwigPyBuiltin__gpgme_conf_arg_value_methods[] = {
37914 : { NULL, NULL, 0, NULL } /* Sentinel */
37915 : };
37916 :
37917 : static PyHeapTypeObject SwigPyBuiltin__gpgme_conf_arg_value_type = {
37918 : {
37919 : #if PY_VERSION_HEX >= 0x03000000
37920 : PyVarObject_HEAD_INIT(NULL, 0)
37921 : #else
37922 : PyObject_HEAD_INIT(NULL)
37923 : 0, /* ob_size */
37924 : #endif
37925 : "gpgme_conf_arg_value", /* tp_name */
37926 : sizeof(SwigPyObject), /* tp_basicsize */
37927 : 0, /* tp_itemsize */
37928 : (destructor) _wrap_delete_gpgme_conf_arg_value_closure, /* tp_dealloc */
37929 : (printfunc) 0, /* tp_print */
37930 : (getattrfunc) 0, /* tp_getattr */
37931 : (setattrfunc) 0, /* tp_setattr */
37932 : #if PY_VERSION_HEX >= 0x03000000
37933 : 0, /* tp_compare */
37934 : #else
37935 : (cmpfunc) 0, /* tp_compare */
37936 : #endif
37937 : (reprfunc) 0, /* tp_repr */
37938 : &SwigPyBuiltin__gpgme_conf_arg_value_type.as_number, /* tp_as_number */
37939 : &SwigPyBuiltin__gpgme_conf_arg_value_type.as_sequence, /* tp_as_sequence */
37940 : &SwigPyBuiltin__gpgme_conf_arg_value_type.as_mapping, /* tp_as_mapping */
37941 : (hashfunc) 0, /* tp_hash */
37942 : (ternaryfunc) 0, /* tp_call */
37943 : (reprfunc) 0, /* tp_str */
37944 : (getattrofunc) 0, /* tp_getattro */
37945 : (setattrofunc) 0, /* tp_setattro */
37946 : &SwigPyBuiltin__gpgme_conf_arg_value_type.as_buffer, /* tp_as_buffer */
37947 : #if PY_VERSION_HEX >= 0x03000000
37948 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
37949 : #else
37950 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
37951 : #endif
37952 : "::gpgme_conf_arg_value", /* tp_doc */
37953 : (traverseproc) 0, /* tp_traverse */
37954 : (inquiry) 0, /* tp_clear */
37955 : (richcmpfunc) SwigPyBuiltin__gpgme_conf_arg_value_richcompare, /* feature:python:tp_richcompare */
37956 : 0, /* tp_weaklistoffset */
37957 : (getiterfunc) 0, /* tp_iter */
37958 : (iternextfunc) 0, /* tp_iternext */
37959 : SwigPyBuiltin__gpgme_conf_arg_value_methods, /* tp_methods */
37960 : 0, /* tp_members */
37961 : SwigPyBuiltin__gpgme_conf_arg_value_getset, /* tp_getset */
37962 : 0, /* tp_base */
37963 : 0, /* tp_dict */
37964 : (descrgetfunc) 0, /* tp_descr_get */
37965 : (descrsetfunc) 0, /* tp_descr_set */
37966 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
37967 : (initproc) _wrap_new_gpgme_conf_arg_value, /* tp_init */
37968 : (allocfunc) 0, /* tp_alloc */
37969 : (newfunc) 0, /* tp_new */
37970 : (freefunc) 0, /* tp_free */
37971 : (inquiry) 0, /* tp_is_gc */
37972 : (PyObject*) 0, /* tp_bases */
37973 : (PyObject*) 0, /* tp_mro */
37974 : (PyObject*) 0, /* tp_cache */
37975 : (PyObject*) 0, /* tp_subclasses */
37976 : (PyObject*) 0, /* tp_weaklist */
37977 : (destructor) 0, /* tp_del */
37978 : #if PY_VERSION_HEX >= 0x02060000
37979 : (int) 0, /* tp_version_tag */
37980 : #endif
37981 : },
37982 : {
37983 : (binaryfunc) 0, /* nb_add */
37984 : (binaryfunc) 0, /* nb_subtract */
37985 : (binaryfunc) 0, /* nb_multiply */
37986 : #if PY_VERSION_HEX < 0x03000000
37987 : (binaryfunc) 0, /* nb_divide */
37988 : #endif
37989 : (binaryfunc) 0, /* nb_remainder */
37990 : (binaryfunc) 0, /* nb_divmod */
37991 : (ternaryfunc) 0, /* nb_power */
37992 : (unaryfunc) 0, /* nb_negative */
37993 : (unaryfunc) 0, /* nb_positive */
37994 : (unaryfunc) 0, /* nb_absolute */
37995 : (inquiry) 0, /* nb_nonzero */
37996 : (unaryfunc) 0, /* nb_invert */
37997 : (binaryfunc) 0, /* nb_lshift */
37998 : (binaryfunc) 0, /* nb_rshift */
37999 : (binaryfunc) 0, /* nb_and */
38000 : (binaryfunc) 0, /* nb_xor */
38001 : (binaryfunc) 0, /* nb_or */
38002 : #if PY_VERSION_HEX < 0x03000000
38003 : (coercion) 0, /* nb_coerce */
38004 : #endif
38005 : (unaryfunc) 0, /* nb_int */
38006 : #if PY_VERSION_HEX >= 0x03000000
38007 : (void*) 0, /* nb_reserved */
38008 : #else
38009 : (unaryfunc) 0, /* nb_long */
38010 : #endif
38011 : (unaryfunc) 0, /* nb_float */
38012 : #if PY_VERSION_HEX < 0x03000000
38013 : (unaryfunc) 0, /* nb_oct */
38014 : (unaryfunc) 0, /* nb_hex */
38015 : #endif
38016 : (binaryfunc) 0, /* nb_inplace_add */
38017 : (binaryfunc) 0, /* nb_inplace_subtract */
38018 : (binaryfunc) 0, /* nb_inplace_multiply */
38019 : #if PY_VERSION_HEX < 0x03000000
38020 : (binaryfunc) 0, /* nb_inplace_divide */
38021 : #endif
38022 : (binaryfunc) 0, /* nb_inplace_remainder */
38023 : (ternaryfunc) 0, /* nb_inplace_power */
38024 : (binaryfunc) 0, /* nb_inplace_lshift */
38025 : (binaryfunc) 0, /* nb_inplace_rshift */
38026 : (binaryfunc) 0, /* nb_inplace_and */
38027 : (binaryfunc) 0, /* nb_inplace_xor */
38028 : (binaryfunc) 0, /* nb_inplace_or */
38029 : (binaryfunc) 0, /* nb_floor_divide */
38030 : (binaryfunc) 0, /* nb_true_divide */
38031 : (binaryfunc) 0, /* nb_inplace_floor_divide */
38032 : (binaryfunc) 0, /* nb_inplace_true_divide */
38033 : #if PY_VERSION_HEX >= 0x02050000
38034 : (unaryfunc) 0, /* nb_index */
38035 : #endif
38036 : },
38037 : {
38038 : (lenfunc) 0, /* mp_length */
38039 : (binaryfunc) 0, /* mp_subscript */
38040 : (objobjargproc) 0, /* mp_ass_subscript */
38041 : },
38042 : {
38043 : (lenfunc) 0, /* sq_length */
38044 : (binaryfunc) 0, /* sq_concat */
38045 : (ssizeargfunc) 0, /* sq_repeat */
38046 : (ssizeargfunc) 0, /* sq_item */
38047 : #if PY_VERSION_HEX >= 0x03000000
38048 : (void*) 0, /* was_sq_slice */
38049 : #else
38050 : (ssizessizeargfunc) 0, /* sq_slice */
38051 : #endif
38052 : (ssizeobjargproc) 0, /* sq_ass_item */
38053 : #if PY_VERSION_HEX >= 0x03000000
38054 : (void*) 0, /* was_sq_ass_slice */
38055 : #else
38056 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
38057 : #endif
38058 : (objobjproc) 0, /* sq_contains */
38059 : (binaryfunc) 0, /* sq_inplace_concat */
38060 : (ssizeargfunc) 0, /* sq_inplace_repeat */
38061 : },
38062 : {
38063 : #if PY_VERSION_HEX < 0x03000000
38064 : (readbufferproc) 0, /* bf_getreadbuffer */
38065 : (writebufferproc) 0, /* bf_getwritebuffer */
38066 : (segcountproc) 0, /* bf_getsegcount */
38067 : (charbufferproc) 0, /* bf_getcharbuffer */
38068 : #endif
38069 : #if PY_VERSION_HEX >= 0x02060000
38070 : (getbufferproc) 0, /* bf_getbuffer */
38071 : (releasebufferproc) 0, /* bf_releasebuffer */
38072 : #endif
38073 : },
38074 : (PyObject*) 0, /* ht_name */
38075 : (PyObject*) 0, /* ht_slots */
38076 : };
38077 :
38078 : SWIGINTERN SwigPyClientData SwigPyBuiltin__gpgme_conf_arg_value_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__gpgme_conf_arg_value_type};
38079 :
38080 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_gpgme_conf_opt)
38081 : static SwigPyGetSet gpgme_conf_opt_value_getset = { _wrap_gpgme_conf_opt_value_get, _wrap_gpgme_conf_opt_value_set };
38082 : static SwigPyGetSet gpgme_conf_opt_name_getset = { _wrap_gpgme_conf_opt_name_get, _wrap_gpgme_conf_opt_name_set };
38083 : static SwigPyGetSet gpgme_conf_opt_alt_type_getset = { _wrap_gpgme_conf_opt_alt_type_get, _wrap_gpgme_conf_opt_alt_type_set };
38084 : static SwigPyGetSet gpgme_conf_opt_argname_getset = { _wrap_gpgme_conf_opt_argname_get, _wrap_gpgme_conf_opt_argname_set };
38085 : static SwigPyGetSet gpgme_conf_opt_level_getset = { _wrap_gpgme_conf_opt_level_get, _wrap_gpgme_conf_opt_level_set };
38086 : static SwigPyGetSet gpgme_conf_opt_user_data_getset = { _wrap_gpgme_conf_opt_user_data_get, _wrap_gpgme_conf_opt_user_data_set };
38087 : static SwigPyGetSet gpgme_conf_opt_flags_getset = { _wrap_gpgme_conf_opt_flags_get, _wrap_gpgme_conf_opt_flags_set };
38088 : static SwigPyGetSet gpgme_conf_opt_type_getset = { _wrap_gpgme_conf_opt_type_get, _wrap_gpgme_conf_opt_type_set };
38089 : static SwigPyGetSet gpgme_conf_opt_default_value_getset = { _wrap_gpgme_conf_opt_default_value_get, _wrap_gpgme_conf_opt_default_value_set };
38090 : static SwigPyGetSet gpgme_conf_opt_description_getset = { _wrap_gpgme_conf_opt_description_get, _wrap_gpgme_conf_opt_description_set };
38091 : static SwigPyGetSet gpgme_conf_opt_default_description_getset = { _wrap_gpgme_conf_opt_default_description_get, _wrap_gpgme_conf_opt_default_description_set };
38092 : static SwigPyGetSet gpgme_conf_opt_no_arg_description_getset = { _wrap_gpgme_conf_opt_no_arg_description_get, _wrap_gpgme_conf_opt_no_arg_description_set };
38093 : static SwigPyGetSet gpgme_conf_opt_no_arg_value_getset = { _wrap_gpgme_conf_opt_no_arg_value_get, _wrap_gpgme_conf_opt_no_arg_value_set };
38094 : static SwigPyGetSet gpgme_conf_opt_change_value_getset = { _wrap_gpgme_conf_opt_change_value_get, _wrap_gpgme_conf_opt_change_value_set };
38095 : static SwigPyGetSet gpgme_conf_opt_new_value_getset = { _wrap_gpgme_conf_opt_new_value_get, _wrap_gpgme_conf_opt_new_value_set };
38096 : SWIGINTERN PyGetSetDef SwigPyBuiltin__gpgme_conf_opt_getset[] = {
38097 : { (char*) "value", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.value", (void*) &gpgme_conf_opt_value_getset }
38098 : ,
38099 : { (char*) "name", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.name", (void*) &gpgme_conf_opt_name_getset }
38100 : ,
38101 : { (char*) "alt_type", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.alt_type", (void*) &gpgme_conf_opt_alt_type_getset }
38102 : ,
38103 : { (char*) "argname", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.argname", (void*) &gpgme_conf_opt_argname_getset }
38104 : ,
38105 : { (char*) "level", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.level", (void*) &gpgme_conf_opt_level_getset }
38106 : ,
38107 : { (char*) "user_data", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.user_data", (void*) &gpgme_conf_opt_user_data_getset }
38108 : ,
38109 : { (char*) "flags", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.flags", (void*) &gpgme_conf_opt_flags_getset }
38110 : ,
38111 : { (char*) "type", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.type", (void*) &gpgme_conf_opt_type_getset }
38112 : ,
38113 : { (char*) "default_value", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.default_value", (void*) &gpgme_conf_opt_default_value_getset }
38114 : ,
38115 : { (char*) "description", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.description", (void*) &gpgme_conf_opt_description_getset }
38116 : ,
38117 : { (char*) "default_description", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.default_description", (void*) &gpgme_conf_opt_default_description_getset }
38118 : ,
38119 : { (char*) "no_arg_description", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.no_arg_description", (void*) &gpgme_conf_opt_no_arg_description_getset }
38120 : ,
38121 : { (char*) "no_arg_value", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.no_arg_value", (void*) &gpgme_conf_opt_no_arg_value_getset }
38122 : ,
38123 : { (char*) "change_value", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.change_value", (void*) &gpgme_conf_opt_change_value_getset }
38124 : ,
38125 : { (char*) "new_value", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_opt.new_value", (void*) &gpgme_conf_opt_new_value_getset }
38126 : ,
38127 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
38128 : };
38129 :
38130 : SWIGINTERN PyObject *
38131 0 : SwigPyBuiltin__gpgme_conf_opt_richcompare(PyObject *self, PyObject *other, int op) {
38132 0 : PyObject *result = NULL;
38133 0 : PyObject *tuple = PyTuple_New(1);
38134 : assert(tuple);
38135 0 : PyTuple_SET_ITEM(tuple, 0, other);
38136 0 : Py_XINCREF(other);
38137 : if (!result) {
38138 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
38139 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
38140 : } else {
38141 0 : result = Py_NotImplemented;
38142 0 : Py_INCREF(result);
38143 : }
38144 : }
38145 0 : Py_DECREF(tuple);
38146 0 : return result;
38147 : }
38148 :
38149 : SWIGINTERN PyMethodDef SwigPyBuiltin__gpgme_conf_opt_methods[] = {
38150 : { NULL, NULL, 0, NULL } /* Sentinel */
38151 : };
38152 :
38153 : static PyHeapTypeObject SwigPyBuiltin__gpgme_conf_opt_type = {
38154 : {
38155 : #if PY_VERSION_HEX >= 0x03000000
38156 : PyVarObject_HEAD_INIT(NULL, 0)
38157 : #else
38158 : PyObject_HEAD_INIT(NULL)
38159 : 0, /* ob_size */
38160 : #endif
38161 : "gpgme_conf_opt", /* tp_name */
38162 : sizeof(SwigPyObject), /* tp_basicsize */
38163 : 0, /* tp_itemsize */
38164 : (destructor) _wrap_delete_gpgme_conf_opt_closure, /* tp_dealloc */
38165 : (printfunc) 0, /* tp_print */
38166 : (getattrfunc) 0, /* tp_getattr */
38167 : (setattrfunc) 0, /* tp_setattr */
38168 : #if PY_VERSION_HEX >= 0x03000000
38169 : 0, /* tp_compare */
38170 : #else
38171 : (cmpfunc) 0, /* tp_compare */
38172 : #endif
38173 : (reprfunc) 0, /* tp_repr */
38174 : &SwigPyBuiltin__gpgme_conf_opt_type.as_number, /* tp_as_number */
38175 : &SwigPyBuiltin__gpgme_conf_opt_type.as_sequence, /* tp_as_sequence */
38176 : &SwigPyBuiltin__gpgme_conf_opt_type.as_mapping, /* tp_as_mapping */
38177 : (hashfunc) 0, /* tp_hash */
38178 : (ternaryfunc) 0, /* tp_call */
38179 : (reprfunc) 0, /* tp_str */
38180 : (getattrofunc) 0, /* tp_getattro */
38181 : (setattrofunc) 0, /* tp_setattro */
38182 : &SwigPyBuiltin__gpgme_conf_opt_type.as_buffer, /* tp_as_buffer */
38183 : #if PY_VERSION_HEX >= 0x03000000
38184 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
38185 : #else
38186 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
38187 : #endif
38188 : "::gpgme_conf_opt", /* tp_doc */
38189 : (traverseproc) 0, /* tp_traverse */
38190 : (inquiry) 0, /* tp_clear */
38191 : (richcmpfunc) SwigPyBuiltin__gpgme_conf_opt_richcompare, /* feature:python:tp_richcompare */
38192 : 0, /* tp_weaklistoffset */
38193 : (getiterfunc) 0, /* tp_iter */
38194 : (iternextfunc) 0, /* tp_iternext */
38195 : SwigPyBuiltin__gpgme_conf_opt_methods, /* tp_methods */
38196 : 0, /* tp_members */
38197 : SwigPyBuiltin__gpgme_conf_opt_getset, /* tp_getset */
38198 : 0, /* tp_base */
38199 : 0, /* tp_dict */
38200 : (descrgetfunc) 0, /* tp_descr_get */
38201 : (descrsetfunc) 0, /* tp_descr_set */
38202 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
38203 : (initproc) _wrap_new_gpgme_conf_opt, /* tp_init */
38204 : (allocfunc) 0, /* tp_alloc */
38205 : (newfunc) 0, /* tp_new */
38206 : (freefunc) 0, /* tp_free */
38207 : (inquiry) 0, /* tp_is_gc */
38208 : (PyObject*) 0, /* tp_bases */
38209 : (PyObject*) 0, /* tp_mro */
38210 : (PyObject*) 0, /* tp_cache */
38211 : (PyObject*) 0, /* tp_subclasses */
38212 : (PyObject*) 0, /* tp_weaklist */
38213 : (destructor) 0, /* tp_del */
38214 : #if PY_VERSION_HEX >= 0x02060000
38215 : (int) 0, /* tp_version_tag */
38216 : #endif
38217 : },
38218 : {
38219 : (binaryfunc) 0, /* nb_add */
38220 : (binaryfunc) 0, /* nb_subtract */
38221 : (binaryfunc) 0, /* nb_multiply */
38222 : #if PY_VERSION_HEX < 0x03000000
38223 : (binaryfunc) 0, /* nb_divide */
38224 : #endif
38225 : (binaryfunc) 0, /* nb_remainder */
38226 : (binaryfunc) 0, /* nb_divmod */
38227 : (ternaryfunc) 0, /* nb_power */
38228 : (unaryfunc) 0, /* nb_negative */
38229 : (unaryfunc) 0, /* nb_positive */
38230 : (unaryfunc) 0, /* nb_absolute */
38231 : (inquiry) 0, /* nb_nonzero */
38232 : (unaryfunc) 0, /* nb_invert */
38233 : (binaryfunc) 0, /* nb_lshift */
38234 : (binaryfunc) 0, /* nb_rshift */
38235 : (binaryfunc) 0, /* nb_and */
38236 : (binaryfunc) 0, /* nb_xor */
38237 : (binaryfunc) 0, /* nb_or */
38238 : #if PY_VERSION_HEX < 0x03000000
38239 : (coercion) 0, /* nb_coerce */
38240 : #endif
38241 : (unaryfunc) 0, /* nb_int */
38242 : #if PY_VERSION_HEX >= 0x03000000
38243 : (void*) 0, /* nb_reserved */
38244 : #else
38245 : (unaryfunc) 0, /* nb_long */
38246 : #endif
38247 : (unaryfunc) 0, /* nb_float */
38248 : #if PY_VERSION_HEX < 0x03000000
38249 : (unaryfunc) 0, /* nb_oct */
38250 : (unaryfunc) 0, /* nb_hex */
38251 : #endif
38252 : (binaryfunc) 0, /* nb_inplace_add */
38253 : (binaryfunc) 0, /* nb_inplace_subtract */
38254 : (binaryfunc) 0, /* nb_inplace_multiply */
38255 : #if PY_VERSION_HEX < 0x03000000
38256 : (binaryfunc) 0, /* nb_inplace_divide */
38257 : #endif
38258 : (binaryfunc) 0, /* nb_inplace_remainder */
38259 : (ternaryfunc) 0, /* nb_inplace_power */
38260 : (binaryfunc) 0, /* nb_inplace_lshift */
38261 : (binaryfunc) 0, /* nb_inplace_rshift */
38262 : (binaryfunc) 0, /* nb_inplace_and */
38263 : (binaryfunc) 0, /* nb_inplace_xor */
38264 : (binaryfunc) 0, /* nb_inplace_or */
38265 : (binaryfunc) 0, /* nb_floor_divide */
38266 : (binaryfunc) 0, /* nb_true_divide */
38267 : (binaryfunc) 0, /* nb_inplace_floor_divide */
38268 : (binaryfunc) 0, /* nb_inplace_true_divide */
38269 : #if PY_VERSION_HEX >= 0x02050000
38270 : (unaryfunc) 0, /* nb_index */
38271 : #endif
38272 : },
38273 : {
38274 : (lenfunc) 0, /* mp_length */
38275 : (binaryfunc) 0, /* mp_subscript */
38276 : (objobjargproc) 0, /* mp_ass_subscript */
38277 : },
38278 : {
38279 : (lenfunc) 0, /* sq_length */
38280 : (binaryfunc) 0, /* sq_concat */
38281 : (ssizeargfunc) 0, /* sq_repeat */
38282 : (ssizeargfunc) 0, /* sq_item */
38283 : #if PY_VERSION_HEX >= 0x03000000
38284 : (void*) 0, /* was_sq_slice */
38285 : #else
38286 : (ssizessizeargfunc) 0, /* sq_slice */
38287 : #endif
38288 : (ssizeobjargproc) 0, /* sq_ass_item */
38289 : #if PY_VERSION_HEX >= 0x03000000
38290 : (void*) 0, /* was_sq_ass_slice */
38291 : #else
38292 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
38293 : #endif
38294 : (objobjproc) 0, /* sq_contains */
38295 : (binaryfunc) 0, /* sq_inplace_concat */
38296 : (ssizeargfunc) 0, /* sq_inplace_repeat */
38297 : },
38298 : {
38299 : #if PY_VERSION_HEX < 0x03000000
38300 : (readbufferproc) 0, /* bf_getreadbuffer */
38301 : (writebufferproc) 0, /* bf_getwritebuffer */
38302 : (segcountproc) 0, /* bf_getsegcount */
38303 : (charbufferproc) 0, /* bf_getcharbuffer */
38304 : #endif
38305 : #if PY_VERSION_HEX >= 0x02060000
38306 : (getbufferproc) 0, /* bf_getbuffer */
38307 : (releasebufferproc) 0, /* bf_releasebuffer */
38308 : #endif
38309 : },
38310 : (PyObject*) 0, /* ht_name */
38311 : (PyObject*) 0, /* ht_slots */
38312 : };
38313 :
38314 : SWIGINTERN SwigPyClientData SwigPyBuiltin__gpgme_conf_opt_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__gpgme_conf_opt_type};
38315 :
38316 0 : SWIGPY_DESTRUCTOR_CLOSURE(_wrap_delete_gpgme_conf_comp)
38317 : static SwigPyGetSet gpgme_conf_comp__last_opt_p_getset = { _wrap_gpgme_conf_comp__last_opt_p_get, _wrap_gpgme_conf_comp__last_opt_p_set };
38318 : static SwigPyGetSet gpgme_conf_comp_program_name_getset = { _wrap_gpgme_conf_comp_program_name_get, _wrap_gpgme_conf_comp_program_name_set };
38319 : static SwigPyGetSet gpgme_conf_comp_name_getset = { _wrap_gpgme_conf_comp_name_get, _wrap_gpgme_conf_comp_name_set };
38320 : static SwigPyGetSet gpgme_conf_comp_options_getset = { _wrap_gpgme_conf_comp_options_get, _wrap_gpgme_conf_comp_options_set };
38321 : static SwigPyGetSet gpgme_conf_comp_description_getset = { _wrap_gpgme_conf_comp_description_get, _wrap_gpgme_conf_comp_description_set };
38322 : SWIGINTERN PyGetSetDef SwigPyBuiltin__gpgme_conf_comp_getset[] = {
38323 : { (char*) "_last_opt_p", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_comp._last_opt_p", (void*) &gpgme_conf_comp__last_opt_p_getset }
38324 : ,
38325 : { (char*) "program_name", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_comp.program_name", (void*) &gpgme_conf_comp_program_name_getset }
38326 : ,
38327 : { (char*) "name", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_comp.name", (void*) &gpgme_conf_comp_name_getset }
38328 : ,
38329 : { (char*) "options", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_comp.options", (void*) &gpgme_conf_comp_options_getset }
38330 : ,
38331 : { (char*) "description", (getter) SwigPyBuiltin_GetterClosure, (setter) SwigPyBuiltin_SetterClosure, (char*)"gpgme_conf_comp.description", (void*) &gpgme_conf_comp_description_getset }
38332 : ,
38333 : {NULL, NULL, NULL, NULL, NULL} /* Sentinel */
38334 : };
38335 :
38336 : SWIGINTERN PyObject *
38337 0 : SwigPyBuiltin__gpgme_conf_comp_richcompare(PyObject *self, PyObject *other, int op) {
38338 0 : PyObject *result = NULL;
38339 0 : PyObject *tuple = PyTuple_New(1);
38340 : assert(tuple);
38341 0 : PyTuple_SET_ITEM(tuple, 0, other);
38342 0 : Py_XINCREF(other);
38343 : if (!result) {
38344 0 : if (SwigPyObject_Check(self) && SwigPyObject_Check(other)) {
38345 0 : result = SwigPyObject_richcompare((SwigPyObject *)self, (SwigPyObject *)other, op);
38346 : } else {
38347 0 : result = Py_NotImplemented;
38348 0 : Py_INCREF(result);
38349 : }
38350 : }
38351 0 : Py_DECREF(tuple);
38352 0 : return result;
38353 : }
38354 :
38355 : SWIGINTERN PyMethodDef SwigPyBuiltin__gpgme_conf_comp_methods[] = {
38356 : { NULL, NULL, 0, NULL } /* Sentinel */
38357 : };
38358 :
38359 : static PyHeapTypeObject SwigPyBuiltin__gpgme_conf_comp_type = {
38360 : {
38361 : #if PY_VERSION_HEX >= 0x03000000
38362 : PyVarObject_HEAD_INIT(NULL, 0)
38363 : #else
38364 : PyObject_HEAD_INIT(NULL)
38365 : 0, /* ob_size */
38366 : #endif
38367 : "gpgme_conf_comp", /* tp_name */
38368 : sizeof(SwigPyObject), /* tp_basicsize */
38369 : 0, /* tp_itemsize */
38370 : (destructor) _wrap_delete_gpgme_conf_comp_closure, /* tp_dealloc */
38371 : (printfunc) 0, /* tp_print */
38372 : (getattrfunc) 0, /* tp_getattr */
38373 : (setattrfunc) 0, /* tp_setattr */
38374 : #if PY_VERSION_HEX >= 0x03000000
38375 : 0, /* tp_compare */
38376 : #else
38377 : (cmpfunc) 0, /* tp_compare */
38378 : #endif
38379 : (reprfunc) 0, /* tp_repr */
38380 : &SwigPyBuiltin__gpgme_conf_comp_type.as_number, /* tp_as_number */
38381 : &SwigPyBuiltin__gpgme_conf_comp_type.as_sequence, /* tp_as_sequence */
38382 : &SwigPyBuiltin__gpgme_conf_comp_type.as_mapping, /* tp_as_mapping */
38383 : (hashfunc) 0, /* tp_hash */
38384 : (ternaryfunc) 0, /* tp_call */
38385 : (reprfunc) 0, /* tp_str */
38386 : (getattrofunc) 0, /* tp_getattro */
38387 : (setattrofunc) 0, /* tp_setattro */
38388 : &SwigPyBuiltin__gpgme_conf_comp_type.as_buffer, /* tp_as_buffer */
38389 : #if PY_VERSION_HEX >= 0x03000000
38390 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
38391 : #else
38392 : Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES, /* tp_flags */
38393 : #endif
38394 : "::gpgme_conf_comp", /* tp_doc */
38395 : (traverseproc) 0, /* tp_traverse */
38396 : (inquiry) 0, /* tp_clear */
38397 : (richcmpfunc) SwigPyBuiltin__gpgme_conf_comp_richcompare, /* feature:python:tp_richcompare */
38398 : 0, /* tp_weaklistoffset */
38399 : (getiterfunc) 0, /* tp_iter */
38400 : (iternextfunc) 0, /* tp_iternext */
38401 : SwigPyBuiltin__gpgme_conf_comp_methods, /* tp_methods */
38402 : 0, /* tp_members */
38403 : SwigPyBuiltin__gpgme_conf_comp_getset, /* tp_getset */
38404 : 0, /* tp_base */
38405 : 0, /* tp_dict */
38406 : (descrgetfunc) 0, /* tp_descr_get */
38407 : (descrsetfunc) 0, /* tp_descr_set */
38408 : (Py_ssize_t)offsetof(SwigPyObject, dict), /* tp_dictoffset */
38409 : (initproc) _wrap_new_gpgme_conf_comp, /* tp_init */
38410 : (allocfunc) 0, /* tp_alloc */
38411 : (newfunc) 0, /* tp_new */
38412 : (freefunc) 0, /* tp_free */
38413 : (inquiry) 0, /* tp_is_gc */
38414 : (PyObject*) 0, /* tp_bases */
38415 : (PyObject*) 0, /* tp_mro */
38416 : (PyObject*) 0, /* tp_cache */
38417 : (PyObject*) 0, /* tp_subclasses */
38418 : (PyObject*) 0, /* tp_weaklist */
38419 : (destructor) 0, /* tp_del */
38420 : #if PY_VERSION_HEX >= 0x02060000
38421 : (int) 0, /* tp_version_tag */
38422 : #endif
38423 : },
38424 : {
38425 : (binaryfunc) 0, /* nb_add */
38426 : (binaryfunc) 0, /* nb_subtract */
38427 : (binaryfunc) 0, /* nb_multiply */
38428 : #if PY_VERSION_HEX < 0x03000000
38429 : (binaryfunc) 0, /* nb_divide */
38430 : #endif
38431 : (binaryfunc) 0, /* nb_remainder */
38432 : (binaryfunc) 0, /* nb_divmod */
38433 : (ternaryfunc) 0, /* nb_power */
38434 : (unaryfunc) 0, /* nb_negative */
38435 : (unaryfunc) 0, /* nb_positive */
38436 : (unaryfunc) 0, /* nb_absolute */
38437 : (inquiry) 0, /* nb_nonzero */
38438 : (unaryfunc) 0, /* nb_invert */
38439 : (binaryfunc) 0, /* nb_lshift */
38440 : (binaryfunc) 0, /* nb_rshift */
38441 : (binaryfunc) 0, /* nb_and */
38442 : (binaryfunc) 0, /* nb_xor */
38443 : (binaryfunc) 0, /* nb_or */
38444 : #if PY_VERSION_HEX < 0x03000000
38445 : (coercion) 0, /* nb_coerce */
38446 : #endif
38447 : (unaryfunc) 0, /* nb_int */
38448 : #if PY_VERSION_HEX >= 0x03000000
38449 : (void*) 0, /* nb_reserved */
38450 : #else
38451 : (unaryfunc) 0, /* nb_long */
38452 : #endif
38453 : (unaryfunc) 0, /* nb_float */
38454 : #if PY_VERSION_HEX < 0x03000000
38455 : (unaryfunc) 0, /* nb_oct */
38456 : (unaryfunc) 0, /* nb_hex */
38457 : #endif
38458 : (binaryfunc) 0, /* nb_inplace_add */
38459 : (binaryfunc) 0, /* nb_inplace_subtract */
38460 : (binaryfunc) 0, /* nb_inplace_multiply */
38461 : #if PY_VERSION_HEX < 0x03000000
38462 : (binaryfunc) 0, /* nb_inplace_divide */
38463 : #endif
38464 : (binaryfunc) 0, /* nb_inplace_remainder */
38465 : (ternaryfunc) 0, /* nb_inplace_power */
38466 : (binaryfunc) 0, /* nb_inplace_lshift */
38467 : (binaryfunc) 0, /* nb_inplace_rshift */
38468 : (binaryfunc) 0, /* nb_inplace_and */
38469 : (binaryfunc) 0, /* nb_inplace_xor */
38470 : (binaryfunc) 0, /* nb_inplace_or */
38471 : (binaryfunc) 0, /* nb_floor_divide */
38472 : (binaryfunc) 0, /* nb_true_divide */
38473 : (binaryfunc) 0, /* nb_inplace_floor_divide */
38474 : (binaryfunc) 0, /* nb_inplace_true_divide */
38475 : #if PY_VERSION_HEX >= 0x02050000
38476 : (unaryfunc) 0, /* nb_index */
38477 : #endif
38478 : },
38479 : {
38480 : (lenfunc) 0, /* mp_length */
38481 : (binaryfunc) 0, /* mp_subscript */
38482 : (objobjargproc) 0, /* mp_ass_subscript */
38483 : },
38484 : {
38485 : (lenfunc) 0, /* sq_length */
38486 : (binaryfunc) 0, /* sq_concat */
38487 : (ssizeargfunc) 0, /* sq_repeat */
38488 : (ssizeargfunc) 0, /* sq_item */
38489 : #if PY_VERSION_HEX >= 0x03000000
38490 : (void*) 0, /* was_sq_slice */
38491 : #else
38492 : (ssizessizeargfunc) 0, /* sq_slice */
38493 : #endif
38494 : (ssizeobjargproc) 0, /* sq_ass_item */
38495 : #if PY_VERSION_HEX >= 0x03000000
38496 : (void*) 0, /* was_sq_ass_slice */
38497 : #else
38498 : (ssizessizeobjargproc) 0, /* sq_ass_slice */
38499 : #endif
38500 : (objobjproc) 0, /* sq_contains */
38501 : (binaryfunc) 0, /* sq_inplace_concat */
38502 : (ssizeargfunc) 0, /* sq_inplace_repeat */
38503 : },
38504 : {
38505 : #if PY_VERSION_HEX < 0x03000000
38506 : (readbufferproc) 0, /* bf_getreadbuffer */
38507 : (writebufferproc) 0, /* bf_getwritebuffer */
38508 : (segcountproc) 0, /* bf_getsegcount */
38509 : (charbufferproc) 0, /* bf_getcharbuffer */
38510 : #endif
38511 : #if PY_VERSION_HEX >= 0x02060000
38512 : (getbufferproc) 0, /* bf_getbuffer */
38513 : (releasebufferproc) 0, /* bf_releasebuffer */
38514 : #endif
38515 : },
38516 : (PyObject*) 0, /* ht_name */
38517 : (PyObject*) 0, /* ht_slots */
38518 : };
38519 :
38520 : SWIGINTERN SwigPyClientData SwigPyBuiltin__gpgme_conf_comp_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject *)&SwigPyBuiltin__gpgme_conf_comp_type};
38521 :
38522 :
38523 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
38524 :
38525 : static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
38526 : static swig_type_info _swigt__p_SwigPyObject = {"_p_SwigPyObject", "SwigPyObject *", 0, 0, (void*)0, 0};
38527 : static swig_type_info _swigt__p__gpgme_attr_t = {"_p__gpgme_attr_t", "enum _gpgme_attr_t *|_gpgme_attr_t *", 0, 0, (void*)0, 0};
38528 : static swig_type_info _swigt__p__gpgme_engine_info = {"_p__gpgme_engine_info", "struct _gpgme_engine_info *|_gpgme_engine_info *|gpgme_engine_info_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_engine_info_clientdata, 0};
38529 : static swig_type_info _swigt__p__gpgme_import_status = {"_p__gpgme_import_status", "gpgme_import_status_t|struct _gpgme_import_status *|_gpgme_import_status *", 0, 0, (void*)&SwigPyBuiltin___gpgme_import_status_clientdata, 0};
38530 : static swig_type_info _swigt__p__gpgme_invalid_key = {"_p__gpgme_invalid_key", "struct _gpgme_invalid_key *|_gpgme_invalid_key *|gpgme_invalid_key_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_invalid_key_clientdata, 0};
38531 : static swig_type_info _swigt__p__gpgme_key = {"_p__gpgme_key", "struct _gpgme_key *|_gpgme_key *|gpgme_key_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_key_clientdata, 0};
38532 : static swig_type_info _swigt__p__gpgme_key_sig = {"_p__gpgme_key_sig", "struct _gpgme_key_sig *|_gpgme_key_sig *|gpgme_key_sig_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_key_sig_clientdata, 0};
38533 : static swig_type_info _swigt__p__gpgme_new_signature = {"_p__gpgme_new_signature", "struct _gpgme_new_signature *|_gpgme_new_signature *|gpgme_new_signature_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_new_signature_clientdata, 0};
38534 : static swig_type_info _swigt__p__gpgme_op_assuan_result = {"_p__gpgme_op_assuan_result", "struct _gpgme_op_assuan_result *|_gpgme_op_assuan_result *", 0, 0, (void*)&SwigPyBuiltin___gpgme_op_assuan_result_clientdata, 0};
38535 : static swig_type_info _swigt__p__gpgme_op_decrypt_result = {"_p__gpgme_op_decrypt_result", "struct _gpgme_op_decrypt_result *|_gpgme_op_decrypt_result *|gpgme_decrypt_result_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_op_decrypt_result_clientdata, 0};
38536 : static swig_type_info _swigt__p__gpgme_op_encrypt_result = {"_p__gpgme_op_encrypt_result", "struct _gpgme_op_encrypt_result *|_gpgme_op_encrypt_result *|gpgme_encrypt_result_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_op_encrypt_result_clientdata, 0};
38537 : static swig_type_info _swigt__p__gpgme_op_genkey_result = {"_p__gpgme_op_genkey_result", "struct _gpgme_op_genkey_result *|_gpgme_op_genkey_result *|gpgme_genkey_result_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_op_genkey_result_clientdata, 0};
38538 : static swig_type_info _swigt__p__gpgme_op_import_result = {"_p__gpgme_op_import_result", "struct _gpgme_op_import_result *|_gpgme_op_import_result *|gpgme_import_result_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_op_import_result_clientdata, 0};
38539 : static swig_type_info _swigt__p__gpgme_op_keylist_result = {"_p__gpgme_op_keylist_result", "struct _gpgme_op_keylist_result *|_gpgme_op_keylist_result *|gpgme_keylist_result_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_op_keylist_result_clientdata, 0};
38540 : static swig_type_info _swigt__p__gpgme_op_sign_result = {"_p__gpgme_op_sign_result", "struct _gpgme_op_sign_result *|_gpgme_op_sign_result *|gpgme_sign_result_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_op_sign_result_clientdata, 0};
38541 : static swig_type_info _swigt__p__gpgme_op_verify_result = {"_p__gpgme_op_verify_result", "struct _gpgme_op_verify_result *|_gpgme_op_verify_result *|gpgme_verify_result_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_op_verify_result_clientdata, 0};
38542 : static swig_type_info _swigt__p__gpgme_op_vfs_mount_result = {"_p__gpgme_op_vfs_mount_result", "struct _gpgme_op_vfs_mount_result *|_gpgme_op_vfs_mount_result *|gpgme_vfs_mount_result_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_op_vfs_mount_result_clientdata, 0};
38543 : static swig_type_info _swigt__p__gpgme_recipient = {"_p__gpgme_recipient", "gpgme_recipient_t|struct _gpgme_recipient *|_gpgme_recipient *", 0, 0, (void*)&SwigPyBuiltin___gpgme_recipient_clientdata, 0};
38544 : static swig_type_info _swigt__p__gpgme_sig_notation = {"_p__gpgme_sig_notation", "struct _gpgme_sig_notation *|_gpgme_sig_notation *|gpgme_sig_notation_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_sig_notation_clientdata, 0};
38545 : static swig_type_info _swigt__p__gpgme_sig_stat_t = {"_p__gpgme_sig_stat_t", "enum _gpgme_sig_stat_t *|_gpgme_sig_stat_t *", 0, 0, (void*)0, 0};
38546 : static swig_type_info _swigt__p__gpgme_signature = {"_p__gpgme_signature", "struct _gpgme_signature *|_gpgme_signature *|gpgme_signature_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_signature_clientdata, 0};
38547 : static swig_type_info _swigt__p__gpgme_subkey = {"_p__gpgme_subkey", "struct _gpgme_subkey *|_gpgme_subkey *|gpgme_subkey_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_subkey_clientdata, 0};
38548 : static swig_type_info _swigt__p__gpgme_tofu_info = {"_p__gpgme_tofu_info", "struct _gpgme_tofu_info *|_gpgme_tofu_info *|gpgme_tofu_info_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_tofu_info_clientdata, 0};
38549 : static swig_type_info _swigt__p__gpgme_trust_item = {"_p__gpgme_trust_item", "gpgme_trust_item_t|struct _gpgme_trust_item *|_gpgme_trust_item *", 0, 0, (void*)&SwigPyBuiltin___gpgme_trust_item_clientdata, 0};
38550 : static swig_type_info _swigt__p__gpgme_user_id = {"_p__gpgme_user_id", "struct _gpgme_user_id *|_gpgme_user_id *|gpgme_user_id_t", 0, 0, (void*)&SwigPyBuiltin___gpgme_user_id_clientdata, 0};
38551 : static swig_type_info _swigt__p_a___p__gpgme_key = {"_p_a___p__gpgme_key", "gpgme_key_t (*)[]|struct _gpgme_key *(*)[]", 0, 0, (void*)0, 0};
38552 : static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
38553 : static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "gpgme_remove_io_cb_t|void (*)(void *)|gpgme_data_release_cb_t", 0, 0, (void*)0, 0};
38554 : static swig_type_info _swigt__p_f_p_void_enum_gpgme_event_io_t_p_void__void = {"_p_f_p_void_enum_gpgme_event_io_t_p_void__void", "gpgme_event_io_cb_t|void (*)(void *,enum gpgme_event_io_t,void *)", 0, 0, (void*)0, 0};
38555 : static swig_type_info _swigt__p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t = {"_p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t", "gpgme_edit_cb_t|gpg_error_t (*)(void *,enum gpgme_status_code_t,char const *,int)", 0, 0, (void*)0, 0};
38556 : static swig_type_info _swigt__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t = {"_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t", "gpg_error_t (*)(void *,int,int,gpg_error_t (*)(void *,int),void *,void **)|gpgme_register_io_cb_t", 0, 0, (void*)0, 0};
38557 : static swig_type_info _swigt__p_f_p_void_off_t_int__off_t = {"_p_f_p_void_off_t_int__off_t", "off_t (*)(void *,off_t,int)|gpgme_data_seek_cb_t", 0, 0, (void*)0, 0};
38558 : static swig_type_info _swigt__p_f_p_void_p_q_const__char_int_int_int__void = {"_p_f_p_void_p_q_const__char_int_int_int__void", "void (*)(void *,char const *,int,int,int)|gpgme_progress_cb_t", 0, 0, (void*)0, 0};
38559 : static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t", "gpg_error_t (*)(void *,char const *,char const *)|gpgme_status_cb_t|gpgme_assuan_status_cb_t", 0, 0, (void*)0, 0};
38560 : static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t", "gpg_error_t (*)(void *,char const *,char const *,int,int)|gpgme_passphrase_cb_t", 0, 0, (void*)0, 0};
38561 : static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t", "gpg_error_t (*)(void *,char const *,char const *,struct gpgme_data **)|gpgme_assuan_inquire_cb_t", 0, 0, (void*)0, 0};
38562 : static swig_type_info _swigt__p_f_p_void_p_q_const__void_size_t__gpg_error_t = {"_p_f_p_void_p_q_const__void_size_t__gpg_error_t", "gpg_error_t (*)(void *,void const *,size_t)|gpgme_assuan_data_cb_t", 0, 0, (void*)0, 0};
38563 : static swig_type_info _swigt__p_f_p_void_p_q_const__void_size_t__ssize_t = {"_p_f_p_void_p_q_const__void_size_t__ssize_t", "ssize_t (*)(void *,void const *,size_t)|gpgme_data_write_cb_t", 0, 0, (void*)0, 0};
38564 : static swig_type_info _swigt__p_f_p_void_p_void_size_t__ssize_t = {"_p_f_p_void_p_void_size_t__ssize_t", "ssize_t (*)(void *,void *,size_t)|gpgme_data_read_cb_t", 0, 0, (void*)0, 0};
38565 : static swig_type_info _swigt__p_gpg_err_code_t = {"_p_gpg_err_code_t", "gpg_err_code_t *|gpgme_err_code_t *", 0, 0, (void*)0, 0};
38566 : static swig_type_info _swigt__p_gpg_err_source_t = {"_p_gpg_err_source_t", "gpg_err_source_t *|gpgme_err_source_t *", 0, 0, (void*)0, 0};
38567 : static swig_type_info _swigt__p_gpg_error_t = {"_p_gpg_error_t", "gpg_error_t *|gpgme_error_t *", 0, 0, (void*)0, 0};
38568 : static swig_type_info _swigt__p_gpgme_conf_arg = {"_p_gpgme_conf_arg", "struct gpgme_conf_arg *|gpgme_conf_arg *|gpgme_conf_arg_t", 0, 0, (void*)&SwigPyBuiltin__gpgme_conf_arg_clientdata, 0};
38569 : static swig_type_info _swigt__p_gpgme_conf_arg_value = {"_p_gpgme_conf_arg_value", "gpgme_conf_arg_value *", 0, 0, (void*)&SwigPyBuiltin__gpgme_conf_arg_value_clientdata, 0};
38570 : static swig_type_info _swigt__p_gpgme_conf_comp = {"_p_gpgme_conf_comp", "struct gpgme_conf_comp *|gpgme_conf_comp *|gpgme_conf_comp_t", 0, 0, (void*)&SwigPyBuiltin__gpgme_conf_comp_clientdata, 0};
38571 : static swig_type_info _swigt__p_gpgme_conf_level_t = {"_p_gpgme_conf_level_t", "enum gpgme_conf_level_t *|gpgme_conf_level_t *", 0, 0, (void*)0, 0};
38572 : static swig_type_info _swigt__p_gpgme_conf_opt = {"_p_gpgme_conf_opt", "gpgme_conf_opt_t|struct gpgme_conf_opt *|gpgme_conf_opt *", 0, 0, (void*)&SwigPyBuiltin__gpgme_conf_opt_clientdata, 0};
38573 : static swig_type_info _swigt__p_gpgme_conf_type_t = {"_p_gpgme_conf_type_t", "enum gpgme_conf_type_t *|gpgme_conf_type_t *", 0, 0, (void*)0, 0};
38574 : static swig_type_info _swigt__p_gpgme_context = {"_p_gpgme_context", "gpgme_ctx_t|struct gpgme_context *", 0, 0, (void*)0, 0};
38575 : static swig_type_info _swigt__p_gpgme_data = {"_p_gpgme_data", "struct gpgme_data *|gpgme_data_t", 0, 0, (void*)0, 0};
38576 : static swig_type_info _swigt__p_gpgme_data_cbs = {"_p_gpgme_data_cbs", "gpgme_data_cbs_t|struct gpgme_data_cbs *|gpgme_data_cbs *", 0, 0, (void*)&SwigPyBuiltin__gpgme_data_cbs_clientdata, 0};
38577 : static swig_type_info _swigt__p_gpgme_data_encoding_t = {"_p_gpgme_data_encoding_t", "enum gpgme_data_encoding_t *|gpgme_data_encoding_t *", 0, 0, (void*)0, 0};
38578 : static swig_type_info _swigt__p_gpgme_data_type_t = {"_p_gpgme_data_type_t", "enum gpgme_data_type_t *|gpgme_data_type_t *", 0, 0, (void*)0, 0};
38579 : static swig_type_info _swigt__p_gpgme_encrypt_flags_t = {"_p_gpgme_encrypt_flags_t", "enum gpgme_encrypt_flags_t *|gpgme_encrypt_flags_t *", 0, 0, (void*)0, 0};
38580 : static swig_type_info _swigt__p_gpgme_event_io_t = {"_p_gpgme_event_io_t", "enum gpgme_event_io_t *|gpgme_event_io_t *", 0, 0, (void*)0, 0};
38581 : static swig_type_info _swigt__p_gpgme_hash_algo_t = {"_p_gpgme_hash_algo_t", "enum gpgme_hash_algo_t *|gpgme_hash_algo_t *", 0, 0, (void*)0, 0};
38582 : static swig_type_info _swigt__p_gpgme_io_cbs = {"_p_gpgme_io_cbs", "gpgme_io_cbs_t|struct gpgme_io_cbs *|gpgme_io_cbs *", 0, 0, (void*)&SwigPyBuiltin__gpgme_io_cbs_clientdata, 0};
38583 : static swig_type_info _swigt__p_gpgme_io_event_done_data = {"_p_gpgme_io_event_done_data", "struct gpgme_io_event_done_data *|gpgme_io_event_done_data *", 0, 0, (void*)&SwigPyBuiltin__gpgme_io_event_done_data_clientdata, 0};
38584 : static swig_type_info _swigt__p_gpgme_pinentry_mode_t = {"_p_gpgme_pinentry_mode_t", "enum gpgme_pinentry_mode_t *|gpgme_pinentry_mode_t *", 0, 0, (void*)0, 0};
38585 : static swig_type_info _swigt__p_gpgme_protocol_t = {"_p_gpgme_protocol_t", "enum gpgme_protocol_t *|gpgme_protocol_t *", 0, 0, (void*)0, 0};
38586 : static swig_type_info _swigt__p_gpgme_pubkey_algo_t = {"_p_gpgme_pubkey_algo_t", "enum gpgme_pubkey_algo_t *|gpgme_pubkey_algo_t *", 0, 0, (void*)0, 0};
38587 : static swig_type_info _swigt__p_gpgme_sig_mode_t = {"_p_gpgme_sig_mode_t", "enum gpgme_sig_mode_t *|gpgme_sig_mode_t *", 0, 0, (void*)0, 0};
38588 : static swig_type_info _swigt__p_gpgme_sigsum_t = {"_p_gpgme_sigsum_t", "enum gpgme_sigsum_t *|gpgme_sigsum_t *", 0, 0, (void*)0, 0};
38589 : static swig_type_info _swigt__p_gpgme_status_code_t = {"_p_gpgme_status_code_t", "enum gpgme_status_code_t *|gpgme_status_code_t *", 0, 0, (void*)0, 0};
38590 : static swig_type_info _swigt__p_gpgme_tofu_policy_t = {"_p_gpgme_tofu_policy_t", "enum gpgme_tofu_policy_t *|gpgme_tofu_policy_t *", 0, 0, (void*)0, 0};
38591 : static swig_type_info _swigt__p_gpgme_validity_t = {"_p_gpgme_validity_t", "enum gpgme_validity_t *|gpgme_validity_t *", 0, 0, (void*)0, 0};
38592 : static swig_type_info _swigt__p_off_t = {"_p_off_t", "off_t *|gpgme_off_t *", 0, 0, (void*)0, 0};
38593 : static swig_type_info _swigt__p_p__gpgme_engine_info = {"_p_p__gpgme_engine_info", "struct _gpgme_engine_info **|gpgme_engine_info_t *", 0, 0, (void*)0, 0};
38594 : static swig_type_info _swigt__p_p__gpgme_key = {"_p_p__gpgme_key", "struct _gpgme_key **|gpgme_key_t *", 0, 0, (void*)0, 0};
38595 : static swig_type_info _swigt__p_p__gpgme_trust_item = {"_p_p__gpgme_trust_item", "struct _gpgme_trust_item **|gpgme_trust_item_t *", 0, 0, (void*)0, 0};
38596 : static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
38597 : static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_int_int_int__void = {"_p_p_f_p_void_p_q_const__char_int_int_int__void", "void (**)(void *,char const *,int,int,int)|gpgme_progress_cb_t *", 0, 0, (void*)0, 0};
38598 : static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t = {"_p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t", "gpg_error_t (**)(void *,char const *,char const *)|gpgme_status_cb_t *", 0, 0, (void*)0, 0};
38599 : static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t = {"_p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t", "gpg_error_t (**)(void *,char const *,char const *,int,int)|gpgme_passphrase_cb_t *", 0, 0, (void*)0, 0};
38600 : static swig_type_info _swigt__p_p_gpgme_conf_arg = {"_p_p_gpgme_conf_arg", "gpgme_conf_arg_t *|struct gpgme_conf_arg **", 0, 0, (void*)0, 0};
38601 : static swig_type_info _swigt__p_p_gpgme_conf_comp = {"_p_p_gpgme_conf_comp", "struct gpgme_conf_comp **|gpgme_conf_comp_t *", 0, 0, (void*)0, 0};
38602 : static swig_type_info _swigt__p_p_gpgme_conf_opt = {"_p_p_gpgme_conf_opt", "struct gpgme_conf_opt **|gpgme_conf_opt_t *", 0, 0, (void*)0, 0};
38603 : static swig_type_info _swigt__p_p_gpgme_context = {"_p_p_gpgme_context", "gpgme_ctx_t *|struct gpgme_context **", 0, 0, (void*)0, 0};
38604 : static swig_type_info _swigt__p_p_gpgme_data = {"_p_p_gpgme_data", "gpgme_data_t *|struct gpgme_data **", 0, 0, (void*)0, 0};
38605 : static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
38606 : static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
38607 : static swig_type_info _swigt__p_ssize_t = {"_p_ssize_t", "ssize_t *|gpgme_ssize_t *", 0, 0, (void*)0, 0};
38608 : static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|gpgme_sig_notation_flags_t *|gpgme_keylist_mode_t *|gpgme_export_mode_t *", 0, 0, (void*)0, 0};
38609 : static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
38610 :
38611 : static swig_type_info *swig_type_initial[] = {
38612 : &_swigt__p_FILE,
38613 : &_swigt__p_SwigPyObject,
38614 : &_swigt__p__gpgme_attr_t,
38615 : &_swigt__p__gpgme_engine_info,
38616 : &_swigt__p__gpgme_import_status,
38617 : &_swigt__p__gpgme_invalid_key,
38618 : &_swigt__p__gpgme_key,
38619 : &_swigt__p__gpgme_key_sig,
38620 : &_swigt__p__gpgme_new_signature,
38621 : &_swigt__p__gpgme_op_assuan_result,
38622 : &_swigt__p__gpgme_op_decrypt_result,
38623 : &_swigt__p__gpgme_op_encrypt_result,
38624 : &_swigt__p__gpgme_op_genkey_result,
38625 : &_swigt__p__gpgme_op_import_result,
38626 : &_swigt__p__gpgme_op_keylist_result,
38627 : &_swigt__p__gpgme_op_sign_result,
38628 : &_swigt__p__gpgme_op_verify_result,
38629 : &_swigt__p__gpgme_op_vfs_mount_result,
38630 : &_swigt__p__gpgme_recipient,
38631 : &_swigt__p__gpgme_sig_notation,
38632 : &_swigt__p__gpgme_sig_stat_t,
38633 : &_swigt__p__gpgme_signature,
38634 : &_swigt__p__gpgme_subkey,
38635 : &_swigt__p__gpgme_tofu_info,
38636 : &_swigt__p__gpgme_trust_item,
38637 : &_swigt__p__gpgme_user_id,
38638 : &_swigt__p_a___p__gpgme_key,
38639 : &_swigt__p_char,
38640 : &_swigt__p_f_p_void__void,
38641 : &_swigt__p_f_p_void_enum_gpgme_event_io_t_p_void__void,
38642 : &_swigt__p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t,
38643 : &_swigt__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t,
38644 : &_swigt__p_f_p_void_off_t_int__off_t,
38645 : &_swigt__p_f_p_void_p_q_const__char_int_int_int__void,
38646 : &_swigt__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
38647 : &_swigt__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
38648 : &_swigt__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t,
38649 : &_swigt__p_f_p_void_p_q_const__void_size_t__gpg_error_t,
38650 : &_swigt__p_f_p_void_p_q_const__void_size_t__ssize_t,
38651 : &_swigt__p_f_p_void_p_void_size_t__ssize_t,
38652 : &_swigt__p_gpg_err_code_t,
38653 : &_swigt__p_gpg_err_source_t,
38654 : &_swigt__p_gpg_error_t,
38655 : &_swigt__p_gpgme_conf_arg,
38656 : &_swigt__p_gpgme_conf_arg_value,
38657 : &_swigt__p_gpgme_conf_comp,
38658 : &_swigt__p_gpgme_conf_level_t,
38659 : &_swigt__p_gpgme_conf_opt,
38660 : &_swigt__p_gpgme_conf_type_t,
38661 : &_swigt__p_gpgme_context,
38662 : &_swigt__p_gpgme_data,
38663 : &_swigt__p_gpgme_data_cbs,
38664 : &_swigt__p_gpgme_data_encoding_t,
38665 : &_swigt__p_gpgme_data_type_t,
38666 : &_swigt__p_gpgme_encrypt_flags_t,
38667 : &_swigt__p_gpgme_event_io_t,
38668 : &_swigt__p_gpgme_hash_algo_t,
38669 : &_swigt__p_gpgme_io_cbs,
38670 : &_swigt__p_gpgme_io_event_done_data,
38671 : &_swigt__p_gpgme_pinentry_mode_t,
38672 : &_swigt__p_gpgme_protocol_t,
38673 : &_swigt__p_gpgme_pubkey_algo_t,
38674 : &_swigt__p_gpgme_sig_mode_t,
38675 : &_swigt__p_gpgme_sigsum_t,
38676 : &_swigt__p_gpgme_status_code_t,
38677 : &_swigt__p_gpgme_tofu_policy_t,
38678 : &_swigt__p_gpgme_validity_t,
38679 : &_swigt__p_off_t,
38680 : &_swigt__p_p__gpgme_engine_info,
38681 : &_swigt__p_p__gpgme_key,
38682 : &_swigt__p_p__gpgme_trust_item,
38683 : &_swigt__p_p_char,
38684 : &_swigt__p_p_f_p_void_p_q_const__char_int_int_int__void,
38685 : &_swigt__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
38686 : &_swigt__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
38687 : &_swigt__p_p_gpgme_conf_arg,
38688 : &_swigt__p_p_gpgme_conf_comp,
38689 : &_swigt__p_p_gpgme_conf_opt,
38690 : &_swigt__p_p_gpgme_context,
38691 : &_swigt__p_p_gpgme_data,
38692 : &_swigt__p_p_void,
38693 : &_swigt__p_size_t,
38694 : &_swigt__p_ssize_t,
38695 : &_swigt__p_unsigned_int,
38696 : &_swigt__p_void,
38697 : };
38698 :
38699 : static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
38700 : static swig_cast_info _swigc__p_SwigPyObject[] = { {&_swigt__p_SwigPyObject, 0, 0, 0},{0, 0, 0, 0}};
38701 : static swig_cast_info _swigc__p__gpgme_attr_t[] = { {&_swigt__p__gpgme_attr_t, 0, 0, 0},{0, 0, 0, 0}};
38702 : static swig_cast_info _swigc__p__gpgme_engine_info[] = { {&_swigt__p__gpgme_engine_info, 0, 0, 0},{0, 0, 0, 0}};
38703 : static swig_cast_info _swigc__p__gpgme_import_status[] = { {&_swigt__p__gpgme_import_status, 0, 0, 0},{0, 0, 0, 0}};
38704 : static swig_cast_info _swigc__p__gpgme_invalid_key[] = { {&_swigt__p__gpgme_invalid_key, 0, 0, 0},{0, 0, 0, 0}};
38705 : static swig_cast_info _swigc__p__gpgme_key[] = { {&_swigt__p__gpgme_key, 0, 0, 0},{0, 0, 0, 0}};
38706 : static swig_cast_info _swigc__p__gpgme_key_sig[] = { {&_swigt__p__gpgme_key_sig, 0, 0, 0},{0, 0, 0, 0}};
38707 : static swig_cast_info _swigc__p__gpgme_new_signature[] = { {&_swigt__p__gpgme_new_signature, 0, 0, 0},{0, 0, 0, 0}};
38708 : static swig_cast_info _swigc__p__gpgme_op_assuan_result[] = { {&_swigt__p__gpgme_op_assuan_result, 0, 0, 0},{0, 0, 0, 0}};
38709 : static swig_cast_info _swigc__p__gpgme_op_decrypt_result[] = { {&_swigt__p__gpgme_op_decrypt_result, 0, 0, 0},{0, 0, 0, 0}};
38710 : static swig_cast_info _swigc__p__gpgme_op_encrypt_result[] = { {&_swigt__p__gpgme_op_encrypt_result, 0, 0, 0},{0, 0, 0, 0}};
38711 : static swig_cast_info _swigc__p__gpgme_op_genkey_result[] = { {&_swigt__p__gpgme_op_genkey_result, 0, 0, 0},{0, 0, 0, 0}};
38712 : static swig_cast_info _swigc__p__gpgme_op_import_result[] = { {&_swigt__p__gpgme_op_import_result, 0, 0, 0},{0, 0, 0, 0}};
38713 : static swig_cast_info _swigc__p__gpgme_op_keylist_result[] = { {&_swigt__p__gpgme_op_keylist_result, 0, 0, 0},{0, 0, 0, 0}};
38714 : static swig_cast_info _swigc__p__gpgme_op_sign_result[] = { {&_swigt__p__gpgme_op_sign_result, 0, 0, 0},{0, 0, 0, 0}};
38715 : static swig_cast_info _swigc__p__gpgme_op_verify_result[] = { {&_swigt__p__gpgme_op_verify_result, 0, 0, 0},{0, 0, 0, 0}};
38716 : static swig_cast_info _swigc__p__gpgme_op_vfs_mount_result[] = { {&_swigt__p__gpgme_op_vfs_mount_result, 0, 0, 0},{0, 0, 0, 0}};
38717 : static swig_cast_info _swigc__p__gpgme_recipient[] = { {&_swigt__p__gpgme_recipient, 0, 0, 0},{0, 0, 0, 0}};
38718 : static swig_cast_info _swigc__p__gpgme_sig_notation[] = { {&_swigt__p__gpgme_sig_notation, 0, 0, 0},{0, 0, 0, 0}};
38719 : static swig_cast_info _swigc__p__gpgme_sig_stat_t[] = { {&_swigt__p__gpgme_sig_stat_t, 0, 0, 0},{0, 0, 0, 0}};
38720 : static swig_cast_info _swigc__p__gpgme_signature[] = { {&_swigt__p__gpgme_signature, 0, 0, 0},{0, 0, 0, 0}};
38721 : static swig_cast_info _swigc__p__gpgme_subkey[] = { {&_swigt__p__gpgme_subkey, 0, 0, 0},{0, 0, 0, 0}};
38722 : static swig_cast_info _swigc__p__gpgme_tofu_info[] = { {&_swigt__p__gpgme_tofu_info, 0, 0, 0},{0, 0, 0, 0}};
38723 : static swig_cast_info _swigc__p__gpgme_trust_item[] = { {&_swigt__p__gpgme_trust_item, 0, 0, 0},{0, 0, 0, 0}};
38724 : static swig_cast_info _swigc__p__gpgme_user_id[] = { {&_swigt__p__gpgme_user_id, 0, 0, 0},{0, 0, 0, 0}};
38725 : static swig_cast_info _swigc__p_a___p__gpgme_key[] = { {&_swigt__p_a___p__gpgme_key, 0, 0, 0},{0, 0, 0, 0}};
38726 : static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
38727 : static swig_cast_info _swigc__p_f_p_void__void[] = { {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
38728 : static swig_cast_info _swigc__p_f_p_void_enum_gpgme_event_io_t_p_void__void[] = { {&_swigt__p_f_p_void_enum_gpgme_event_io_t_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
38729 : static swig_cast_info _swigc__p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t[] = { {&_swigt__p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
38730 : static swig_cast_info _swigc__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t[] = { {&_swigt__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
38731 : static swig_cast_info _swigc__p_f_p_void_off_t_int__off_t[] = { {&_swigt__p_f_p_void_off_t_int__off_t, 0, 0, 0},{0, 0, 0, 0}};
38732 : static swig_cast_info _swigc__p_f_p_void_p_q_const__char_int_int_int__void[] = { {&_swigt__p_f_p_void_p_q_const__char_int_int_int__void, 0, 0, 0},{0, 0, 0, 0}};
38733 : static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
38734 : static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
38735 : static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
38736 : static swig_cast_info _swigc__p_f_p_void_p_q_const__void_size_t__gpg_error_t[] = { {&_swigt__p_f_p_void_p_q_const__void_size_t__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
38737 : static swig_cast_info _swigc__p_f_p_void_p_q_const__void_size_t__ssize_t[] = { {&_swigt__p_f_p_void_p_q_const__void_size_t__ssize_t, 0, 0, 0},{0, 0, 0, 0}};
38738 : static swig_cast_info _swigc__p_f_p_void_p_void_size_t__ssize_t[] = { {&_swigt__p_f_p_void_p_void_size_t__ssize_t, 0, 0, 0},{0, 0, 0, 0}};
38739 : static swig_cast_info _swigc__p_gpg_err_code_t[] = { {&_swigt__p_gpg_err_code_t, 0, 0, 0},{0, 0, 0, 0}};
38740 : static swig_cast_info _swigc__p_gpg_err_source_t[] = { {&_swigt__p_gpg_err_source_t, 0, 0, 0},{0, 0, 0, 0}};
38741 : static swig_cast_info _swigc__p_gpg_error_t[] = { {&_swigt__p_gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
38742 : static swig_cast_info _swigc__p_gpgme_conf_arg[] = { {&_swigt__p_gpgme_conf_arg, 0, 0, 0},{0, 0, 0, 0}};
38743 : static swig_cast_info _swigc__p_gpgme_conf_arg_value[] = { {&_swigt__p_gpgme_conf_arg_value, 0, 0, 0},{0, 0, 0, 0}};
38744 : static swig_cast_info _swigc__p_gpgme_conf_comp[] = { {&_swigt__p_gpgme_conf_comp, 0, 0, 0},{0, 0, 0, 0}};
38745 : static swig_cast_info _swigc__p_gpgme_conf_level_t[] = { {&_swigt__p_gpgme_conf_level_t, 0, 0, 0},{0, 0, 0, 0}};
38746 : static swig_cast_info _swigc__p_gpgme_conf_opt[] = { {&_swigt__p_gpgme_conf_opt, 0, 0, 0},{0, 0, 0, 0}};
38747 : static swig_cast_info _swigc__p_gpgme_conf_type_t[] = { {&_swigt__p_gpgme_conf_type_t, 0, 0, 0},{0, 0, 0, 0}};
38748 : static swig_cast_info _swigc__p_gpgme_context[] = { {&_swigt__p_gpgme_context, 0, 0, 0},{0, 0, 0, 0}};
38749 : static swig_cast_info _swigc__p_gpgme_data[] = { {&_swigt__p_gpgme_data, 0, 0, 0},{0, 0, 0, 0}};
38750 : static swig_cast_info _swigc__p_gpgme_data_cbs[] = { {&_swigt__p_gpgme_data_cbs, 0, 0, 0},{0, 0, 0, 0}};
38751 : static swig_cast_info _swigc__p_gpgme_data_encoding_t[] = { {&_swigt__p_gpgme_data_encoding_t, 0, 0, 0},{0, 0, 0, 0}};
38752 : static swig_cast_info _swigc__p_gpgme_data_type_t[] = { {&_swigt__p_gpgme_data_type_t, 0, 0, 0},{0, 0, 0, 0}};
38753 : static swig_cast_info _swigc__p_gpgme_encrypt_flags_t[] = { {&_swigt__p_gpgme_encrypt_flags_t, 0, 0, 0},{0, 0, 0, 0}};
38754 : static swig_cast_info _swigc__p_gpgme_event_io_t[] = { {&_swigt__p_gpgme_event_io_t, 0, 0, 0},{0, 0, 0, 0}};
38755 : static swig_cast_info _swigc__p_gpgme_hash_algo_t[] = { {&_swigt__p_gpgme_hash_algo_t, 0, 0, 0},{0, 0, 0, 0}};
38756 : static swig_cast_info _swigc__p_gpgme_io_cbs[] = { {&_swigt__p_gpgme_io_cbs, 0, 0, 0},{0, 0, 0, 0}};
38757 : static swig_cast_info _swigc__p_gpgme_io_event_done_data[] = { {&_swigt__p_gpgme_io_event_done_data, 0, 0, 0},{0, 0, 0, 0}};
38758 : static swig_cast_info _swigc__p_gpgme_pinentry_mode_t[] = { {&_swigt__p_gpgme_pinentry_mode_t, 0, 0, 0},{0, 0, 0, 0}};
38759 : static swig_cast_info _swigc__p_gpgme_protocol_t[] = { {&_swigt__p_gpgme_protocol_t, 0, 0, 0},{0, 0, 0, 0}};
38760 : static swig_cast_info _swigc__p_gpgme_pubkey_algo_t[] = { {&_swigt__p_gpgme_pubkey_algo_t, 0, 0, 0},{0, 0, 0, 0}};
38761 : static swig_cast_info _swigc__p_gpgme_sig_mode_t[] = { {&_swigt__p_gpgme_sig_mode_t, 0, 0, 0},{0, 0, 0, 0}};
38762 : static swig_cast_info _swigc__p_gpgme_sigsum_t[] = { {&_swigt__p_gpgme_sigsum_t, 0, 0, 0},{0, 0, 0, 0}};
38763 : static swig_cast_info _swigc__p_gpgme_status_code_t[] = { {&_swigt__p_gpgme_status_code_t, 0, 0, 0},{0, 0, 0, 0}};
38764 : static swig_cast_info _swigc__p_gpgme_tofu_policy_t[] = { {&_swigt__p_gpgme_tofu_policy_t, 0, 0, 0},{0, 0, 0, 0}};
38765 : static swig_cast_info _swigc__p_gpgme_validity_t[] = { {&_swigt__p_gpgme_validity_t, 0, 0, 0},{0, 0, 0, 0}};
38766 : static swig_cast_info _swigc__p_off_t[] = { {&_swigt__p_off_t, 0, 0, 0},{0, 0, 0, 0}};
38767 : static swig_cast_info _swigc__p_p__gpgme_engine_info[] = { {&_swigt__p_p__gpgme_engine_info, 0, 0, 0},{0, 0, 0, 0}};
38768 : static swig_cast_info _swigc__p_p__gpgme_key[] = { {&_swigt__p_p__gpgme_key, 0, 0, 0},{0, 0, 0, 0}};
38769 : static swig_cast_info _swigc__p_p__gpgme_trust_item[] = { {&_swigt__p_p__gpgme_trust_item, 0, 0, 0},{0, 0, 0, 0}};
38770 : static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
38771 : static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_int_int_int__void[] = { {&_swigt__p_p_f_p_void_p_q_const__char_int_int_int__void, 0, 0, 0},{0, 0, 0, 0}};
38772 : static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t[] = { {&_swigt__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
38773 : static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t[] = { {&_swigt__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
38774 : static swig_cast_info _swigc__p_p_gpgme_conf_arg[] = { {&_swigt__p_p_gpgme_conf_arg, 0, 0, 0},{0, 0, 0, 0}};
38775 : static swig_cast_info _swigc__p_p_gpgme_conf_comp[] = { {&_swigt__p_p_gpgme_conf_comp, 0, 0, 0},{0, 0, 0, 0}};
38776 : static swig_cast_info _swigc__p_p_gpgme_conf_opt[] = { {&_swigt__p_p_gpgme_conf_opt, 0, 0, 0},{0, 0, 0, 0}};
38777 : static swig_cast_info _swigc__p_p_gpgme_context[] = { {&_swigt__p_p_gpgme_context, 0, 0, 0},{0, 0, 0, 0}};
38778 : static swig_cast_info _swigc__p_p_gpgme_data[] = { {&_swigt__p_p_gpgme_data, 0, 0, 0},{0, 0, 0, 0}};
38779 : static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
38780 : static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
38781 : static swig_cast_info _swigc__p_ssize_t[] = { {&_swigt__p_ssize_t, 0, 0, 0},{0, 0, 0, 0}};
38782 : static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
38783 : static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
38784 :
38785 : static swig_cast_info *swig_cast_initial[] = {
38786 : _swigc__p_FILE,
38787 : _swigc__p_SwigPyObject,
38788 : _swigc__p__gpgme_attr_t,
38789 : _swigc__p__gpgme_engine_info,
38790 : _swigc__p__gpgme_import_status,
38791 : _swigc__p__gpgme_invalid_key,
38792 : _swigc__p__gpgme_key,
38793 : _swigc__p__gpgme_key_sig,
38794 : _swigc__p__gpgme_new_signature,
38795 : _swigc__p__gpgme_op_assuan_result,
38796 : _swigc__p__gpgme_op_decrypt_result,
38797 : _swigc__p__gpgme_op_encrypt_result,
38798 : _swigc__p__gpgme_op_genkey_result,
38799 : _swigc__p__gpgme_op_import_result,
38800 : _swigc__p__gpgme_op_keylist_result,
38801 : _swigc__p__gpgme_op_sign_result,
38802 : _swigc__p__gpgme_op_verify_result,
38803 : _swigc__p__gpgme_op_vfs_mount_result,
38804 : _swigc__p__gpgme_recipient,
38805 : _swigc__p__gpgme_sig_notation,
38806 : _swigc__p__gpgme_sig_stat_t,
38807 : _swigc__p__gpgme_signature,
38808 : _swigc__p__gpgme_subkey,
38809 : _swigc__p__gpgme_tofu_info,
38810 : _swigc__p__gpgme_trust_item,
38811 : _swigc__p__gpgme_user_id,
38812 : _swigc__p_a___p__gpgme_key,
38813 : _swigc__p_char,
38814 : _swigc__p_f_p_void__void,
38815 : _swigc__p_f_p_void_enum_gpgme_event_io_t_p_void__void,
38816 : _swigc__p_f_p_void_enum_gpgme_status_code_t_p_q_const__char_int__gpg_error_t,
38817 : _swigc__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t,
38818 : _swigc__p_f_p_void_off_t_int__off_t,
38819 : _swigc__p_f_p_void_p_q_const__char_int_int_int__void,
38820 : _swigc__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
38821 : _swigc__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
38822 : _swigc__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t,
38823 : _swigc__p_f_p_void_p_q_const__void_size_t__gpg_error_t,
38824 : _swigc__p_f_p_void_p_q_const__void_size_t__ssize_t,
38825 : _swigc__p_f_p_void_p_void_size_t__ssize_t,
38826 : _swigc__p_gpg_err_code_t,
38827 : _swigc__p_gpg_err_source_t,
38828 : _swigc__p_gpg_error_t,
38829 : _swigc__p_gpgme_conf_arg,
38830 : _swigc__p_gpgme_conf_arg_value,
38831 : _swigc__p_gpgme_conf_comp,
38832 : _swigc__p_gpgme_conf_level_t,
38833 : _swigc__p_gpgme_conf_opt,
38834 : _swigc__p_gpgme_conf_type_t,
38835 : _swigc__p_gpgme_context,
38836 : _swigc__p_gpgme_data,
38837 : _swigc__p_gpgme_data_cbs,
38838 : _swigc__p_gpgme_data_encoding_t,
38839 : _swigc__p_gpgme_data_type_t,
38840 : _swigc__p_gpgme_encrypt_flags_t,
38841 : _swigc__p_gpgme_event_io_t,
38842 : _swigc__p_gpgme_hash_algo_t,
38843 : _swigc__p_gpgme_io_cbs,
38844 : _swigc__p_gpgme_io_event_done_data,
38845 : _swigc__p_gpgme_pinentry_mode_t,
38846 : _swigc__p_gpgme_protocol_t,
38847 : _swigc__p_gpgme_pubkey_algo_t,
38848 : _swigc__p_gpgme_sig_mode_t,
38849 : _swigc__p_gpgme_sigsum_t,
38850 : _swigc__p_gpgme_status_code_t,
38851 : _swigc__p_gpgme_tofu_policy_t,
38852 : _swigc__p_gpgme_validity_t,
38853 : _swigc__p_off_t,
38854 : _swigc__p_p__gpgme_engine_info,
38855 : _swigc__p_p__gpgme_key,
38856 : _swigc__p_p__gpgme_trust_item,
38857 : _swigc__p_p_char,
38858 : _swigc__p_p_f_p_void_p_q_const__char_int_int_int__void,
38859 : _swigc__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
38860 : _swigc__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
38861 : _swigc__p_p_gpgme_conf_arg,
38862 : _swigc__p_p_gpgme_conf_comp,
38863 : _swigc__p_p_gpgme_conf_opt,
38864 : _swigc__p_p_gpgme_context,
38865 : _swigc__p_p_gpgme_data,
38866 : _swigc__p_p_void,
38867 : _swigc__p_size_t,
38868 : _swigc__p_ssize_t,
38869 : _swigc__p_unsigned_int,
38870 : _swigc__p_void,
38871 : };
38872 :
38873 :
38874 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38875 :
38876 : static swig_const_info swig_const_table[] = {
38877 : {0, 0, 0, 0.0, 0, 0}};
38878 :
38879 : #ifdef __cplusplus
38880 : }
38881 : #endif
38882 : static PyTypeObject *builtin_bases[2];
38883 :
38884 : /* -----------------------------------------------------------------------------
38885 : * Type initialization:
38886 : * This problem is tough by the requirement that no dynamic
38887 : * memory is used. Also, since swig_type_info structures store pointers to
38888 : * swig_cast_info structures and swig_cast_info structures store pointers back
38889 : * to swig_type_info structures, we need some lookup code at initialization.
38890 : * The idea is that swig generates all the structures that are needed.
38891 : * The runtime then collects these partially filled structures.
38892 : * The SWIG_InitializeModule function takes these initial arrays out of
38893 : * swig_module, and does all the lookup, filling in the swig_module.types
38894 : * array with the correct data and linking the correct swig_cast_info
38895 : * structures together.
38896 : *
38897 : * The generated swig_type_info structures are assigned staticly to an initial
38898 : * array. We just loop through that array, and handle each type individually.
38899 : * First we lookup if this type has been already loaded, and if so, use the
38900 : * loaded structure instead of the generated one. Then we have to fill in the
38901 : * cast linked list. The cast data is initially stored in something like a
38902 : * two-dimensional array. Each row corresponds to a type (there are the same
38903 : * number of rows as there are in the swig_type_initial array). Each entry in
38904 : * a column is one of the swig_cast_info structures for that type.
38905 : * The cast_initial array is actually an array of arrays, because each row has
38906 : * a variable number of columns. So to actually build the cast linked list,
38907 : * we find the array of casts associated with the type, and loop through it
38908 : * adding the casts to the list. The one last trick we need to do is making
38909 : * sure the type pointer in the swig_cast_info struct is correct.
38910 : *
38911 : * First off, we lookup the cast->type name to see if it is already loaded.
38912 : * There are three cases to handle:
38913 : * 1) If the cast->type has already been loaded AND the type we are adding
38914 : * casting info to has not been loaded (it is in this module), THEN we
38915 : * replace the cast->type pointer with the type pointer that has already
38916 : * been loaded.
38917 : * 2) If BOTH types (the one we are adding casting info to, and the
38918 : * cast->type) are loaded, THEN the cast info has already been loaded by
38919 : * the previous module so we just ignore it.
38920 : * 3) Finally, if cast->type has not already been loaded, then we add that
38921 : * swig_cast_info to the linked list (because the cast->type) pointer will
38922 : * be correct.
38923 : * ----------------------------------------------------------------------------- */
38924 :
38925 : #ifdef __cplusplus
38926 : extern "C" {
38927 : #if 0
38928 : } /* c-mode */
38929 : #endif
38930 : #endif
38931 :
38932 : #if 0
38933 : #define SWIGRUNTIME_DEBUG
38934 : #endif
38935 :
38936 :
38937 : SWIGRUNTIME void
38938 23 : SWIG_InitializeModule(void *clientdata) {
38939 : size_t i;
38940 : swig_module_info *module_head, *iter;
38941 : int found, init;
38942 :
38943 : /* check to see if the circular list has been setup, if not, set it up */
38944 23 : if (swig_module.next==0) {
38945 : /* Initialize the swig_module */
38946 23 : swig_module.type_initial = swig_type_initial;
38947 23 : swig_module.cast_initial = swig_cast_initial;
38948 23 : swig_module.next = &swig_module;
38949 23 : init = 1;
38950 : } else {
38951 : init = 0;
38952 : }
38953 :
38954 : /* Try and load any already created modules */
38955 23 : module_head = SWIG_GetModule(clientdata);
38956 23 : if (!module_head) {
38957 : /* This is the first module loaded for this interpreter */
38958 : /* so set the swig module into the interpreter */
38959 23 : SWIG_SetModule(clientdata, &swig_module);
38960 23 : module_head = &swig_module;
38961 : } else {
38962 : /* the interpreter has loaded a SWIG module, but has it loaded this one? */
38963 : found=0;
38964 : iter=module_head;
38965 : do {
38966 0 : if (iter==&swig_module) {
38967 : found=1;
38968 : break;
38969 : }
38970 0 : iter=iter->next;
38971 0 : } while (iter!= module_head);
38972 :
38973 : /* if the is found in the list, then all is done and we may leave */
38974 0 : if (found) return;
38975 : /* otherwise we must add out module into the list */
38976 0 : swig_module.next = module_head->next;
38977 0 : module_head->next = &swig_module;
38978 : }
38979 :
38980 : /* When multiple interpreters are used, a module could have already been initialized in
38981 : a different interpreter, but not yet have a pointer in this interpreter.
38982 : In this case, we do not want to continue adding types... everything should be
38983 : set up already */
38984 23 : if (init == 0) return;
38985 :
38986 : /* Now work on filling in swig_module.types */
38987 : #ifdef SWIGRUNTIME_DEBUG
38988 : printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38989 : #endif
38990 1955 : for (i = 0; i < swig_module.size; ++i) {
38991 1955 : swig_type_info *type = 0;
38992 : swig_type_info *ret;
38993 : swig_cast_info *cast;
38994 :
38995 : #ifdef SWIGRUNTIME_DEBUG
38996 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38997 : #endif
38998 :
38999 : /* if there is another module already loaded */
39000 1955 : if (swig_module.next != &swig_module) {
39001 0 : type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
39002 : }
39003 1955 : if (type) {
39004 : /* Overwrite clientdata field */
39005 : #ifdef SWIGRUNTIME_DEBUG
39006 : printf("SWIG_InitializeModule: found type %s\n", type->name);
39007 : #endif
39008 0 : if (swig_module.type_initial[i]->clientdata) {
39009 0 : type->clientdata = swig_module.type_initial[i]->clientdata;
39010 : #ifdef SWIGRUNTIME_DEBUG
39011 : printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
39012 : #endif
39013 : }
39014 : } else {
39015 1955 : type = swig_module.type_initial[i];
39016 : }
39017 :
39018 : /* Insert casting types */
39019 1955 : cast = swig_module.cast_initial[i];
39020 3910 : while (cast->type) {
39021 : /* Don't need to add information already in the list */
39022 1955 : ret = 0;
39023 : #ifdef SWIGRUNTIME_DEBUG
39024 : printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
39025 : #endif
39026 1955 : if (swig_module.next != &swig_module) {
39027 0 : ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
39028 : #ifdef SWIGRUNTIME_DEBUG
39029 : if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
39030 : #endif
39031 : }
39032 1955 : if (ret) {
39033 0 : if (type == swig_module.type_initial[i]) {
39034 : #ifdef SWIGRUNTIME_DEBUG
39035 : printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
39036 : #endif
39037 0 : cast->type = ret;
39038 0 : ret = 0;
39039 : } else {
39040 : /* Check for casting already in the list */
39041 0 : swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
39042 : #ifdef SWIGRUNTIME_DEBUG
39043 : if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
39044 : #endif
39045 0 : if (!ocast) ret = 0;
39046 : }
39047 : }
39048 :
39049 1955 : if (!ret) {
39050 : #ifdef SWIGRUNTIME_DEBUG
39051 : printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
39052 : #endif
39053 1955 : if (type->cast) {
39054 0 : type->cast->prev = cast;
39055 0 : cast->next = type->cast;
39056 : }
39057 1955 : type->cast = cast;
39058 : }
39059 1955 : cast++;
39060 : }
39061 : /* Set entry in modules->types array equal to the type */
39062 1955 : swig_module.types[i] = type;
39063 : }
39064 23 : swig_module.types[i] = 0;
39065 :
39066 : #ifdef SWIGRUNTIME_DEBUG
39067 : printf("**** SWIG_InitializeModule: Cast List ******\n");
39068 : for (i = 0; i < swig_module.size; ++i) {
39069 : int j = 0;
39070 : swig_cast_info *cast = swig_module.cast_initial[i];
39071 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39072 : while (cast->type) {
39073 : printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
39074 : cast++;
39075 : ++j;
39076 : }
39077 : printf("---- Total casts: %d\n",j);
39078 : }
39079 : printf("**** SWIG_InitializeModule: Cast List ******\n");
39080 : #endif
39081 : }
39082 :
39083 : /* This function will propagate the clientdata field of type to
39084 : * any new swig_type_info structures that have been added into the list
39085 : * of equivalent types. It is like calling
39086 : * SWIG_TypeClientData(type, clientdata) a second time.
39087 : */
39088 : SWIGRUNTIME void
39089 : SWIG_PropagateClientData(void) {
39090 : size_t i;
39091 : swig_cast_info *equiv;
39092 : static int init_run = 0;
39093 :
39094 : if (init_run) return;
39095 : init_run = 1;
39096 :
39097 : for (i = 0; i < swig_module.size; i++) {
39098 : if (swig_module.types[i]->clientdata) {
39099 : equiv = swig_module.types[i]->cast;
39100 : while (equiv) {
39101 : if (!equiv->converter) {
39102 : if (equiv->type && !equiv->type->clientdata)
39103 : SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
39104 : }
39105 : equiv = equiv->next;
39106 : }
39107 : }
39108 : }
39109 : }
39110 :
39111 : #ifdef __cplusplus
39112 : #if 0
39113 : {
39114 : /* c-mode */
39115 : #endif
39116 : }
39117 : #endif
39118 :
39119 :
39120 :
39121 : #ifdef __cplusplus
39122 : extern "C" {
39123 : #endif
39124 :
39125 : /* Python-specific SWIG API */
39126 : #define SWIG_newvarlink() SWIG_Python_newvarlink()
39127 : #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
39128 : #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
39129 :
39130 : /* -----------------------------------------------------------------------------
39131 : * global variable support code.
39132 : * ----------------------------------------------------------------------------- */
39133 :
39134 : typedef struct swig_globalvar {
39135 : char *name; /* Name of global variable */
39136 : PyObject *(*get_attr)(void); /* Return the current value */
39137 : int (*set_attr)(PyObject *); /* Set the value */
39138 : struct swig_globalvar *next;
39139 : } swig_globalvar;
39140 :
39141 : typedef struct swig_varlinkobject {
39142 : PyObject_HEAD
39143 : swig_globalvar *vars;
39144 : } swig_varlinkobject;
39145 :
39146 : SWIGINTERN PyObject *
39147 0 : swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
39148 : #if PY_VERSION_HEX >= 0x03000000
39149 0 : return PyUnicode_InternFromString("<Swig global variables>");
39150 : #else
39151 : return PyString_FromString("<Swig global variables>");
39152 : #endif
39153 : }
39154 :
39155 : SWIGINTERN PyObject *
39156 0 : swig_varlink_str(swig_varlinkobject *v) {
39157 : #if PY_VERSION_HEX >= 0x03000000
39158 0 : PyObject *str = PyUnicode_InternFromString("(");
39159 : PyObject *tail;
39160 : PyObject *joined;
39161 : swig_globalvar *var;
39162 0 : for (var = v->vars; var; var=var->next) {
39163 0 : tail = PyUnicode_FromString(var->name);
39164 0 : joined = PyUnicode_Concat(str, tail);
39165 0 : Py_DecRef(str);
39166 0 : Py_DecRef(tail);
39167 0 : str = joined;
39168 0 : if (var->next) {
39169 0 : tail = PyUnicode_InternFromString(", ");
39170 0 : joined = PyUnicode_Concat(str, tail);
39171 0 : Py_DecRef(str);
39172 0 : Py_DecRef(tail);
39173 0 : str = joined;
39174 : }
39175 : }
39176 0 : tail = PyUnicode_InternFromString(")");
39177 0 : joined = PyUnicode_Concat(str, tail);
39178 0 : Py_DecRef(str);
39179 0 : Py_DecRef(tail);
39180 0 : str = joined;
39181 : #else
39182 : PyObject *str = PyString_FromString("(");
39183 : swig_globalvar *var;
39184 : for (var = v->vars; var; var=var->next) {
39185 : PyString_ConcatAndDel(&str,PyString_FromString(var->name));
39186 : if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
39187 : }
39188 : PyString_ConcatAndDel(&str,PyString_FromString(")"));
39189 : #endif
39190 0 : return str;
39191 : }
39192 :
39193 : SWIGINTERN int
39194 0 : swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
39195 : char *tmp;
39196 0 : PyObject *str = swig_varlink_str(v);
39197 : fprintf(fp,"Swig global variables ");
39198 0 : fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
39199 0 : SWIG_Python_str_DelForPy3(tmp);
39200 0 : Py_DECREF(str);
39201 0 : return 0;
39202 : }
39203 :
39204 : SWIGINTERN void
39205 0 : swig_varlink_dealloc(swig_varlinkobject *v) {
39206 0 : swig_globalvar *var = v->vars;
39207 0 : while (var) {
39208 0 : swig_globalvar *n = var->next;
39209 0 : free(var->name);
39210 0 : free(var);
39211 0 : var = n;
39212 : }
39213 0 : }
39214 :
39215 : SWIGINTERN PyObject *
39216 23 : swig_varlink_getattr(swig_varlinkobject *v, char *n) {
39217 23 : PyObject *res = NULL;
39218 23 : swig_globalvar *var = v->vars;
39219 46 : while (var) {
39220 23 : if (strcmp(var->name,n) == 0) {
39221 23 : res = (*var->get_attr)();
39222 23 : break;
39223 : }
39224 0 : var = var->next;
39225 : }
39226 23 : if (res == NULL && !PyErr_Occurred()) {
39227 0 : PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39228 : }
39229 23 : return res;
39230 : }
39231 :
39232 : SWIGINTERN int
39233 0 : swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
39234 0 : int res = 1;
39235 0 : swig_globalvar *var = v->vars;
39236 0 : while (var) {
39237 0 : if (strcmp(var->name,n) == 0) {
39238 0 : res = (*var->set_attr)(p);
39239 0 : break;
39240 : }
39241 0 : var = var->next;
39242 : }
39243 0 : if (res == 1 && !PyErr_Occurred()) {
39244 0 : PyErr_SetString(PyExc_NameError,"Unknown C global variable");
39245 : }
39246 0 : return res;
39247 : }
39248 :
39249 : SWIGINTERN PyTypeObject*
39250 46 : swig_varlink_type(void) {
39251 : static char varlink__doc__[] = "Swig var link object";
39252 : static PyTypeObject varlink_type;
39253 : static int type_init = 0;
39254 46 : if (!type_init) {
39255 : const PyTypeObject tmp = {
39256 : /* PyObject header changed in Python 3 */
39257 : #if PY_VERSION_HEX >= 0x03000000
39258 : PyVarObject_HEAD_INIT(NULL, 0)
39259 : #else
39260 : PyObject_HEAD_INIT(NULL)
39261 : 0, /* ob_size */
39262 : #endif
39263 : (char *)"swigvarlink", /* tp_name */
39264 : sizeof(swig_varlinkobject), /* tp_basicsize */
39265 : 0, /* tp_itemsize */
39266 : (destructor) swig_varlink_dealloc, /* tp_dealloc */
39267 : (printfunc) swig_varlink_print, /* tp_print */
39268 : (getattrfunc) swig_varlink_getattr, /* tp_getattr */
39269 : (setattrfunc) swig_varlink_setattr, /* tp_setattr */
39270 : 0, /* tp_compare */
39271 : (reprfunc) swig_varlink_repr, /* tp_repr */
39272 : 0, /* tp_as_number */
39273 : 0, /* tp_as_sequence */
39274 : 0, /* tp_as_mapping */
39275 : 0, /* tp_hash */
39276 : 0, /* tp_call */
39277 : (reprfunc) swig_varlink_str, /* tp_str */
39278 : 0, /* tp_getattro */
39279 : 0, /* tp_setattro */
39280 : 0, /* tp_as_buffer */
39281 : 0, /* tp_flags */
39282 : varlink__doc__, /* tp_doc */
39283 : 0, /* tp_traverse */
39284 : 0, /* tp_clear */
39285 : 0, /* tp_richcompare */
39286 : 0, /* tp_weaklistoffset */
39287 : #if PY_VERSION_HEX >= 0x02020000
39288 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
39289 : #endif
39290 : #if PY_VERSION_HEX >= 0x02030000
39291 : 0, /* tp_del */
39292 : #endif
39293 : #if PY_VERSION_HEX >= 0x02060000
39294 : 0, /* tp_version */
39295 : #endif
39296 : #ifdef COUNT_ALLOCS
39297 : 0,0,0,0 /* tp_alloc -> tp_next */
39298 : #endif
39299 : };
39300 23 : varlink_type = tmp;
39301 23 : type_init = 1;
39302 : #if PY_VERSION_HEX < 0x02020000
39303 : varlink_type.ob_type = &PyType_Type;
39304 : #else
39305 23 : if (PyType_Ready(&varlink_type) < 0)
39306 : return NULL;
39307 : #endif
39308 : }
39309 : return &varlink_type;
39310 : }
39311 :
39312 : /* Create a variable linking object for use later */
39313 : SWIGINTERN PyObject *
39314 23 : SWIG_Python_newvarlink(void) {
39315 23 : swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
39316 23 : if (result) {
39317 23 : result->vars = 0;
39318 : }
39319 23 : return ((PyObject*) result);
39320 : }
39321 :
39322 : SWIGINTERN void
39323 23 : SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
39324 23 : swig_varlinkobject *v = (swig_varlinkobject *) p;
39325 23 : swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
39326 23 : if (gv) {
39327 23 : size_t size = strlen(name)+1;
39328 23 : gv->name = (char *)malloc(size);
39329 23 : if (gv->name) {
39330 23 : strncpy(gv->name,name,size);
39331 23 : gv->get_attr = get_attr;
39332 23 : gv->set_attr = set_attr;
39333 23 : gv->next = v->vars;
39334 : }
39335 : }
39336 23 : v->vars = gv;
39337 23 : }
39338 :
39339 : SWIGINTERN PyObject *
39340 : SWIG_globals(void) {
39341 : static PyObject *_SWIG_globals = 0;
39342 46 : if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
39343 46 : return _SWIG_globals;
39344 : }
39345 :
39346 : /* -----------------------------------------------------------------------------
39347 : * constants/methods manipulation
39348 : * ----------------------------------------------------------------------------- */
39349 :
39350 : /* Install Constants */
39351 : SWIGINTERN void
39352 23 : SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
39353 23 : PyObject *obj = 0;
39354 : size_t i;
39355 23 : for (i = 0; constants[i].type; ++i) {
39356 0 : switch(constants[i].type) {
39357 : case SWIG_PY_POINTER:
39358 0 : obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
39359 0 : break;
39360 : case SWIG_PY_BINARY:
39361 0 : obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
39362 0 : break;
39363 : default:
39364 : obj = 0;
39365 : break;
39366 : }
39367 0 : if (obj) {
39368 0 : PyDict_SetItemString(d, constants[i].name, obj);
39369 0 : Py_DECREF(obj);
39370 : }
39371 : }
39372 23 : }
39373 :
39374 : /* -----------------------------------------------------------------------------*/
39375 : /* Fix SwigMethods to carry the callback ptrs when needed */
39376 : /* -----------------------------------------------------------------------------*/
39377 :
39378 : SWIGINTERN void
39379 23 : SWIG_Python_FixMethods(PyMethodDef *methods,
39380 : swig_const_info *const_table,
39381 : swig_type_info **types,
39382 : swig_type_info **types_initial) {
39383 : size_t i;
39384 4508 : for (i = 0; methods[i].ml_name; ++i) {
39385 4485 : const char *c = methods[i].ml_doc;
39386 4485 : if (c && (c = strstr(c, "swig_ptr: "))) {
39387 : int j;
39388 0 : swig_const_info *ci = 0;
39389 0 : const char *name = c + 10;
39390 0 : for (j = 0; const_table[j].type; ++j) {
39391 0 : if (strncmp(const_table[j].name, name,
39392 : strlen(const_table[j].name)) == 0) {
39393 0 : ci = &(const_table[j]);
39394 0 : break;
39395 : }
39396 : }
39397 0 : if (ci) {
39398 0 : void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
39399 0 : if (ptr) {
39400 0 : size_t shift = (ci->ptype) - types;
39401 0 : swig_type_info *ty = types_initial[shift];
39402 0 : size_t ldoc = (c - methods[i].ml_doc);
39403 0 : size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
39404 0 : char *ndoc = (char*)malloc(ldoc + lptr + 10);
39405 0 : if (ndoc) {
39406 0 : char *buff = ndoc;
39407 0 : strncpy(buff, methods[i].ml_doc, ldoc);
39408 0 : buff += ldoc;
39409 : strncpy(buff, "swig_ptr: ", 10);
39410 0 : buff += 10;
39411 0 : SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
39412 0 : methods[i].ml_doc = ndoc;
39413 : }
39414 : }
39415 : }
39416 : }
39417 : }
39418 23 : }
39419 :
39420 : #ifdef __cplusplus
39421 : }
39422 : #endif
39423 :
39424 : /* -----------------------------------------------------------------------------*
39425 : * Partial Init method
39426 : * -----------------------------------------------------------------------------*/
39427 :
39428 : #ifdef __cplusplus
39429 : extern "C"
39430 : #endif
39431 :
39432 : SWIGEXPORT
39433 : #if PY_VERSION_HEX >= 0x03000000
39434 : PyObject*
39435 : #else
39436 : void
39437 : #endif
39438 23 : SWIG_init(void) {
39439 : PyObject *m, *d, *md;
39440 : #if PY_VERSION_HEX >= 0x03000000
39441 : static struct PyModuleDef SWIG_module = {
39442 : # if PY_VERSION_HEX >= 0x03020000
39443 : PyModuleDef_HEAD_INIT,
39444 : # else
39445 : {
39446 : PyObject_HEAD_INIT(NULL)
39447 : NULL, /* m_init */
39448 : 0, /* m_index */
39449 : NULL, /* m_copy */
39450 : },
39451 : # endif
39452 : (char *) SWIG_name,
39453 : NULL,
39454 : -1,
39455 : SwigMethods,
39456 : NULL,
39457 : NULL,
39458 : NULL,
39459 : NULL
39460 : };
39461 : #endif
39462 :
39463 : #if defined(SWIGPYTHON_BUILTIN)
39464 : static SwigPyClientData SwigPyObject_clientdata = {
39465 : 0, 0, 0, 0, 0, 0, 0
39466 : };
39467 : static PyGetSetDef this_getset_def = {
39468 : (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
39469 : };
39470 : static SwigPyGetSet thisown_getset_closure = {
39471 : (PyCFunction) SwigPyObject_own,
39472 : (PyCFunction) SwigPyObject_own
39473 : };
39474 : static PyGetSetDef thisown_getset_def = {
39475 : (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
39476 : };
39477 : PyObject *metatype_args;
39478 : PyTypeObject *builtin_pytype;
39479 : int builtin_base_count;
39480 : swig_type_info *builtin_basetype;
39481 : PyObject *tuple;
39482 : PyGetSetDescrObject *static_getset;
39483 : PyTypeObject *metatype;
39484 : SwigPyClientData *cd;
39485 : PyObject *public_interface, *public_symbol;
39486 : PyObject *this_descr;
39487 : PyObject *thisown_descr;
39488 : int i;
39489 :
39490 : (void)builtin_pytype;
39491 : (void)builtin_base_count;
39492 : (void)builtin_basetype;
39493 : (void)tuple;
39494 : (void)static_getset;
39495 :
39496 : /* metatype is used to implement static member variables. */
39497 23 : metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
39498 : assert(metatype_args);
39499 23 : metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
39500 : assert(metatype);
39501 23 : Py_DECREF(metatype_args);
39502 23 : metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
39503 : assert(PyType_Ready(metatype) >= 0);
39504 : #endif
39505 :
39506 : /* Fix SwigMethods to carry the callback ptrs when needed */
39507 23 : SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
39508 :
39509 : #if PY_VERSION_HEX >= 0x03000000
39510 23 : m = PyModule_Create(&SWIG_module);
39511 : #else
39512 : m = Py_InitModule((char *) SWIG_name, SwigMethods);
39513 : #endif
39514 23 : md = d = PyModule_GetDict(m);
39515 : (void)md;
39516 :
39517 23 : SWIG_InitializeModule(0);
39518 :
39519 : #ifdef SWIGPYTHON_BUILTIN
39520 23 : SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
39521 : assert(SwigPyObject_stype);
39522 23 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
39523 23 : if (!cd) {
39524 23 : SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
39525 23 : SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
39526 0 : } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
39527 0 : PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
39528 : # if PY_VERSION_HEX >= 0x03000000
39529 0 : return NULL;
39530 : # else
39531 : return;
39532 : # endif
39533 : }
39534 :
39535 : /* All objects have a 'this' attribute */
39536 23 : this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
39537 : (void)this_descr;
39538 :
39539 : /* All objects have a 'thisown' attribute */
39540 23 : thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
39541 : (void)thisown_descr;
39542 :
39543 23 : public_interface = PyList_New(0);
39544 23 : public_symbol = 0;
39545 : (void)public_symbol;
39546 :
39547 23 : PyDict_SetItemString(md, "__all__", public_interface);
39548 23 : Py_DECREF(public_interface);
39549 4485 : for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
39550 4485 : SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
39551 0 : for (i = 0; swig_const_table[i].name != 0; ++i)
39552 0 : SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
39553 : #endif
39554 :
39555 23 : SWIG_InstallConstants(d,swig_const_table);
39556 :
39557 :
39558 : /* type '::_gpgme_sig_notation' */
39559 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_sig_notation_type;
39560 23 : builtin_pytype->tp_dict = d = PyDict_New();
39561 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
39562 23 : builtin_pytype->tp_new = PyType_GenericNew;
39563 23 : builtin_base_count = 0;
39564 23 : builtin_bases[builtin_base_count] = NULL;
39565 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
39566 23 : PyDict_SetItemString(d, "this", this_descr);
39567 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
39568 23 : if (PyType_Ready(builtin_pytype) < 0) {
39569 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_sig_notation'.");
39570 : #if PY_VERSION_HEX >= 0x03000000
39571 0 : return NULL;
39572 : #else
39573 : return;
39574 : #endif
39575 : }
39576 23 : Py_INCREF(builtin_pytype);
39577 23 : PyModule_AddObject(m, "_gpgme_sig_notation", (PyObject*) builtin_pytype);
39578 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_sig_notation");
39579 23 : d = md;
39580 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_VERSION",SWIG_FromCharPtr("1.7.0"));
39581 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_VERSION_NUMBER",SWIG_From_int((int)(0x010700)));
39582 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_ENCODING_NONE",SWIG_From_int((int)(GPGME_DATA_ENCODING_NONE)));
39583 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_ENCODING_BINARY",SWIG_From_int((int)(GPGME_DATA_ENCODING_BINARY)));
39584 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_ENCODING_BASE64",SWIG_From_int((int)(GPGME_DATA_ENCODING_BASE64)));
39585 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_ENCODING_ARMOR",SWIG_From_int((int)(GPGME_DATA_ENCODING_ARMOR)));
39586 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_ENCODING_URL",SWIG_From_int((int)(GPGME_DATA_ENCODING_URL)));
39587 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_ENCODING_URLESC",SWIG_From_int((int)(GPGME_DATA_ENCODING_URLESC)));
39588 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_ENCODING_URL0",SWIG_From_int((int)(GPGME_DATA_ENCODING_URL0)));
39589 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_ENCODING_MIME",SWIG_From_int((int)(GPGME_DATA_ENCODING_MIME)));
39590 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_INVALID",SWIG_From_int((int)(GPGME_DATA_TYPE_INVALID)));
39591 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_UNKNOWN",SWIG_From_int((int)(GPGME_DATA_TYPE_UNKNOWN)));
39592 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_PGP_SIGNED",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_SIGNED)));
39593 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_PGP_ENCRYPTED",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_ENCRYPTED)));
39594 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_PGP_OTHER",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_OTHER)));
39595 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_PGP_KEY",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_KEY)));
39596 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_PGP_SIGNATURE",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_SIGNATURE)));
39597 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_CMS_SIGNED",SWIG_From_int((int)(GPGME_DATA_TYPE_CMS_SIGNED)));
39598 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_CMS_ENCRYPTED",SWIG_From_int((int)(GPGME_DATA_TYPE_CMS_ENCRYPTED)));
39599 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_CMS_OTHER",SWIG_From_int((int)(GPGME_DATA_TYPE_CMS_OTHER)));
39600 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_X509_CERT",SWIG_From_int((int)(GPGME_DATA_TYPE_X509_CERT)));
39601 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_DATA_TYPE_PKCS12",SWIG_From_int((int)(GPGME_DATA_TYPE_PKCS12)));
39602 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PK_RSA",SWIG_From_int((int)(GPGME_PK_RSA)));
39603 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PK_RSA_E",SWIG_From_int((int)(GPGME_PK_RSA_E)));
39604 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PK_RSA_S",SWIG_From_int((int)(GPGME_PK_RSA_S)));
39605 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PK_ELG_E",SWIG_From_int((int)(GPGME_PK_ELG_E)));
39606 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PK_DSA",SWIG_From_int((int)(GPGME_PK_DSA)));
39607 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PK_ECC",SWIG_From_int((int)(GPGME_PK_ECC)));
39608 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PK_ELG",SWIG_From_int((int)(GPGME_PK_ELG)));
39609 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PK_ECDSA",SWIG_From_int((int)(GPGME_PK_ECDSA)));
39610 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PK_ECDH",SWIG_From_int((int)(GPGME_PK_ECDH)));
39611 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PK_EDDSA",SWIG_From_int((int)(GPGME_PK_EDDSA)));
39612 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_NONE",SWIG_From_int((int)(GPGME_MD_NONE)));
39613 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_MD5",SWIG_From_int((int)(GPGME_MD_MD5)));
39614 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_SHA1",SWIG_From_int((int)(GPGME_MD_SHA1)));
39615 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_RMD160",SWIG_From_int((int)(GPGME_MD_RMD160)));
39616 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_MD2",SWIG_From_int((int)(GPGME_MD_MD2)));
39617 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_TIGER",SWIG_From_int((int)(GPGME_MD_TIGER)));
39618 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_HAVAL",SWIG_From_int((int)(GPGME_MD_HAVAL)));
39619 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_SHA256",SWIG_From_int((int)(GPGME_MD_SHA256)));
39620 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_SHA384",SWIG_From_int((int)(GPGME_MD_SHA384)));
39621 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_SHA512",SWIG_From_int((int)(GPGME_MD_SHA512)));
39622 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_SHA224",SWIG_From_int((int)(GPGME_MD_SHA224)));
39623 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_MD4",SWIG_From_int((int)(GPGME_MD_MD4)));
39624 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_CRC32",SWIG_From_int((int)(GPGME_MD_CRC32)));
39625 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_CRC32_RFC1510",SWIG_From_int((int)(GPGME_MD_CRC32_RFC1510)));
39626 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_MD_CRC24_RFC2440",SWIG_From_int((int)(GPGME_MD_CRC24_RFC2440)));
39627 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_STAT_NONE",SWIG_From_int((int)(GPGME_SIG_STAT_NONE)));
39628 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_STAT_GOOD",SWIG_From_int((int)(GPGME_SIG_STAT_GOOD)));
39629 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_STAT_BAD",SWIG_From_int((int)(GPGME_SIG_STAT_BAD)));
39630 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_STAT_NOKEY",SWIG_From_int((int)(GPGME_SIG_STAT_NOKEY)));
39631 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_STAT_NOSIG",SWIG_From_int((int)(GPGME_SIG_STAT_NOSIG)));
39632 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_STAT_ERROR",SWIG_From_int((int)(GPGME_SIG_STAT_ERROR)));
39633 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_STAT_DIFF",SWIG_From_int((int)(GPGME_SIG_STAT_DIFF)));
39634 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_STAT_GOOD_EXP",SWIG_From_int((int)(GPGME_SIG_STAT_GOOD_EXP)));
39635 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_STAT_GOOD_EXPKEY",SWIG_From_int((int)(GPGME_SIG_STAT_GOOD_EXPKEY)));
39636 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_MODE_NORMAL",SWIG_From_int((int)(GPGME_SIG_MODE_NORMAL)));
39637 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_MODE_DETACH",SWIG_From_int((int)(GPGME_SIG_MODE_DETACH)));
39638 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_MODE_CLEAR",SWIG_From_int((int)(GPGME_SIG_MODE_CLEAR)));
39639 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_KEYID",SWIG_From_int((int)(GPGME_ATTR_KEYID)));
39640 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_FPR",SWIG_From_int((int)(GPGME_ATTR_FPR)));
39641 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_ALGO",SWIG_From_int((int)(GPGME_ATTR_ALGO)));
39642 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_LEN",SWIG_From_int((int)(GPGME_ATTR_LEN)));
39643 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_CREATED",SWIG_From_int((int)(GPGME_ATTR_CREATED)));
39644 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_EXPIRE",SWIG_From_int((int)(GPGME_ATTR_EXPIRE)));
39645 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_OTRUST",SWIG_From_int((int)(GPGME_ATTR_OTRUST)));
39646 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_USERID",SWIG_From_int((int)(GPGME_ATTR_USERID)));
39647 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_NAME",SWIG_From_int((int)(GPGME_ATTR_NAME)));
39648 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_EMAIL",SWIG_From_int((int)(GPGME_ATTR_EMAIL)));
39649 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_COMMENT",SWIG_From_int((int)(GPGME_ATTR_COMMENT)));
39650 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_VALIDITY",SWIG_From_int((int)(GPGME_ATTR_VALIDITY)));
39651 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_LEVEL",SWIG_From_int((int)(GPGME_ATTR_LEVEL)));
39652 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_TYPE",SWIG_From_int((int)(GPGME_ATTR_TYPE)));
39653 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_IS_SECRET",SWIG_From_int((int)(GPGME_ATTR_IS_SECRET)));
39654 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_KEY_REVOKED",SWIG_From_int((int)(GPGME_ATTR_KEY_REVOKED)));
39655 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_KEY_INVALID",SWIG_From_int((int)(GPGME_ATTR_KEY_INVALID)));
39656 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_UID_REVOKED",SWIG_From_int((int)(GPGME_ATTR_UID_REVOKED)));
39657 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_UID_INVALID",SWIG_From_int((int)(GPGME_ATTR_UID_INVALID)));
39658 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_KEY_CAPS",SWIG_From_int((int)(GPGME_ATTR_KEY_CAPS)));
39659 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_CAN_ENCRYPT",SWIG_From_int((int)(GPGME_ATTR_CAN_ENCRYPT)));
39660 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_CAN_SIGN",SWIG_From_int((int)(GPGME_ATTR_CAN_SIGN)));
39661 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_CAN_CERTIFY",SWIG_From_int((int)(GPGME_ATTR_CAN_CERTIFY)));
39662 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_KEY_EXPIRED",SWIG_From_int((int)(GPGME_ATTR_KEY_EXPIRED)));
39663 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_KEY_DISABLED",SWIG_From_int((int)(GPGME_ATTR_KEY_DISABLED)));
39664 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_SERIAL",SWIG_From_int((int)(GPGME_ATTR_SERIAL)));
39665 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_ISSUER",SWIG_From_int((int)(GPGME_ATTR_ISSUER)));
39666 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_CHAINID",SWIG_From_int((int)(GPGME_ATTR_CHAINID)));
39667 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_SIG_STATUS",SWIG_From_int((int)(GPGME_ATTR_SIG_STATUS)));
39668 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_ERRTOK",SWIG_From_int((int)(GPGME_ATTR_ERRTOK)));
39669 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_SIG_SUMMARY",SWIG_From_int((int)(GPGME_ATTR_SIG_SUMMARY)));
39670 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ATTR_SIG_CLASS",SWIG_From_int((int)(GPGME_ATTR_SIG_CLASS)));
39671 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_VALIDITY_UNKNOWN",SWIG_From_int((int)(GPGME_VALIDITY_UNKNOWN)));
39672 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_VALIDITY_UNDEFINED",SWIG_From_int((int)(GPGME_VALIDITY_UNDEFINED)));
39673 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_VALIDITY_NEVER",SWIG_From_int((int)(GPGME_VALIDITY_NEVER)));
39674 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_VALIDITY_MARGINAL",SWIG_From_int((int)(GPGME_VALIDITY_MARGINAL)));
39675 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_VALIDITY_FULL",SWIG_From_int((int)(GPGME_VALIDITY_FULL)));
39676 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_VALIDITY_ULTIMATE",SWIG_From_int((int)(GPGME_VALIDITY_ULTIMATE)));
39677 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_TOFU_POLICY_NONE",SWIG_From_int((int)(GPGME_TOFU_POLICY_NONE)));
39678 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_TOFU_POLICY_AUTO",SWIG_From_int((int)(GPGME_TOFU_POLICY_AUTO)));
39679 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_TOFU_POLICY_GOOD",SWIG_From_int((int)(GPGME_TOFU_POLICY_GOOD)));
39680 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_TOFU_POLICY_UNKNOWN",SWIG_From_int((int)(GPGME_TOFU_POLICY_UNKNOWN)));
39681 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_TOFU_POLICY_BAD",SWIG_From_int((int)(GPGME_TOFU_POLICY_BAD)));
39682 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_TOFU_POLICY_ASK",SWIG_From_int((int)(GPGME_TOFU_POLICY_ASK)));
39683 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PROTOCOL_OpenPGP",SWIG_From_int((int)(GPGME_PROTOCOL_OpenPGP)));
39684 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PROTOCOL_CMS",SWIG_From_int((int)(GPGME_PROTOCOL_CMS)));
39685 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PROTOCOL_GPGCONF",SWIG_From_int((int)(GPGME_PROTOCOL_GPGCONF)));
39686 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PROTOCOL_ASSUAN",SWIG_From_int((int)(GPGME_PROTOCOL_ASSUAN)));
39687 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PROTOCOL_G13",SWIG_From_int((int)(GPGME_PROTOCOL_G13)));
39688 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PROTOCOL_UISERVER",SWIG_From_int((int)(GPGME_PROTOCOL_UISERVER)));
39689 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PROTOCOL_SPAWN",SWIG_From_int((int)(GPGME_PROTOCOL_SPAWN)));
39690 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PROTOCOL_DEFAULT",SWIG_From_int((int)(GPGME_PROTOCOL_DEFAULT)));
39691 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PROTOCOL_UNKNOWN",SWIG_From_int((int)(GPGME_PROTOCOL_UNKNOWN)));
39692 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_KEYLIST_MODE_LOCAL",SWIG_From_int((int)(1)));
39693 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_KEYLIST_MODE_EXTERN",SWIG_From_int((int)(2)));
39694 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_KEYLIST_MODE_SIGS",SWIG_From_int((int)(4)));
39695 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_KEYLIST_MODE_SIG_NOTATIONS",SWIG_From_int((int)(8)));
39696 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_KEYLIST_MODE_WITH_SECRET",SWIG_From_int((int)(16)));
39697 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_KEYLIST_MODE_WITH_TOFU",SWIG_From_int((int)(32)));
39698 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_KEYLIST_MODE_EPHEMERAL",SWIG_From_int((int)(128)));
39699 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_KEYLIST_MODE_VALIDATE",SWIG_From_int((int)(256)));
39700 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PINENTRY_MODE_DEFAULT",SWIG_From_int((int)(GPGME_PINENTRY_MODE_DEFAULT)));
39701 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PINENTRY_MODE_ASK",SWIG_From_int((int)(GPGME_PINENTRY_MODE_ASK)));
39702 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PINENTRY_MODE_CANCEL",SWIG_From_int((int)(GPGME_PINENTRY_MODE_CANCEL)));
39703 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PINENTRY_MODE_ERROR",SWIG_From_int((int)(GPGME_PINENTRY_MODE_ERROR)));
39704 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_PINENTRY_MODE_LOOPBACK",SWIG_From_int((int)(GPGME_PINENTRY_MODE_LOOPBACK)));
39705 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_EXPORT_MODE_EXTERN",SWIG_From_int((int)(2)));
39706 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_EXPORT_MODE_MINIMAL",SWIG_From_int((int)(4)));
39707 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_EXPORT_MODE_SECRET",SWIG_From_int((int)(16)));
39708 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_EXPORT_MODE_RAW",SWIG_From_int((int)(32)));
39709 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_EXPORT_MODE_PKCS12",SWIG_From_int((int)(64)));
39710 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_AUDITLOG_HTML",SWIG_From_int((int)(1)));
39711 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_AUDITLOG_WITH_HELP",SWIG_From_int((int)(128)));
39712 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_EOF",SWIG_From_int((int)(GPGME_STATUS_EOF)));
39713 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_ENTER",SWIG_From_int((int)(GPGME_STATUS_ENTER)));
39714 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_LEAVE",SWIG_From_int((int)(GPGME_STATUS_LEAVE)));
39715 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_ABORT",SWIG_From_int((int)(GPGME_STATUS_ABORT)));
39716 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_GOODSIG",SWIG_From_int((int)(GPGME_STATUS_GOODSIG)));
39717 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_BADSIG",SWIG_From_int((int)(GPGME_STATUS_BADSIG)));
39718 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_ERRSIG",SWIG_From_int((int)(GPGME_STATUS_ERRSIG)));
39719 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_BADARMOR",SWIG_From_int((int)(GPGME_STATUS_BADARMOR)));
39720 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_RSA_OR_IDEA",SWIG_From_int((int)(GPGME_STATUS_RSA_OR_IDEA)));
39721 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_KEYEXPIRED",SWIG_From_int((int)(GPGME_STATUS_KEYEXPIRED)));
39722 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_KEYREVOKED",SWIG_From_int((int)(GPGME_STATUS_KEYREVOKED)));
39723 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_TRUST_UNDEFINED",SWIG_From_int((int)(GPGME_STATUS_TRUST_UNDEFINED)));
39724 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_TRUST_NEVER",SWIG_From_int((int)(GPGME_STATUS_TRUST_NEVER)));
39725 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_TRUST_MARGINAL",SWIG_From_int((int)(GPGME_STATUS_TRUST_MARGINAL)));
39726 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_TRUST_FULLY",SWIG_From_int((int)(GPGME_STATUS_TRUST_FULLY)));
39727 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_TRUST_ULTIMATE",SWIG_From_int((int)(GPGME_STATUS_TRUST_ULTIMATE)));
39728 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SHM_INFO",SWIG_From_int((int)(GPGME_STATUS_SHM_INFO)));
39729 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SHM_GET",SWIG_From_int((int)(GPGME_STATUS_SHM_GET)));
39730 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SHM_GET_BOOL",SWIG_From_int((int)(GPGME_STATUS_SHM_GET_BOOL)));
39731 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SHM_GET_HIDDEN",SWIG_From_int((int)(GPGME_STATUS_SHM_GET_HIDDEN)));
39732 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NEED_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_NEED_PASSPHRASE)));
39733 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_VALIDSIG",SWIG_From_int((int)(GPGME_STATUS_VALIDSIG)));
39734 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SIG_ID",SWIG_From_int((int)(GPGME_STATUS_SIG_ID)));
39735 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_ENC_TO",SWIG_From_int((int)(GPGME_STATUS_ENC_TO)));
39736 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NODATA",SWIG_From_int((int)(GPGME_STATUS_NODATA)));
39737 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_BAD_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_BAD_PASSPHRASE)));
39738 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NO_PUBKEY",SWIG_From_int((int)(GPGME_STATUS_NO_PUBKEY)));
39739 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NO_SECKEY",SWIG_From_int((int)(GPGME_STATUS_NO_SECKEY)));
39740 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NEED_PASSPHRASE_SYM",SWIG_From_int((int)(GPGME_STATUS_NEED_PASSPHRASE_SYM)));
39741 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_DECRYPTION_FAILED",SWIG_From_int((int)(GPGME_STATUS_DECRYPTION_FAILED)));
39742 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_DECRYPTION_OKAY",SWIG_From_int((int)(GPGME_STATUS_DECRYPTION_OKAY)));
39743 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_MISSING_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_MISSING_PASSPHRASE)));
39744 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_GOOD_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_GOOD_PASSPHRASE)));
39745 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_GOODMDC",SWIG_From_int((int)(GPGME_STATUS_GOODMDC)));
39746 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_BADMDC",SWIG_From_int((int)(GPGME_STATUS_BADMDC)));
39747 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_ERRMDC",SWIG_From_int((int)(GPGME_STATUS_ERRMDC)));
39748 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_IMPORTED",SWIG_From_int((int)(GPGME_STATUS_IMPORTED)));
39749 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_IMPORT_OK",SWIG_From_int((int)(GPGME_STATUS_IMPORT_OK)));
39750 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_IMPORT_PROBLEM",SWIG_From_int((int)(GPGME_STATUS_IMPORT_PROBLEM)));
39751 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_IMPORT_RES",SWIG_From_int((int)(GPGME_STATUS_IMPORT_RES)));
39752 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_FILE_START",SWIG_From_int((int)(GPGME_STATUS_FILE_START)));
39753 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_FILE_DONE",SWIG_From_int((int)(GPGME_STATUS_FILE_DONE)));
39754 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_FILE_ERROR",SWIG_From_int((int)(GPGME_STATUS_FILE_ERROR)));
39755 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_BEGIN_DECRYPTION",SWIG_From_int((int)(GPGME_STATUS_BEGIN_DECRYPTION)));
39756 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_END_DECRYPTION",SWIG_From_int((int)(GPGME_STATUS_END_DECRYPTION)));
39757 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_BEGIN_ENCRYPTION",SWIG_From_int((int)(GPGME_STATUS_BEGIN_ENCRYPTION)));
39758 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_END_ENCRYPTION",SWIG_From_int((int)(GPGME_STATUS_END_ENCRYPTION)));
39759 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_DELETE_PROBLEM",SWIG_From_int((int)(GPGME_STATUS_DELETE_PROBLEM)));
39760 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_GET_BOOL",SWIG_From_int((int)(GPGME_STATUS_GET_BOOL)));
39761 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_GET_LINE",SWIG_From_int((int)(GPGME_STATUS_GET_LINE)));
39762 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_GET_HIDDEN",SWIG_From_int((int)(GPGME_STATUS_GET_HIDDEN)));
39763 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_GOT_IT",SWIG_From_int((int)(GPGME_STATUS_GOT_IT)));
39764 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_PROGRESS",SWIG_From_int((int)(GPGME_STATUS_PROGRESS)));
39765 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SIG_CREATED",SWIG_From_int((int)(GPGME_STATUS_SIG_CREATED)));
39766 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SESSION_KEY",SWIG_From_int((int)(GPGME_STATUS_SESSION_KEY)));
39767 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NOTATION_NAME",SWIG_From_int((int)(GPGME_STATUS_NOTATION_NAME)));
39768 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NOTATION_DATA",SWIG_From_int((int)(GPGME_STATUS_NOTATION_DATA)));
39769 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_POLICY_URL",SWIG_From_int((int)(GPGME_STATUS_POLICY_URL)));
39770 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_BEGIN_STREAM",SWIG_From_int((int)(GPGME_STATUS_BEGIN_STREAM)));
39771 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_END_STREAM",SWIG_From_int((int)(GPGME_STATUS_END_STREAM)));
39772 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_KEY_CREATED",SWIG_From_int((int)(GPGME_STATUS_KEY_CREATED)));
39773 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_USERID_HINT",SWIG_From_int((int)(GPGME_STATUS_USERID_HINT)));
39774 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_UNEXPECTED",SWIG_From_int((int)(GPGME_STATUS_UNEXPECTED)));
39775 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_INV_RECP",SWIG_From_int((int)(GPGME_STATUS_INV_RECP)));
39776 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NO_RECP",SWIG_From_int((int)(GPGME_STATUS_NO_RECP)));
39777 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_ALREADY_SIGNED",SWIG_From_int((int)(GPGME_STATUS_ALREADY_SIGNED)));
39778 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SIGEXPIRED",SWIG_From_int((int)(GPGME_STATUS_SIGEXPIRED)));
39779 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_EXPSIG",SWIG_From_int((int)(GPGME_STATUS_EXPSIG)));
39780 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_EXPKEYSIG",SWIG_From_int((int)(GPGME_STATUS_EXPKEYSIG)));
39781 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_TRUNCATED",SWIG_From_int((int)(GPGME_STATUS_TRUNCATED)));
39782 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_ERROR",SWIG_From_int((int)(GPGME_STATUS_ERROR)));
39783 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NEWSIG",SWIG_From_int((int)(GPGME_STATUS_NEWSIG)));
39784 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_REVKEYSIG",SWIG_From_int((int)(GPGME_STATUS_REVKEYSIG)));
39785 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SIG_SUBPACKET",SWIG_From_int((int)(GPGME_STATUS_SIG_SUBPACKET)));
39786 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NEED_PASSPHRASE_PIN",SWIG_From_int((int)(GPGME_STATUS_NEED_PASSPHRASE_PIN)));
39787 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SC_OP_FAILURE",SWIG_From_int((int)(GPGME_STATUS_SC_OP_FAILURE)));
39788 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SC_OP_SUCCESS",SWIG_From_int((int)(GPGME_STATUS_SC_OP_SUCCESS)));
39789 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_CARDCTRL",SWIG_From_int((int)(GPGME_STATUS_CARDCTRL)));
39790 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_BACKUP_KEY_CREATED",SWIG_From_int((int)(GPGME_STATUS_BACKUP_KEY_CREATED)));
39791 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_PKA_TRUST_BAD",SWIG_From_int((int)(GPGME_STATUS_PKA_TRUST_BAD)));
39792 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_PKA_TRUST_GOOD",SWIG_From_int((int)(GPGME_STATUS_PKA_TRUST_GOOD)));
39793 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_PLAINTEXT",SWIG_From_int((int)(GPGME_STATUS_PLAINTEXT)));
39794 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_INV_SGNR",SWIG_From_int((int)(GPGME_STATUS_INV_SGNR)));
39795 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NO_SGNR",SWIG_From_int((int)(GPGME_STATUS_NO_SGNR)));
39796 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_SUCCESS",SWIG_From_int((int)(GPGME_STATUS_SUCCESS)));
39797 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_DECRYPTION_INFO",SWIG_From_int((int)(GPGME_STATUS_DECRYPTION_INFO)));
39798 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_PLAINTEXT_LENGTH",SWIG_From_int((int)(GPGME_STATUS_PLAINTEXT_LENGTH)));
39799 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_MOUNTPOINT",SWIG_From_int((int)(GPGME_STATUS_MOUNTPOINT)));
39800 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_PINENTRY_LAUNCHED",SWIG_From_int((int)(GPGME_STATUS_PINENTRY_LAUNCHED)));
39801 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_ATTRIBUTE",SWIG_From_int((int)(GPGME_STATUS_ATTRIBUTE)));
39802 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_BEGIN_SIGNING",SWIG_From_int((int)(GPGME_STATUS_BEGIN_SIGNING)));
39803 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_KEY_NOT_CREATED",SWIG_From_int((int)(GPGME_STATUS_KEY_NOT_CREATED)));
39804 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_INQUIRE_MAXLEN",SWIG_From_int((int)(GPGME_STATUS_INQUIRE_MAXLEN)));
39805 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_FAILURE",SWIG_From_int((int)(GPGME_STATUS_FAILURE)));
39806 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_KEY_CONSIDERED",SWIG_From_int((int)(GPGME_STATUS_KEY_CONSIDERED)));
39807 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_TOFU_USER",SWIG_From_int((int)(GPGME_STATUS_TOFU_USER)));
39808 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_TOFU_STATS",SWIG_From_int((int)(GPGME_STATUS_TOFU_STATS)));
39809 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_TOFU_STATS_LONG",SWIG_From_int((int)(GPGME_STATUS_TOFU_STATS_LONG)));
39810 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_STATUS_NOTATION_FLAGS",SWIG_From_int((int)(GPGME_STATUS_NOTATION_FLAGS)));
39811 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_NOTATION_HUMAN_READABLE",SWIG_From_int((int)(1)));
39812 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIG_NOTATION_CRITICAL",SWIG_From_int((int)(2)));
39813 :
39814 : /* type '::_gpgme_engine_info' */
39815 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_engine_info_type;
39816 23 : builtin_pytype->tp_dict = d = PyDict_New();
39817 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
39818 23 : builtin_pytype->tp_new = PyType_GenericNew;
39819 23 : builtin_base_count = 0;
39820 23 : builtin_bases[builtin_base_count] = NULL;
39821 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
39822 23 : PyDict_SetItemString(d, "this", this_descr);
39823 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
39824 23 : if (PyType_Ready(builtin_pytype) < 0) {
39825 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_engine_info'.");
39826 : #if PY_VERSION_HEX >= 0x03000000
39827 0 : return NULL;
39828 : #else
39829 : return;
39830 : #endif
39831 : }
39832 23 : Py_INCREF(builtin_pytype);
39833 23 : PyModule_AddObject(m, "_gpgme_engine_info", (PyObject*) builtin_pytype);
39834 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_engine_info");
39835 23 : d = md;
39836 :
39837 : /* type '::_gpgme_tofu_info' */
39838 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_tofu_info_type;
39839 23 : builtin_pytype->tp_dict = d = PyDict_New();
39840 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
39841 23 : builtin_pytype->tp_new = PyType_GenericNew;
39842 23 : builtin_base_count = 0;
39843 23 : builtin_bases[builtin_base_count] = NULL;
39844 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
39845 23 : PyDict_SetItemString(d, "this", this_descr);
39846 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
39847 23 : if (PyType_Ready(builtin_pytype) < 0) {
39848 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_tofu_info'.");
39849 : #if PY_VERSION_HEX >= 0x03000000
39850 0 : return NULL;
39851 : #else
39852 : return;
39853 : #endif
39854 : }
39855 23 : Py_INCREF(builtin_pytype);
39856 23 : PyModule_AddObject(m, "_gpgme_tofu_info", (PyObject*) builtin_pytype);
39857 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_tofu_info");
39858 23 : d = md;
39859 :
39860 : /* type '::_gpgme_subkey' */
39861 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_subkey_type;
39862 23 : builtin_pytype->tp_dict = d = PyDict_New();
39863 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
39864 23 : builtin_pytype->tp_new = PyType_GenericNew;
39865 23 : builtin_base_count = 0;
39866 23 : builtin_bases[builtin_base_count] = NULL;
39867 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
39868 23 : PyDict_SetItemString(d, "this", this_descr);
39869 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
39870 23 : if (PyType_Ready(builtin_pytype) < 0) {
39871 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_subkey'.");
39872 : #if PY_VERSION_HEX >= 0x03000000
39873 0 : return NULL;
39874 : #else
39875 : return;
39876 : #endif
39877 : }
39878 23 : Py_INCREF(builtin_pytype);
39879 23 : PyModule_AddObject(m, "_gpgme_subkey", (PyObject*) builtin_pytype);
39880 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_subkey");
39881 23 : d = md;
39882 :
39883 : /* type '::_gpgme_key_sig' */
39884 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_key_sig_type;
39885 23 : builtin_pytype->tp_dict = d = PyDict_New();
39886 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
39887 23 : builtin_pytype->tp_new = PyType_GenericNew;
39888 23 : builtin_base_count = 0;
39889 23 : builtin_bases[builtin_base_count] = NULL;
39890 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
39891 23 : PyDict_SetItemString(d, "this", this_descr);
39892 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
39893 23 : if (PyType_Ready(builtin_pytype) < 0) {
39894 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_key_sig'.");
39895 : #if PY_VERSION_HEX >= 0x03000000
39896 0 : return NULL;
39897 : #else
39898 : return;
39899 : #endif
39900 : }
39901 23 : Py_INCREF(builtin_pytype);
39902 23 : PyModule_AddObject(m, "_gpgme_key_sig", (PyObject*) builtin_pytype);
39903 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_key_sig");
39904 23 : d = md;
39905 :
39906 : /* type '::_gpgme_user_id' */
39907 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_user_id_type;
39908 23 : builtin_pytype->tp_dict = d = PyDict_New();
39909 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
39910 23 : builtin_pytype->tp_new = PyType_GenericNew;
39911 23 : builtin_base_count = 0;
39912 23 : builtin_bases[builtin_base_count] = NULL;
39913 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
39914 23 : PyDict_SetItemString(d, "this", this_descr);
39915 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
39916 23 : if (PyType_Ready(builtin_pytype) < 0) {
39917 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_user_id'.");
39918 : #if PY_VERSION_HEX >= 0x03000000
39919 0 : return NULL;
39920 : #else
39921 : return;
39922 : #endif
39923 : }
39924 23 : Py_INCREF(builtin_pytype);
39925 23 : PyModule_AddObject(m, "_gpgme_user_id", (PyObject*) builtin_pytype);
39926 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_user_id");
39927 23 : d = md;
39928 :
39929 : /* type '::_gpgme_key' */
39930 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_key_type;
39931 23 : builtin_pytype->tp_dict = d = PyDict_New();
39932 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
39933 23 : builtin_pytype->tp_new = PyType_GenericNew;
39934 23 : builtin_base_count = 0;
39935 23 : builtin_bases[builtin_base_count] = NULL;
39936 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
39937 23 : PyDict_SetItemString(d, "this", this_descr);
39938 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
39939 23 : if (PyType_Ready(builtin_pytype) < 0) {
39940 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_key'.");
39941 : #if PY_VERSION_HEX >= 0x03000000
39942 0 : return NULL;
39943 : #else
39944 : return;
39945 : #endif
39946 : }
39947 23 : Py_INCREF(builtin_pytype);
39948 23 : PyModule_AddObject(m, "_gpgme_key", (PyObject*) builtin_pytype);
39949 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_key");
39950 23 : d = md;
39951 :
39952 : /* type '::_gpgme_invalid_key' */
39953 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_invalid_key_type;
39954 23 : builtin_pytype->tp_dict = d = PyDict_New();
39955 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
39956 23 : builtin_pytype->tp_new = PyType_GenericNew;
39957 23 : builtin_base_count = 0;
39958 23 : builtin_bases[builtin_base_count] = NULL;
39959 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
39960 23 : PyDict_SetItemString(d, "this", this_descr);
39961 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
39962 23 : if (PyType_Ready(builtin_pytype) < 0) {
39963 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_invalid_key'.");
39964 : #if PY_VERSION_HEX >= 0x03000000
39965 0 : return NULL;
39966 : #else
39967 : return;
39968 : #endif
39969 : }
39970 23 : Py_INCREF(builtin_pytype);
39971 23 : PyModule_AddObject(m, "_gpgme_invalid_key", (PyObject*) builtin_pytype);
39972 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_invalid_key");
39973 23 : d = md;
39974 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_INCLUDE_CERTS_DEFAULT",SWIG_From_int((int)(-256)));
39975 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_EVENT_START",SWIG_From_int((int)(GPGME_EVENT_START)));
39976 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_EVENT_DONE",SWIG_From_int((int)(GPGME_EVENT_DONE)));
39977 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_EVENT_NEXT_KEY",SWIG_From_int((int)(GPGME_EVENT_NEXT_KEY)));
39978 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_EVENT_NEXT_TRUSTITEM",SWIG_From_int((int)(GPGME_EVENT_NEXT_TRUSTITEM)));
39979 :
39980 : /* type '::gpgme_io_event_done_data' */
39981 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__gpgme_io_event_done_data_type;
39982 23 : builtin_pytype->tp_dict = d = PyDict_New();
39983 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
39984 23 : builtin_pytype->tp_new = PyType_GenericNew;
39985 23 : builtin_base_count = 0;
39986 23 : builtin_bases[builtin_base_count] = NULL;
39987 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
39988 23 : PyDict_SetItemString(d, "this", this_descr);
39989 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
39990 23 : if (PyType_Ready(builtin_pytype) < 0) {
39991 0 : PyErr_SetString(PyExc_TypeError, "Could not create type 'gpgme_io_event_done_data'.");
39992 : #if PY_VERSION_HEX >= 0x03000000
39993 0 : return NULL;
39994 : #else
39995 : return;
39996 : #endif
39997 : }
39998 23 : Py_INCREF(builtin_pytype);
39999 23 : PyModule_AddObject(m, "gpgme_io_event_done_data", (PyObject*) builtin_pytype);
40000 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "gpgme_io_event_done_data");
40001 23 : d = md;
40002 :
40003 : /* type '::gpgme_io_cbs' */
40004 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__gpgme_io_cbs_type;
40005 23 : builtin_pytype->tp_dict = d = PyDict_New();
40006 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40007 23 : builtin_pytype->tp_new = PyType_GenericNew;
40008 23 : builtin_base_count = 0;
40009 23 : builtin_bases[builtin_base_count] = NULL;
40010 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40011 23 : PyDict_SetItemString(d, "this", this_descr);
40012 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40013 23 : if (PyType_Ready(builtin_pytype) < 0) {
40014 0 : PyErr_SetString(PyExc_TypeError, "Could not create type 'gpgme_io_cbs'.");
40015 : #if PY_VERSION_HEX >= 0x03000000
40016 0 : return NULL;
40017 : #else
40018 : return;
40019 : #endif
40020 : }
40021 23 : Py_INCREF(builtin_pytype);
40022 23 : PyModule_AddObject(m, "gpgme_io_cbs", (PyObject*) builtin_pytype);
40023 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "gpgme_io_cbs");
40024 23 : d = md;
40025 :
40026 : /* type '::gpgme_data_cbs' */
40027 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__gpgme_data_cbs_type;
40028 23 : builtin_pytype->tp_dict = d = PyDict_New();
40029 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40030 23 : builtin_pytype->tp_new = PyType_GenericNew;
40031 23 : builtin_base_count = 0;
40032 23 : builtin_bases[builtin_base_count] = NULL;
40033 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40034 23 : PyDict_SetItemString(d, "this", this_descr);
40035 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40036 23 : if (PyType_Ready(builtin_pytype) < 0) {
40037 0 : PyErr_SetString(PyExc_TypeError, "Could not create type 'gpgme_data_cbs'.");
40038 : #if PY_VERSION_HEX >= 0x03000000
40039 0 : return NULL;
40040 : #else
40041 : return;
40042 : #endif
40043 : }
40044 23 : Py_INCREF(builtin_pytype);
40045 23 : PyModule_AddObject(m, "gpgme_data_cbs", (PyObject*) builtin_pytype);
40046 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "gpgme_data_cbs");
40047 23 : d = md;
40048 :
40049 : /* type '::_gpgme_op_encrypt_result' */
40050 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_op_encrypt_result_type;
40051 23 : builtin_pytype->tp_dict = d = PyDict_New();
40052 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40053 23 : builtin_pytype->tp_new = PyType_GenericNew;
40054 23 : builtin_base_count = 0;
40055 23 : builtin_bases[builtin_base_count] = NULL;
40056 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40057 23 : PyDict_SetItemString(d, "this", this_descr);
40058 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40059 23 : if (PyType_Ready(builtin_pytype) < 0) {
40060 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_op_encrypt_result'.");
40061 : #if PY_VERSION_HEX >= 0x03000000
40062 0 : return NULL;
40063 : #else
40064 : return;
40065 : #endif
40066 : }
40067 23 : Py_INCREF(builtin_pytype);
40068 23 : PyModule_AddObject(m, "_gpgme_op_encrypt_result", (PyObject*) builtin_pytype);
40069 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_op_encrypt_result");
40070 23 : d = md;
40071 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ENCRYPT_ALWAYS_TRUST",SWIG_From_int((int)(GPGME_ENCRYPT_ALWAYS_TRUST)));
40072 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ENCRYPT_NO_ENCRYPT_TO",SWIG_From_int((int)(GPGME_ENCRYPT_NO_ENCRYPT_TO)));
40073 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ENCRYPT_PREPARE",SWIG_From_int((int)(GPGME_ENCRYPT_PREPARE)));
40074 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ENCRYPT_EXPECT_SIGN",SWIG_From_int((int)(GPGME_ENCRYPT_EXPECT_SIGN)));
40075 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ENCRYPT_NO_COMPRESS",SWIG_From_int((int)(GPGME_ENCRYPT_NO_COMPRESS)));
40076 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_ENCRYPT_SYMMETRIC",SWIG_From_int((int)(GPGME_ENCRYPT_SYMMETRIC)));
40077 :
40078 : /* type '::_gpgme_recipient' */
40079 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_recipient_type;
40080 23 : builtin_pytype->tp_dict = d = PyDict_New();
40081 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40082 23 : builtin_pytype->tp_new = PyType_GenericNew;
40083 23 : builtin_base_count = 0;
40084 23 : builtin_bases[builtin_base_count] = NULL;
40085 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40086 23 : PyDict_SetItemString(d, "this", this_descr);
40087 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40088 23 : if (PyType_Ready(builtin_pytype) < 0) {
40089 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_recipient'.");
40090 : #if PY_VERSION_HEX >= 0x03000000
40091 0 : return NULL;
40092 : #else
40093 : return;
40094 : #endif
40095 : }
40096 23 : Py_INCREF(builtin_pytype);
40097 23 : PyModule_AddObject(m, "_gpgme_recipient", (PyObject*) builtin_pytype);
40098 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_recipient");
40099 23 : d = md;
40100 :
40101 : /* type '::_gpgme_op_decrypt_result' */
40102 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_op_decrypt_result_type;
40103 23 : builtin_pytype->tp_dict = d = PyDict_New();
40104 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40105 23 : builtin_pytype->tp_new = PyType_GenericNew;
40106 23 : builtin_base_count = 0;
40107 23 : builtin_bases[builtin_base_count] = NULL;
40108 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40109 23 : PyDict_SetItemString(d, "this", this_descr);
40110 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40111 23 : if (PyType_Ready(builtin_pytype) < 0) {
40112 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_op_decrypt_result'.");
40113 : #if PY_VERSION_HEX >= 0x03000000
40114 0 : return NULL;
40115 : #else
40116 : return;
40117 : #endif
40118 : }
40119 23 : Py_INCREF(builtin_pytype);
40120 23 : PyModule_AddObject(m, "_gpgme_op_decrypt_result", (PyObject*) builtin_pytype);
40121 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_op_decrypt_result");
40122 23 : d = md;
40123 :
40124 : /* type '::_gpgme_new_signature' */
40125 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_new_signature_type;
40126 23 : builtin_pytype->tp_dict = d = PyDict_New();
40127 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40128 23 : builtin_pytype->tp_new = PyType_GenericNew;
40129 23 : builtin_base_count = 0;
40130 23 : builtin_bases[builtin_base_count] = NULL;
40131 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40132 23 : PyDict_SetItemString(d, "this", this_descr);
40133 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40134 23 : if (PyType_Ready(builtin_pytype) < 0) {
40135 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_new_signature'.");
40136 : #if PY_VERSION_HEX >= 0x03000000
40137 0 : return NULL;
40138 : #else
40139 : return;
40140 : #endif
40141 : }
40142 23 : Py_INCREF(builtin_pytype);
40143 23 : PyModule_AddObject(m, "_gpgme_new_signature", (PyObject*) builtin_pytype);
40144 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_new_signature");
40145 23 : d = md;
40146 :
40147 : /* type '::_gpgme_op_sign_result' */
40148 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_op_sign_result_type;
40149 23 : builtin_pytype->tp_dict = d = PyDict_New();
40150 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40151 23 : builtin_pytype->tp_new = PyType_GenericNew;
40152 23 : builtin_base_count = 0;
40153 23 : builtin_bases[builtin_base_count] = NULL;
40154 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40155 23 : PyDict_SetItemString(d, "this", this_descr);
40156 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40157 23 : if (PyType_Ready(builtin_pytype) < 0) {
40158 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_op_sign_result'.");
40159 : #if PY_VERSION_HEX >= 0x03000000
40160 0 : return NULL;
40161 : #else
40162 : return;
40163 : #endif
40164 : }
40165 23 : Py_INCREF(builtin_pytype);
40166 23 : PyModule_AddObject(m, "_gpgme_op_sign_result", (PyObject*) builtin_pytype);
40167 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_op_sign_result");
40168 23 : d = md;
40169 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_VALID",SWIG_From_int((int)(GPGME_SIGSUM_VALID)));
40170 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_GREEN",SWIG_From_int((int)(GPGME_SIGSUM_GREEN)));
40171 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_RED",SWIG_From_int((int)(GPGME_SIGSUM_RED)));
40172 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_KEY_REVOKED",SWIG_From_int((int)(GPGME_SIGSUM_KEY_REVOKED)));
40173 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_KEY_EXPIRED",SWIG_From_int((int)(GPGME_SIGSUM_KEY_EXPIRED)));
40174 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_SIG_EXPIRED",SWIG_From_int((int)(GPGME_SIGSUM_SIG_EXPIRED)));
40175 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_KEY_MISSING",SWIG_From_int((int)(GPGME_SIGSUM_KEY_MISSING)));
40176 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_CRL_MISSING",SWIG_From_int((int)(GPGME_SIGSUM_CRL_MISSING)));
40177 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_CRL_TOO_OLD",SWIG_From_int((int)(GPGME_SIGSUM_CRL_TOO_OLD)));
40178 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_BAD_POLICY",SWIG_From_int((int)(GPGME_SIGSUM_BAD_POLICY)));
40179 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_SYS_ERROR",SWIG_From_int((int)(GPGME_SIGSUM_SYS_ERROR)));
40180 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SIGSUM_TOFU_CONFLICT",SWIG_From_int((int)(GPGME_SIGSUM_TOFU_CONFLICT)));
40181 :
40182 : /* type '::_gpgme_signature' */
40183 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_signature_type;
40184 23 : builtin_pytype->tp_dict = d = PyDict_New();
40185 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40186 23 : builtin_pytype->tp_new = PyType_GenericNew;
40187 23 : builtin_base_count = 0;
40188 23 : builtin_bases[builtin_base_count] = NULL;
40189 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40190 23 : PyDict_SetItemString(d, "this", this_descr);
40191 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40192 23 : if (PyType_Ready(builtin_pytype) < 0) {
40193 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_signature'.");
40194 : #if PY_VERSION_HEX >= 0x03000000
40195 0 : return NULL;
40196 : #else
40197 : return;
40198 : #endif
40199 : }
40200 23 : Py_INCREF(builtin_pytype);
40201 23 : PyModule_AddObject(m, "_gpgme_signature", (PyObject*) builtin_pytype);
40202 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_signature");
40203 23 : d = md;
40204 :
40205 : /* type '::_gpgme_op_verify_result' */
40206 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_op_verify_result_type;
40207 23 : builtin_pytype->tp_dict = d = PyDict_New();
40208 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40209 23 : builtin_pytype->tp_new = PyType_GenericNew;
40210 23 : builtin_base_count = 0;
40211 23 : builtin_bases[builtin_base_count] = NULL;
40212 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40213 23 : PyDict_SetItemString(d, "this", this_descr);
40214 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40215 23 : if (PyType_Ready(builtin_pytype) < 0) {
40216 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_op_verify_result'.");
40217 : #if PY_VERSION_HEX >= 0x03000000
40218 0 : return NULL;
40219 : #else
40220 : return;
40221 : #endif
40222 : }
40223 23 : Py_INCREF(builtin_pytype);
40224 23 : PyModule_AddObject(m, "_gpgme_op_verify_result", (PyObject*) builtin_pytype);
40225 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_op_verify_result");
40226 23 : d = md;
40227 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_IMPORT_NEW",SWIG_From_int((int)(1)));
40228 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_IMPORT_UID",SWIG_From_int((int)(2)));
40229 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_IMPORT_SIG",SWIG_From_int((int)(4)));
40230 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_IMPORT_SUBKEY",SWIG_From_int((int)(8)));
40231 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_IMPORT_SECRET",SWIG_From_int((int)(16)));
40232 :
40233 : /* type '::_gpgme_import_status' */
40234 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_import_status_type;
40235 23 : builtin_pytype->tp_dict = d = PyDict_New();
40236 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40237 23 : builtin_pytype->tp_new = PyType_GenericNew;
40238 23 : builtin_base_count = 0;
40239 23 : builtin_bases[builtin_base_count] = NULL;
40240 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40241 23 : PyDict_SetItemString(d, "this", this_descr);
40242 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40243 23 : if (PyType_Ready(builtin_pytype) < 0) {
40244 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_import_status'.");
40245 : #if PY_VERSION_HEX >= 0x03000000
40246 0 : return NULL;
40247 : #else
40248 : return;
40249 : #endif
40250 : }
40251 23 : Py_INCREF(builtin_pytype);
40252 23 : PyModule_AddObject(m, "_gpgme_import_status", (PyObject*) builtin_pytype);
40253 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_import_status");
40254 23 : d = md;
40255 :
40256 : /* type '::_gpgme_op_import_result' */
40257 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_op_import_result_type;
40258 23 : builtin_pytype->tp_dict = d = PyDict_New();
40259 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40260 23 : builtin_pytype->tp_new = PyType_GenericNew;
40261 23 : builtin_base_count = 0;
40262 23 : builtin_bases[builtin_base_count] = NULL;
40263 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40264 23 : PyDict_SetItemString(d, "this", this_descr);
40265 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40266 23 : if (PyType_Ready(builtin_pytype) < 0) {
40267 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_op_import_result'.");
40268 : #if PY_VERSION_HEX >= 0x03000000
40269 0 : return NULL;
40270 : #else
40271 : return;
40272 : #endif
40273 : }
40274 23 : Py_INCREF(builtin_pytype);
40275 23 : PyModule_AddObject(m, "_gpgme_op_import_result", (PyObject*) builtin_pytype);
40276 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_op_import_result");
40277 23 : d = md;
40278 :
40279 : /* type '::_gpgme_op_genkey_result' */
40280 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_op_genkey_result_type;
40281 23 : builtin_pytype->tp_dict = d = PyDict_New();
40282 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40283 23 : builtin_pytype->tp_new = PyType_GenericNew;
40284 23 : builtin_base_count = 0;
40285 23 : builtin_bases[builtin_base_count] = NULL;
40286 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40287 23 : PyDict_SetItemString(d, "this", this_descr);
40288 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40289 23 : if (PyType_Ready(builtin_pytype) < 0) {
40290 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_op_genkey_result'.");
40291 : #if PY_VERSION_HEX >= 0x03000000
40292 0 : return NULL;
40293 : #else
40294 : return;
40295 : #endif
40296 : }
40297 23 : Py_INCREF(builtin_pytype);
40298 23 : PyModule_AddObject(m, "_gpgme_op_genkey_result", (PyObject*) builtin_pytype);
40299 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_op_genkey_result");
40300 23 : d = md;
40301 :
40302 : /* type '::_gpgme_op_keylist_result' */
40303 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_op_keylist_result_type;
40304 23 : builtin_pytype->tp_dict = d = PyDict_New();
40305 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40306 23 : builtin_pytype->tp_new = PyType_GenericNew;
40307 23 : builtin_base_count = 0;
40308 23 : builtin_bases[builtin_base_count] = NULL;
40309 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40310 23 : PyDict_SetItemString(d, "this", this_descr);
40311 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40312 23 : if (PyType_Ready(builtin_pytype) < 0) {
40313 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_op_keylist_result'.");
40314 : #if PY_VERSION_HEX >= 0x03000000
40315 0 : return NULL;
40316 : #else
40317 : return;
40318 : #endif
40319 : }
40320 23 : Py_INCREF(builtin_pytype);
40321 23 : PyModule_AddObject(m, "_gpgme_op_keylist_result", (PyObject*) builtin_pytype);
40322 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_op_keylist_result");
40323 23 : d = md;
40324 :
40325 : /* type '::_gpgme_trust_item' */
40326 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_trust_item_type;
40327 23 : builtin_pytype->tp_dict = d = PyDict_New();
40328 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40329 23 : builtin_pytype->tp_new = PyType_GenericNew;
40330 23 : builtin_base_count = 0;
40331 23 : builtin_bases[builtin_base_count] = NULL;
40332 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40333 23 : PyDict_SetItemString(d, "this", this_descr);
40334 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40335 23 : if (PyType_Ready(builtin_pytype) < 0) {
40336 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_trust_item'.");
40337 : #if PY_VERSION_HEX >= 0x03000000
40338 0 : return NULL;
40339 : #else
40340 : return;
40341 : #endif
40342 : }
40343 23 : Py_INCREF(builtin_pytype);
40344 23 : PyModule_AddObject(m, "_gpgme_trust_item", (PyObject*) builtin_pytype);
40345 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_trust_item");
40346 23 : d = md;
40347 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SPAWN_DETACHED",SWIG_From_int((int)(1)));
40348 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_SPAWN_ALLOW_SET_FG",SWIG_From_int((int)(2)));
40349 :
40350 : /* type '::_gpgme_op_assuan_result' */
40351 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_op_assuan_result_type;
40352 23 : builtin_pytype->tp_dict = d = PyDict_New();
40353 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40354 23 : builtin_pytype->tp_new = PyType_GenericNew;
40355 23 : builtin_base_count = 0;
40356 23 : builtin_bases[builtin_base_count] = NULL;
40357 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40358 23 : PyDict_SetItemString(d, "this", this_descr);
40359 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40360 23 : if (PyType_Ready(builtin_pytype) < 0) {
40361 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_op_assuan_result'.");
40362 : #if PY_VERSION_HEX >= 0x03000000
40363 0 : return NULL;
40364 : #else
40365 : return;
40366 : #endif
40367 : }
40368 23 : Py_INCREF(builtin_pytype);
40369 23 : PyModule_AddObject(m, "_gpgme_op_assuan_result", (PyObject*) builtin_pytype);
40370 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_op_assuan_result");
40371 23 : d = md;
40372 :
40373 : /* type '::_gpgme_op_vfs_mount_result' */
40374 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin___gpgme_op_vfs_mount_result_type;
40375 23 : builtin_pytype->tp_dict = d = PyDict_New();
40376 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40377 23 : builtin_pytype->tp_new = PyType_GenericNew;
40378 23 : builtin_base_count = 0;
40379 23 : builtin_bases[builtin_base_count] = NULL;
40380 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40381 23 : PyDict_SetItemString(d, "this", this_descr);
40382 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40383 23 : if (PyType_Ready(builtin_pytype) < 0) {
40384 0 : PyErr_SetString(PyExc_TypeError, "Could not create type '_gpgme_op_vfs_mount_result'.");
40385 : #if PY_VERSION_HEX >= 0x03000000
40386 0 : return NULL;
40387 : #else
40388 : return;
40389 : #endif
40390 : }
40391 23 : Py_INCREF(builtin_pytype);
40392 23 : PyModule_AddObject(m, "_gpgme_op_vfs_mount_result", (PyObject*) builtin_pytype);
40393 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "_gpgme_op_vfs_mount_result");
40394 23 : d = md;
40395 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_BASIC",SWIG_From_int((int)(GPGME_CONF_BASIC)));
40396 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_ADVANCED",SWIG_From_int((int)(GPGME_CONF_ADVANCED)));
40397 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_EXPERT",SWIG_From_int((int)(GPGME_CONF_EXPERT)));
40398 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_INVISIBLE",SWIG_From_int((int)(GPGME_CONF_INVISIBLE)));
40399 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_INTERNAL",SWIG_From_int((int)(GPGME_CONF_INTERNAL)));
40400 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_NONE",SWIG_From_int((int)(GPGME_CONF_NONE)));
40401 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_STRING",SWIG_From_int((int)(GPGME_CONF_STRING)));
40402 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_INT32",SWIG_From_int((int)(GPGME_CONF_INT32)));
40403 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_UINT32",SWIG_From_int((int)(GPGME_CONF_UINT32)));
40404 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_FILENAME",SWIG_From_int((int)(GPGME_CONF_FILENAME)));
40405 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_LDAP_SERVER",SWIG_From_int((int)(GPGME_CONF_LDAP_SERVER)));
40406 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_KEY_FPR",SWIG_From_int((int)(GPGME_CONF_KEY_FPR)));
40407 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_PUB_KEY",SWIG_From_int((int)(GPGME_CONF_PUB_KEY)));
40408 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_SEC_KEY",SWIG_From_int((int)(GPGME_CONF_SEC_KEY)));
40409 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_ALIAS_LIST",SWIG_From_int((int)(GPGME_CONF_ALIAS_LIST)));
40410 :
40411 : /* type '::gpgme_conf_arg' */
40412 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__gpgme_conf_arg_type;
40413 23 : builtin_pytype->tp_dict = d = PyDict_New();
40414 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40415 23 : builtin_pytype->tp_new = PyType_GenericNew;
40416 23 : builtin_base_count = 0;
40417 23 : builtin_bases[builtin_base_count] = NULL;
40418 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40419 23 : PyDict_SetItemString(d, "this", this_descr);
40420 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40421 23 : if (PyType_Ready(builtin_pytype) < 0) {
40422 0 : PyErr_SetString(PyExc_TypeError, "Could not create type 'gpgme_conf_arg'.");
40423 : #if PY_VERSION_HEX >= 0x03000000
40424 0 : return NULL;
40425 : #else
40426 : return;
40427 : #endif
40428 : }
40429 23 : Py_INCREF(builtin_pytype);
40430 23 : PyModule_AddObject(m, "gpgme_conf_arg", (PyObject*) builtin_pytype);
40431 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "gpgme_conf_arg");
40432 23 : d = md;
40433 :
40434 : /* type '::gpgme_conf_arg_value' */
40435 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__gpgme_conf_arg_value_type;
40436 23 : builtin_pytype->tp_dict = d = PyDict_New();
40437 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40438 23 : builtin_pytype->tp_new = PyType_GenericNew;
40439 23 : builtin_base_count = 0;
40440 23 : builtin_bases[builtin_base_count] = NULL;
40441 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40442 23 : PyDict_SetItemString(d, "this", this_descr);
40443 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40444 23 : if (PyType_Ready(builtin_pytype) < 0) {
40445 0 : PyErr_SetString(PyExc_TypeError, "Could not create type 'gpgme_conf_arg_value'.");
40446 : #if PY_VERSION_HEX >= 0x03000000
40447 0 : return NULL;
40448 : #else
40449 : return;
40450 : #endif
40451 : }
40452 23 : Py_INCREF(builtin_pytype);
40453 23 : PyModule_AddObject(m, "gpgme_conf_arg_value", (PyObject*) builtin_pytype);
40454 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "gpgme_conf_arg_value");
40455 23 : d = md;
40456 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_GROUP",SWIG_From_int((int)((1 << 0))));
40457 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_OPTIONAL",SWIG_From_int((int)((1 << 1))));
40458 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_LIST",SWIG_From_int((int)((1 << 2))));
40459 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_RUNTIME",SWIG_From_int((int)((1 << 3))));
40460 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_DEFAULT",SWIG_From_int((int)((1 << 4))));
40461 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_DEFAULT_DESC",SWIG_From_int((int)((1 << 5))));
40462 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_NO_ARG_DESC",SWIG_From_int((int)((1 << 6))));
40463 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPGME_CONF_NO_CHANGE",SWIG_From_int((int)((1 << 7))));
40464 :
40465 : /* type '::gpgme_conf_opt' */
40466 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__gpgme_conf_opt_type;
40467 23 : builtin_pytype->tp_dict = d = PyDict_New();
40468 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40469 23 : builtin_pytype->tp_new = PyType_GenericNew;
40470 23 : builtin_base_count = 0;
40471 23 : builtin_bases[builtin_base_count] = NULL;
40472 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40473 23 : PyDict_SetItemString(d, "this", this_descr);
40474 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40475 23 : if (PyType_Ready(builtin_pytype) < 0) {
40476 0 : PyErr_SetString(PyExc_TypeError, "Could not create type 'gpgme_conf_opt'.");
40477 : #if PY_VERSION_HEX >= 0x03000000
40478 0 : return NULL;
40479 : #else
40480 : return;
40481 : #endif
40482 : }
40483 23 : Py_INCREF(builtin_pytype);
40484 23 : PyModule_AddObject(m, "gpgme_conf_opt", (PyObject*) builtin_pytype);
40485 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "gpgme_conf_opt");
40486 23 : d = md;
40487 :
40488 : /* type '::gpgme_conf_comp' */
40489 23 : builtin_pytype = (PyTypeObject *)&SwigPyBuiltin__gpgme_conf_comp_type;
40490 23 : builtin_pytype->tp_dict = d = PyDict_New();
40491 23 : SwigPyBuiltin_SetMetaType(builtin_pytype, metatype);
40492 23 : builtin_pytype->tp_new = PyType_GenericNew;
40493 23 : builtin_base_count = 0;
40494 23 : builtin_bases[builtin_base_count] = NULL;
40495 23 : SwigPyBuiltin_InitBases(builtin_pytype, builtin_bases);
40496 23 : PyDict_SetItemString(d, "this", this_descr);
40497 23 : PyDict_SetItemString(d, "thisown", thisown_descr);
40498 23 : if (PyType_Ready(builtin_pytype) < 0) {
40499 0 : PyErr_SetString(PyExc_TypeError, "Could not create type 'gpgme_conf_comp'.");
40500 : #if PY_VERSION_HEX >= 0x03000000
40501 0 : return NULL;
40502 : #else
40503 : return;
40504 : #endif
40505 : }
40506 23 : Py_INCREF(builtin_pytype);
40507 23 : PyModule_AddObject(m, "gpgme_conf_comp", (PyObject*) builtin_pytype);
40508 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "gpgme_conf_comp");
40509 23 : d = md;
40510 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_UNKNOWN",SWIG_From_long((long)(GPG_ERR_SOURCE_UNKNOWN)));
40511 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_GCRYPT",SWIG_From_long((long)(GPG_ERR_SOURCE_GCRYPT)));
40512 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_GPG",SWIG_From_long((long)(GPG_ERR_SOURCE_GPG)));
40513 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_GPGSM",SWIG_From_long((long)(GPG_ERR_SOURCE_GPGSM)));
40514 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_GPGAGENT",SWIG_From_long((long)(GPG_ERR_SOURCE_GPGAGENT)));
40515 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_PINENTRY",SWIG_From_long((long)(GPG_ERR_SOURCE_PINENTRY)));
40516 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_SCD",SWIG_From_long((long)(GPG_ERR_SOURCE_SCD)));
40517 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_GPGME",SWIG_From_long((long)(GPG_ERR_SOURCE_GPGME)));
40518 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_KEYBOX",SWIG_From_long((long)(GPG_ERR_SOURCE_KEYBOX)));
40519 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_KSBA",SWIG_From_long((long)(GPG_ERR_SOURCE_KSBA)));
40520 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_DIRMNGR",SWIG_From_long((long)(GPG_ERR_SOURCE_DIRMNGR)));
40521 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_GSTI",SWIG_From_long((long)(GPG_ERR_SOURCE_GSTI)));
40522 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_GPA",SWIG_From_long((long)(GPG_ERR_SOURCE_GPA)));
40523 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_KLEO",SWIG_From_long((long)(GPG_ERR_SOURCE_KLEO)));
40524 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_G13",SWIG_From_long((long)(GPG_ERR_SOURCE_G13)));
40525 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_ASSUAN",SWIG_From_long((long)(GPG_ERR_SOURCE_ASSUAN)));
40526 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_TLS",SWIG_From_long((long)(GPG_ERR_SOURCE_TLS)));
40527 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_ANY",SWIG_From_long((long)(GPG_ERR_SOURCE_ANY)));
40528 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_USER_1",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_1)));
40529 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_USER_2",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_2)));
40530 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_USER_3",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_3)));
40531 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_USER_4",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_4)));
40532 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SOURCE_DIM",SWIG_From_long((long)(GPG_ERR_SOURCE_DIM)));
40533 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_ERROR",SWIG_From_long((long)(GPG_ERR_NO_ERROR)));
40534 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_GENERAL",SWIG_From_long((long)(GPG_ERR_GENERAL)));
40535 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_PACKET",SWIG_From_long((long)(GPG_ERR_UNKNOWN_PACKET)));
40536 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_VERSION",SWIG_From_long((long)(GPG_ERR_UNKNOWN_VERSION)));
40537 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_PUBKEY_ALGO",SWIG_From_long((long)(GPG_ERR_PUBKEY_ALGO)));
40538 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_DIGEST_ALGO",SWIG_From_long((long)(GPG_ERR_DIGEST_ALGO)));
40539 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_PUBKEY",SWIG_From_long((long)(GPG_ERR_BAD_PUBKEY)));
40540 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_SECKEY",SWIG_From_long((long)(GPG_ERR_BAD_SECKEY)));
40541 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_SIGNATURE",SWIG_From_long((long)(GPG_ERR_BAD_SIGNATURE)));
40542 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_PUBKEY",SWIG_From_long((long)(GPG_ERR_NO_PUBKEY)));
40543 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CHECKSUM",SWIG_From_long((long)(GPG_ERR_CHECKSUM)));
40544 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_PASSPHRASE",SWIG_From_long((long)(GPG_ERR_BAD_PASSPHRASE)));
40545 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CIPHER_ALGO",SWIG_From_long((long)(GPG_ERR_CIPHER_ALGO)));
40546 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_KEYRING_OPEN",SWIG_From_long((long)(GPG_ERR_KEYRING_OPEN)));
40547 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_PACKET",SWIG_From_long((long)(GPG_ERR_INV_PACKET)));
40548 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_ARMOR",SWIG_From_long((long)(GPG_ERR_INV_ARMOR)));
40549 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_USER_ID",SWIG_From_long((long)(GPG_ERR_NO_USER_ID)));
40550 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_SECKEY",SWIG_From_long((long)(GPG_ERR_NO_SECKEY)));
40551 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_WRONG_SECKEY",SWIG_From_long((long)(GPG_ERR_WRONG_SECKEY)));
40552 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_KEY",SWIG_From_long((long)(GPG_ERR_BAD_KEY)));
40553 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_COMPR_ALGO",SWIG_From_long((long)(GPG_ERR_COMPR_ALGO)));
40554 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_PRIME",SWIG_From_long((long)(GPG_ERR_NO_PRIME)));
40555 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_ENCODING_METHOD",SWIG_From_long((long)(GPG_ERR_NO_ENCODING_METHOD)));
40556 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_ENCRYPTION_SCHEME",SWIG_From_long((long)(GPG_ERR_NO_ENCRYPTION_SCHEME)));
40557 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_SIGNATURE_SCHEME",SWIG_From_long((long)(GPG_ERR_NO_SIGNATURE_SCHEME)));
40558 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_ATTR",SWIG_From_long((long)(GPG_ERR_INV_ATTR)));
40559 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_VALUE",SWIG_From_long((long)(GPG_ERR_NO_VALUE)));
40560 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_NOT_FOUND)));
40561 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_VALUE_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_VALUE_NOT_FOUND)));
40562 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SYNTAX",SWIG_From_long((long)(GPG_ERR_SYNTAX)));
40563 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_MPI",SWIG_From_long((long)(GPG_ERR_BAD_MPI)));
40564 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_PASSPHRASE",SWIG_From_long((long)(GPG_ERR_INV_PASSPHRASE)));
40565 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SIG_CLASS",SWIG_From_long((long)(GPG_ERR_SIG_CLASS)));
40566 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_RESOURCE_LIMIT",SWIG_From_long((long)(GPG_ERR_RESOURCE_LIMIT)));
40567 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_KEYRING",SWIG_From_long((long)(GPG_ERR_INV_KEYRING)));
40568 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_TRUSTDB",SWIG_From_long((long)(GPG_ERR_TRUSTDB)));
40569 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_CERT",SWIG_From_long((long)(GPG_ERR_BAD_CERT)));
40570 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_USER_ID",SWIG_From_long((long)(GPG_ERR_INV_USER_ID)));
40571 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNEXPECTED",SWIG_From_long((long)(GPG_ERR_UNEXPECTED)));
40572 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_TIME_CONFLICT",SWIG_From_long((long)(GPG_ERR_TIME_CONFLICT)));
40573 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_KEYSERVER",SWIG_From_long((long)(GPG_ERR_KEYSERVER)));
40574 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_WRONG_PUBKEY_ALGO",SWIG_From_long((long)(GPG_ERR_WRONG_PUBKEY_ALGO)));
40575 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_TRIBUTE_TO_D_A",SWIG_From_long((long)(GPG_ERR_TRIBUTE_TO_D_A)));
40576 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_WEAK_KEY",SWIG_From_long((long)(GPG_ERR_WEAK_KEY)));
40577 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_KEYLEN",SWIG_From_long((long)(GPG_ERR_INV_KEYLEN)));
40578 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_ARG",SWIG_From_long((long)(GPG_ERR_INV_ARG)));
40579 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_URI",SWIG_From_long((long)(GPG_ERR_BAD_URI)));
40580 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_URI",SWIG_From_long((long)(GPG_ERR_INV_URI)));
40581 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NETWORK",SWIG_From_long((long)(GPG_ERR_NETWORK)));
40582 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_HOST",SWIG_From_long((long)(GPG_ERR_UNKNOWN_HOST)));
40583 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SELFTEST_FAILED",SWIG_From_long((long)(GPG_ERR_SELFTEST_FAILED)));
40584 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_ENCRYPTED",SWIG_From_long((long)(GPG_ERR_NOT_ENCRYPTED)));
40585 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_PROCESSED",SWIG_From_long((long)(GPG_ERR_NOT_PROCESSED)));
40586 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNUSABLE_PUBKEY",SWIG_From_long((long)(GPG_ERR_UNUSABLE_PUBKEY)));
40587 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNUSABLE_SECKEY",SWIG_From_long((long)(GPG_ERR_UNUSABLE_SECKEY)));
40588 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_VALUE",SWIG_From_long((long)(GPG_ERR_INV_VALUE)));
40589 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_CERT_CHAIN",SWIG_From_long((long)(GPG_ERR_BAD_CERT_CHAIN)));
40590 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_MISSING_CERT",SWIG_From_long((long)(GPG_ERR_MISSING_CERT)));
40591 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_DATA",SWIG_From_long((long)(GPG_ERR_NO_DATA)));
40592 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BUG",SWIG_From_long((long)(GPG_ERR_BUG)));
40593 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_SUPPORTED",SWIG_From_long((long)(GPG_ERR_NOT_SUPPORTED)));
40594 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_OP",SWIG_From_long((long)(GPG_ERR_INV_OP)));
40595 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_TIMEOUT",SWIG_From_long((long)(GPG_ERR_TIMEOUT)));
40596 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INTERNAL",SWIG_From_long((long)(GPG_ERR_INTERNAL)));
40597 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EOF_GCRYPT",SWIG_From_long((long)(GPG_ERR_EOF_GCRYPT)));
40598 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_OBJ",SWIG_From_long((long)(GPG_ERR_INV_OBJ)));
40599 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_TOO_SHORT",SWIG_From_long((long)(GPG_ERR_TOO_SHORT)));
40600 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_TOO_LARGE",SWIG_From_long((long)(GPG_ERR_TOO_LARGE)));
40601 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_OBJ",SWIG_From_long((long)(GPG_ERR_NO_OBJ)));
40602 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_IMPLEMENTED",SWIG_From_long((long)(GPG_ERR_NOT_IMPLEMENTED)));
40603 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CONFLICT",SWIG_From_long((long)(GPG_ERR_CONFLICT)));
40604 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_CIPHER_MODE",SWIG_From_long((long)(GPG_ERR_INV_CIPHER_MODE)));
40605 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_FLAG",SWIG_From_long((long)(GPG_ERR_INV_FLAG)));
40606 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_HANDLE",SWIG_From_long((long)(GPG_ERR_INV_HANDLE)));
40607 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_TRUNCATED",SWIG_From_long((long)(GPG_ERR_TRUNCATED)));
40608 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INCOMPLETE_LINE",SWIG_From_long((long)(GPG_ERR_INCOMPLETE_LINE)));
40609 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_RESPONSE",SWIG_From_long((long)(GPG_ERR_INV_RESPONSE)));
40610 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_AGENT",SWIG_From_long((long)(GPG_ERR_NO_AGENT)));
40611 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_AGENT",SWIG_From_long((long)(GPG_ERR_AGENT)));
40612 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_DATA",SWIG_From_long((long)(GPG_ERR_INV_DATA)));
40613 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASSUAN_SERVER_FAULT",SWIG_From_long((long)(GPG_ERR_ASSUAN_SERVER_FAULT)));
40614 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASSUAN",SWIG_From_long((long)(GPG_ERR_ASSUAN)));
40615 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_SESSION_KEY",SWIG_From_long((long)(GPG_ERR_INV_SESSION_KEY)));
40616 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_SEXP",SWIG_From_long((long)(GPG_ERR_INV_SEXP)));
40617 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNSUPPORTED_ALGORITHM",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_ALGORITHM)));
40618 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_PIN_ENTRY",SWIG_From_long((long)(GPG_ERR_NO_PIN_ENTRY)));
40619 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_PIN_ENTRY",SWIG_From_long((long)(GPG_ERR_PIN_ENTRY)));
40620 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_PIN",SWIG_From_long((long)(GPG_ERR_BAD_PIN)));
40621 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_NAME",SWIG_From_long((long)(GPG_ERR_INV_NAME)));
40622 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_DATA",SWIG_From_long((long)(GPG_ERR_BAD_DATA)));
40623 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_PARAMETER",SWIG_From_long((long)(GPG_ERR_INV_PARAMETER)));
40624 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_WRONG_CARD",SWIG_From_long((long)(GPG_ERR_WRONG_CARD)));
40625 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_DIRMNGR",SWIG_From_long((long)(GPG_ERR_NO_DIRMNGR)));
40626 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_DIRMNGR",SWIG_From_long((long)(GPG_ERR_DIRMNGR)));
40627 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CERT_REVOKED",SWIG_From_long((long)(GPG_ERR_CERT_REVOKED)));
40628 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_CRL_KNOWN",SWIG_From_long((long)(GPG_ERR_NO_CRL_KNOWN)));
40629 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CRL_TOO_OLD",SWIG_From_long((long)(GPG_ERR_CRL_TOO_OLD)));
40630 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LINE_TOO_LONG",SWIG_From_long((long)(GPG_ERR_LINE_TOO_LONG)));
40631 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_TRUSTED",SWIG_From_long((long)(GPG_ERR_NOT_TRUSTED)));
40632 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CANCELED",SWIG_From_long((long)(GPG_ERR_CANCELED)));
40633 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_CA_CERT",SWIG_From_long((long)(GPG_ERR_BAD_CA_CERT)));
40634 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CERT_EXPIRED",SWIG_From_long((long)(GPG_ERR_CERT_EXPIRED)));
40635 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CERT_TOO_YOUNG",SWIG_From_long((long)(GPG_ERR_CERT_TOO_YOUNG)));
40636 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNSUPPORTED_CERT",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CERT)));
40637 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_SEXP",SWIG_From_long((long)(GPG_ERR_UNKNOWN_SEXP)));
40638 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNSUPPORTED_PROTECTION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_PROTECTION)));
40639 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CORRUPTED_PROTECTION",SWIG_From_long((long)(GPG_ERR_CORRUPTED_PROTECTION)));
40640 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_AMBIGUOUS_NAME",SWIG_From_long((long)(GPG_ERR_AMBIGUOUS_NAME)));
40641 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CARD",SWIG_From_long((long)(GPG_ERR_CARD)));
40642 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CARD_RESET",SWIG_From_long((long)(GPG_ERR_CARD_RESET)));
40643 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CARD_REMOVED",SWIG_From_long((long)(GPG_ERR_CARD_REMOVED)));
40644 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_CARD",SWIG_From_long((long)(GPG_ERR_INV_CARD)));
40645 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CARD_NOT_PRESENT",SWIG_From_long((long)(GPG_ERR_CARD_NOT_PRESENT)));
40646 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_PKCS15_APP",SWIG_From_long((long)(GPG_ERR_NO_PKCS15_APP)));
40647 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_CONFIRMED",SWIG_From_long((long)(GPG_ERR_NOT_CONFIRMED)));
40648 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CONFIGURATION",SWIG_From_long((long)(GPG_ERR_CONFIGURATION)));
40649 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_POLICY_MATCH",SWIG_From_long((long)(GPG_ERR_NO_POLICY_MATCH)));
40650 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_INDEX",SWIG_From_long((long)(GPG_ERR_INV_INDEX)));
40651 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_ID",SWIG_From_long((long)(GPG_ERR_INV_ID)));
40652 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_SCDAEMON",SWIG_From_long((long)(GPG_ERR_NO_SCDAEMON)));
40653 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SCDAEMON",SWIG_From_long((long)(GPG_ERR_SCDAEMON)));
40654 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNSUPPORTED_PROTOCOL",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_PROTOCOL)));
40655 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_PIN_METHOD",SWIG_From_long((long)(GPG_ERR_BAD_PIN_METHOD)));
40656 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CARD_NOT_INITIALIZED",SWIG_From_long((long)(GPG_ERR_CARD_NOT_INITIALIZED)));
40657 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNSUPPORTED_OPERATION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_OPERATION)));
40658 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_WRONG_KEY_USAGE",SWIG_From_long((long)(GPG_ERR_WRONG_KEY_USAGE)));
40659 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOTHING_FOUND",SWIG_From_long((long)(GPG_ERR_NOTHING_FOUND)));
40660 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_WRONG_BLOB_TYPE",SWIG_From_long((long)(GPG_ERR_WRONG_BLOB_TYPE)));
40661 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_MISSING_VALUE",SWIG_From_long((long)(GPG_ERR_MISSING_VALUE)));
40662 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_HARDWARE",SWIG_From_long((long)(GPG_ERR_HARDWARE)));
40663 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_PIN_BLOCKED",SWIG_From_long((long)(GPG_ERR_PIN_BLOCKED)));
40664 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USE_CONDITIONS",SWIG_From_long((long)(GPG_ERR_USE_CONDITIONS)));
40665 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_PIN_NOT_SYNCED",SWIG_From_long((long)(GPG_ERR_PIN_NOT_SYNCED)));
40666 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_CRL",SWIG_From_long((long)(GPG_ERR_INV_CRL)));
40667 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_BER",SWIG_From_long((long)(GPG_ERR_BAD_BER)));
40668 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_BER",SWIG_From_long((long)(GPG_ERR_INV_BER)));
40669 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ELEMENT_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_ELEMENT_NOT_FOUND)));
40670 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_IDENTIFIER_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_IDENTIFIER_NOT_FOUND)));
40671 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_TAG",SWIG_From_long((long)(GPG_ERR_INV_TAG)));
40672 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_LENGTH",SWIG_From_long((long)(GPG_ERR_INV_LENGTH)));
40673 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_KEYINFO",SWIG_From_long((long)(GPG_ERR_INV_KEYINFO)));
40674 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNEXPECTED_TAG",SWIG_From_long((long)(GPG_ERR_UNEXPECTED_TAG)));
40675 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_DER_ENCODED",SWIG_From_long((long)(GPG_ERR_NOT_DER_ENCODED)));
40676 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_NO_CMS_OBJ)));
40677 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_INV_CMS_OBJ)));
40678 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_UNKNOWN_CMS_OBJ)));
40679 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNSUPPORTED_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CMS_OBJ)));
40680 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNSUPPORTED_ENCODING",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_ENCODING)));
40681 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNSUPPORTED_CMS_VERSION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CMS_VERSION)));
40682 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_ALGORITHM",SWIG_From_long((long)(GPG_ERR_UNKNOWN_ALGORITHM)));
40683 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_ENGINE",SWIG_From_long((long)(GPG_ERR_INV_ENGINE)));
40684 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_PUBKEY_NOT_TRUSTED",SWIG_From_long((long)(GPG_ERR_PUBKEY_NOT_TRUSTED)));
40685 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_DECRYPT_FAILED",SWIG_From_long((long)(GPG_ERR_DECRYPT_FAILED)));
40686 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_KEY_EXPIRED",SWIG_From_long((long)(GPG_ERR_KEY_EXPIRED)));
40687 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SIG_EXPIRED",SWIG_From_long((long)(GPG_ERR_SIG_EXPIRED)));
40688 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENCODING_PROBLEM",SWIG_From_long((long)(GPG_ERR_ENCODING_PROBLEM)));
40689 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_STATE",SWIG_From_long((long)(GPG_ERR_INV_STATE)));
40690 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_DUP_VALUE",SWIG_From_long((long)(GPG_ERR_DUP_VALUE)));
40691 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_MISSING_ACTION",SWIG_From_long((long)(GPG_ERR_MISSING_ACTION)));
40692 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_MODULE_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_MODULE_NOT_FOUND)));
40693 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_OID_STRING",SWIG_From_long((long)(GPG_ERR_INV_OID_STRING)));
40694 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_TIME",SWIG_From_long((long)(GPG_ERR_INV_TIME)));
40695 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_CRL_OBJ",SWIG_From_long((long)(GPG_ERR_INV_CRL_OBJ)));
40696 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNSUPPORTED_CRL_VERSION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CRL_VERSION)));
40697 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_CERT_OBJ",SWIG_From_long((long)(GPG_ERR_INV_CERT_OBJ)));
40698 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_NAME",SWIG_From_long((long)(GPG_ERR_UNKNOWN_NAME)));
40699 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LOCALE_PROBLEM",SWIG_From_long((long)(GPG_ERR_LOCALE_PROBLEM)));
40700 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_LOCKED",SWIG_From_long((long)(GPG_ERR_NOT_LOCKED)));
40701 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_PROTOCOL_VIOLATION",SWIG_From_long((long)(GPG_ERR_PROTOCOL_VIOLATION)));
40702 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_MAC",SWIG_From_long((long)(GPG_ERR_INV_MAC)));
40703 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_REQUEST",SWIG_From_long((long)(GPG_ERR_INV_REQUEST)));
40704 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_EXTN",SWIG_From_long((long)(GPG_ERR_UNKNOWN_EXTN)));
40705 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_CRIT_EXTN",SWIG_From_long((long)(GPG_ERR_UNKNOWN_CRIT_EXTN)));
40706 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LOCKED",SWIG_From_long((long)(GPG_ERR_LOCKED)));
40707 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_OPTION",SWIG_From_long((long)(GPG_ERR_UNKNOWN_OPTION)));
40708 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_COMMAND",SWIG_From_long((long)(GPG_ERR_UNKNOWN_COMMAND)));
40709 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_OPERATIONAL",SWIG_From_long((long)(GPG_ERR_NOT_OPERATIONAL)));
40710 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_PASSPHRASE",SWIG_From_long((long)(GPG_ERR_NO_PASSPHRASE)));
40711 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_PIN",SWIG_From_long((long)(GPG_ERR_NO_PIN)));
40712 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_ENABLED",SWIG_From_long((long)(GPG_ERR_NOT_ENABLED)));
40713 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_ENGINE",SWIG_From_long((long)(GPG_ERR_NO_ENGINE)));
40714 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_MISSING_KEY",SWIG_From_long((long)(GPG_ERR_MISSING_KEY)));
40715 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_TOO_MANY",SWIG_From_long((long)(GPG_ERR_TOO_MANY)));
40716 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LIMIT_REACHED",SWIG_From_long((long)(GPG_ERR_LIMIT_REACHED)));
40717 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NOT_INITIALIZED",SWIG_From_long((long)(GPG_ERR_NOT_INITIALIZED)));
40718 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_MISSING_ISSUER_CERT",SWIG_From_long((long)(GPG_ERR_MISSING_ISSUER_CERT)));
40719 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_KEYSERVER",SWIG_From_long((long)(GPG_ERR_NO_KEYSERVER)));
40720 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_CURVE",SWIG_From_long((long)(GPG_ERR_INV_CURVE)));
40721 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_CURVE",SWIG_From_long((long)(GPG_ERR_UNKNOWN_CURVE)));
40722 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_DUP_KEY",SWIG_From_long((long)(GPG_ERR_DUP_KEY)));
40723 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_AMBIGUOUS",SWIG_From_long((long)(GPG_ERR_AMBIGUOUS)));
40724 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_CRYPT_CTX",SWIG_From_long((long)(GPG_ERR_NO_CRYPT_CTX)));
40725 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_WRONG_CRYPT_CTX",SWIG_From_long((long)(GPG_ERR_WRONG_CRYPT_CTX)));
40726 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_CRYPT_CTX",SWIG_From_long((long)(GPG_ERR_BAD_CRYPT_CTX)));
40727 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CRYPT_CTX_CONFLICT",SWIG_From_long((long)(GPG_ERR_CRYPT_CTX_CONFLICT)));
40728 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BROKEN_PUBKEY",SWIG_From_long((long)(GPG_ERR_BROKEN_PUBKEY)));
40729 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BROKEN_SECKEY",SWIG_From_long((long)(GPG_ERR_BROKEN_SECKEY)));
40730 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_MAC_ALGO",SWIG_From_long((long)(GPG_ERR_MAC_ALGO)));
40731 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_FULLY_CANCELED",SWIG_From_long((long)(GPG_ERR_FULLY_CANCELED)));
40732 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNFINISHED",SWIG_From_long((long)(GPG_ERR_UNFINISHED)));
40733 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BUFFER_TOO_SHORT",SWIG_From_long((long)(GPG_ERR_BUFFER_TOO_SHORT)));
40734 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_INV_LEN_SPEC",SWIG_From_long((long)(GPG_ERR_SEXP_INV_LEN_SPEC)));
40735 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_STRING_TOO_LONG",SWIG_From_long((long)(GPG_ERR_SEXP_STRING_TOO_LONG)));
40736 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_UNMATCHED_PAREN",SWIG_From_long((long)(GPG_ERR_SEXP_UNMATCHED_PAREN)));
40737 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_NOT_CANONICAL",SWIG_From_long((long)(GPG_ERR_SEXP_NOT_CANONICAL)));
40738 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_BAD_CHARACTER",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_CHARACTER)));
40739 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_BAD_QUOTATION",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_QUOTATION)));
40740 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_ZERO_PREFIX",SWIG_From_long((long)(GPG_ERR_SEXP_ZERO_PREFIX)));
40741 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_NESTED_DH",SWIG_From_long((long)(GPG_ERR_SEXP_NESTED_DH)));
40742 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_UNMATCHED_DH",SWIG_From_long((long)(GPG_ERR_SEXP_UNMATCHED_DH)));
40743 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_UNEXPECTED_PUNC",SWIG_From_long((long)(GPG_ERR_SEXP_UNEXPECTED_PUNC)));
40744 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_BAD_HEX_CHAR",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_HEX_CHAR)));
40745 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_ODD_HEX_NUMBERS",SWIG_From_long((long)(GPG_ERR_SEXP_ODD_HEX_NUMBERS)));
40746 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SEXP_BAD_OCT_CHAR",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_OCT_CHAR)));
40747 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SUBKEYS_EXP_OR_REV",SWIG_From_long((long)(GPG_ERR_SUBKEYS_EXP_OR_REV)));
40748 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_DB_CORRUPTED",SWIG_From_long((long)(GPG_ERR_DB_CORRUPTED)));
40749 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_SERVER_FAILED",SWIG_From_long((long)(GPG_ERR_SERVER_FAILED)));
40750 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_NAME",SWIG_From_long((long)(GPG_ERR_NO_NAME)));
40751 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_KEY",SWIG_From_long((long)(GPG_ERR_NO_KEY)));
40752 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LEGACY_KEY",SWIG_From_long((long)(GPG_ERR_LEGACY_KEY)));
40753 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_REQUEST_TOO_SHORT",SWIG_From_long((long)(GPG_ERR_REQUEST_TOO_SHORT)));
40754 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_REQUEST_TOO_LONG",SWIG_From_long((long)(GPG_ERR_REQUEST_TOO_LONG)));
40755 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_OBJ_TERM_STATE",SWIG_From_long((long)(GPG_ERR_OBJ_TERM_STATE)));
40756 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_CERT_CHAIN",SWIG_From_long((long)(GPG_ERR_NO_CERT_CHAIN)));
40757 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CERT_TOO_LARGE",SWIG_From_long((long)(GPG_ERR_CERT_TOO_LARGE)));
40758 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_RECORD",SWIG_From_long((long)(GPG_ERR_INV_RECORD)));
40759 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_MAC",SWIG_From_long((long)(GPG_ERR_BAD_MAC)));
40760 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNEXPECTED_MSG",SWIG_From_long((long)(GPG_ERR_UNEXPECTED_MSG)));
40761 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_COMPR_FAILED",SWIG_From_long((long)(GPG_ERR_COMPR_FAILED)));
40762 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_WOULD_WRAP",SWIG_From_long((long)(GPG_ERR_WOULD_WRAP)));
40763 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_FATAL_ALERT",SWIG_From_long((long)(GPG_ERR_FATAL_ALERT)));
40764 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_NO_CIPHER",SWIG_From_long((long)(GPG_ERR_NO_CIPHER)));
40765 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_MISSING_CLIENT_CERT",SWIG_From_long((long)(GPG_ERR_MISSING_CLIENT_CERT)));
40766 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CLOSE_NOTIFY",SWIG_From_long((long)(GPG_ERR_CLOSE_NOTIFY)));
40767 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_TICKET_EXPIRED",SWIG_From_long((long)(GPG_ERR_TICKET_EXPIRED)));
40768 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_TICKET",SWIG_From_long((long)(GPG_ERR_BAD_TICKET)));
40769 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_IDENTITY",SWIG_From_long((long)(GPG_ERR_UNKNOWN_IDENTITY)));
40770 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_HS_CERT",SWIG_From_long((long)(GPG_ERR_BAD_HS_CERT)));
40771 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_HS_CERT_REQ",SWIG_From_long((long)(GPG_ERR_BAD_HS_CERT_REQ)));
40772 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_HS_CERT_VER",SWIG_From_long((long)(GPG_ERR_BAD_HS_CERT_VER)));
40773 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_HS_CHANGE_CIPHER",SWIG_From_long((long)(GPG_ERR_BAD_HS_CHANGE_CIPHER)));
40774 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_HS_CLIENT_HELLO",SWIG_From_long((long)(GPG_ERR_BAD_HS_CLIENT_HELLO)));
40775 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_HS_SERVER_HELLO",SWIG_From_long((long)(GPG_ERR_BAD_HS_SERVER_HELLO)));
40776 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_HS_SERVER_HELLO_DONE",SWIG_From_long((long)(GPG_ERR_BAD_HS_SERVER_HELLO_DONE)));
40777 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_HS_FINISHED",SWIG_From_long((long)(GPG_ERR_BAD_HS_FINISHED)));
40778 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_HS_SERVER_KEX",SWIG_From_long((long)(GPG_ERR_BAD_HS_SERVER_KEX)));
40779 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BAD_HS_CLIENT_KEX",SWIG_From_long((long)(GPG_ERR_BAD_HS_CLIENT_KEX)));
40780 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_BOGUS_STRING",SWIG_From_long((long)(GPG_ERR_BOGUS_STRING)));
40781 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_FORBIDDEN",SWIG_From_long((long)(GPG_ERR_FORBIDDEN)));
40782 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_KEY_DISABLED",SWIG_From_long((long)(GPG_ERR_KEY_DISABLED)));
40783 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_KEY_ON_CARD",SWIG_From_long((long)(GPG_ERR_KEY_ON_CARD)));
40784 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_INV_LOCK_OBJ",SWIG_From_long((long)(GPG_ERR_INV_LOCK_OBJ)));
40785 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_TRUE",SWIG_From_long((long)(GPG_ERR_TRUE)));
40786 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_FALSE",SWIG_From_long((long)(GPG_ERR_FALSE)));
40787 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_GENERAL",SWIG_From_long((long)(GPG_ERR_ASS_GENERAL)));
40788 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_ACCEPT_FAILED",SWIG_From_long((long)(GPG_ERR_ASS_ACCEPT_FAILED)));
40789 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_CONNECT_FAILED",SWIG_From_long((long)(GPG_ERR_ASS_CONNECT_FAILED)));
40790 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_INV_RESPONSE",SWIG_From_long((long)(GPG_ERR_ASS_INV_RESPONSE)));
40791 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_INV_VALUE",SWIG_From_long((long)(GPG_ERR_ASS_INV_VALUE)));
40792 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_INCOMPLETE_LINE",SWIG_From_long((long)(GPG_ERR_ASS_INCOMPLETE_LINE)));
40793 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_LINE_TOO_LONG",SWIG_From_long((long)(GPG_ERR_ASS_LINE_TOO_LONG)));
40794 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_NESTED_COMMANDS",SWIG_From_long((long)(GPG_ERR_ASS_NESTED_COMMANDS)));
40795 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_NO_DATA_CB",SWIG_From_long((long)(GPG_ERR_ASS_NO_DATA_CB)));
40796 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_NO_INQUIRE_CB",SWIG_From_long((long)(GPG_ERR_ASS_NO_INQUIRE_CB)));
40797 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_NOT_A_SERVER",SWIG_From_long((long)(GPG_ERR_ASS_NOT_A_SERVER)));
40798 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_NOT_A_CLIENT",SWIG_From_long((long)(GPG_ERR_ASS_NOT_A_CLIENT)));
40799 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_SERVER_START",SWIG_From_long((long)(GPG_ERR_ASS_SERVER_START)));
40800 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_READ_ERROR",SWIG_From_long((long)(GPG_ERR_ASS_READ_ERROR)));
40801 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_WRITE_ERROR",SWIG_From_long((long)(GPG_ERR_ASS_WRITE_ERROR)));
40802 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_TOO_MUCH_DATA",SWIG_From_long((long)(GPG_ERR_ASS_TOO_MUCH_DATA)));
40803 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_UNEXPECTED_CMD",SWIG_From_long((long)(GPG_ERR_ASS_UNEXPECTED_CMD)));
40804 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_UNKNOWN_CMD",SWIG_From_long((long)(GPG_ERR_ASS_UNKNOWN_CMD)));
40805 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_SYNTAX",SWIG_From_long((long)(GPG_ERR_ASS_SYNTAX)));
40806 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_CANCELED",SWIG_From_long((long)(GPG_ERR_ASS_CANCELED)));
40807 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_NO_INPUT",SWIG_From_long((long)(GPG_ERR_ASS_NO_INPUT)));
40808 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_NO_OUTPUT",SWIG_From_long((long)(GPG_ERR_ASS_NO_OUTPUT)));
40809 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_PARAMETER",SWIG_From_long((long)(GPG_ERR_ASS_PARAMETER)));
40810 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ASS_UNKNOWN_INQUIRE",SWIG_From_long((long)(GPG_ERR_ASS_UNKNOWN_INQUIRE)));
40811 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENGINE_TOO_OLD",SWIG_From_long((long)(GPG_ERR_ENGINE_TOO_OLD)));
40812 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_GENERAL)));
40813 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_ATTR_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_ATTR_GENERAL)));
40814 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_NAME_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_NAME_GENERAL)));
40815 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_SECURITY_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_SECURITY_GENERAL)));
40816 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_SERVICE_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_SERVICE_GENERAL)));
40817 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_UPDATE_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_UPDATE_GENERAL)));
40818 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_E_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_E_GENERAL)));
40819 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_X_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_X_GENERAL)));
40820 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_OTHER_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_OTHER_GENERAL)));
40821 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_X_CONNECTING",SWIG_From_long((long)(GPG_ERR_LDAP_X_CONNECTING)));
40822 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_REFERRAL_LIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_REFERRAL_LIMIT)));
40823 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CLIENT_LOOP",SWIG_From_long((long)(GPG_ERR_LDAP_CLIENT_LOOP)));
40824 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_NO_RESULTS",SWIG_From_long((long)(GPG_ERR_LDAP_NO_RESULTS)));
40825 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CONTROL_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_LDAP_CONTROL_NOT_FOUND)));
40826 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_NOT_SUPPORTED",SWIG_From_long((long)(GPG_ERR_LDAP_NOT_SUPPORTED)));
40827 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CONNECT",SWIG_From_long((long)(GPG_ERR_LDAP_CONNECT)));
40828 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_NO_MEMORY",SWIG_From_long((long)(GPG_ERR_LDAP_NO_MEMORY)));
40829 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_PARAM",SWIG_From_long((long)(GPG_ERR_LDAP_PARAM)));
40830 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_USER_CANCELLED",SWIG_From_long((long)(GPG_ERR_LDAP_USER_CANCELLED)));
40831 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_FILTER",SWIG_From_long((long)(GPG_ERR_LDAP_FILTER)));
40832 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_AUTH_UNKNOWN",SWIG_From_long((long)(GPG_ERR_LDAP_AUTH_UNKNOWN)));
40833 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_TIMEOUT",SWIG_From_long((long)(GPG_ERR_LDAP_TIMEOUT)));
40834 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_DECODING",SWIG_From_long((long)(GPG_ERR_LDAP_DECODING)));
40835 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_ENCODING",SWIG_From_long((long)(GPG_ERR_LDAP_ENCODING)));
40836 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_LOCAL",SWIG_From_long((long)(GPG_ERR_LDAP_LOCAL)));
40837 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_SERVER_DOWN",SWIG_From_long((long)(GPG_ERR_LDAP_SERVER_DOWN)));
40838 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_SUCCESS",SWIG_From_long((long)(GPG_ERR_LDAP_SUCCESS)));
40839 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_OPERATIONS",SWIG_From_long((long)(GPG_ERR_LDAP_OPERATIONS)));
40840 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_PROTOCOL",SWIG_From_long((long)(GPG_ERR_LDAP_PROTOCOL)));
40841 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_TIMELIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_TIMELIMIT)));
40842 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_SIZELIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_SIZELIMIT)));
40843 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_COMPARE_FALSE",SWIG_From_long((long)(GPG_ERR_LDAP_COMPARE_FALSE)));
40844 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_COMPARE_TRUE",SWIG_From_long((long)(GPG_ERR_LDAP_COMPARE_TRUE)));
40845 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_UNSUPPORTED_AUTH",SWIG_From_long((long)(GPG_ERR_LDAP_UNSUPPORTED_AUTH)));
40846 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_STRONG_AUTH_RQRD",SWIG_From_long((long)(GPG_ERR_LDAP_STRONG_AUTH_RQRD)));
40847 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_PARTIAL_RESULTS",SWIG_From_long((long)(GPG_ERR_LDAP_PARTIAL_RESULTS)));
40848 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_REFERRAL",SWIG_From_long((long)(GPG_ERR_LDAP_REFERRAL)));
40849 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_ADMINLIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_ADMINLIMIT)));
40850 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN",SWIG_From_long((long)(GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN)));
40851 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CONFIDENT_RQRD",SWIG_From_long((long)(GPG_ERR_LDAP_CONFIDENT_RQRD)));
40852 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_SASL_BIND_INPROG",SWIG_From_long((long)(GPG_ERR_LDAP_SASL_BIND_INPROG)));
40853 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE",SWIG_From_long((long)(GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE)));
40854 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_UNDEFINED_TYPE",SWIG_From_long((long)(GPG_ERR_LDAP_UNDEFINED_TYPE)));
40855 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_BAD_MATCHING",SWIG_From_long((long)(GPG_ERR_LDAP_BAD_MATCHING)));
40856 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CONST_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_CONST_VIOLATION)));
40857 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_TYPE_VALUE_EXISTS",SWIG_From_long((long)(GPG_ERR_LDAP_TYPE_VALUE_EXISTS)));
40858 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_INV_SYNTAX",SWIG_From_long((long)(GPG_ERR_LDAP_INV_SYNTAX)));
40859 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_NO_SUCH_OBJ",SWIG_From_long((long)(GPG_ERR_LDAP_NO_SUCH_OBJ)));
40860 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_ALIAS_PROBLEM",SWIG_From_long((long)(GPG_ERR_LDAP_ALIAS_PROBLEM)));
40861 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_INV_DN_SYNTAX",SWIG_From_long((long)(GPG_ERR_LDAP_INV_DN_SYNTAX)));
40862 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_IS_LEAF",SWIG_From_long((long)(GPG_ERR_LDAP_IS_LEAF)));
40863 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_ALIAS_DEREF",SWIG_From_long((long)(GPG_ERR_LDAP_ALIAS_DEREF)));
40864 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_X_PROXY_AUTH_FAIL",SWIG_From_long((long)(GPG_ERR_LDAP_X_PROXY_AUTH_FAIL)));
40865 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_BAD_AUTH",SWIG_From_long((long)(GPG_ERR_LDAP_BAD_AUTH)));
40866 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_INV_CREDENTIALS",SWIG_From_long((long)(GPG_ERR_LDAP_INV_CREDENTIALS)));
40867 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_INSUFFICIENT_ACC",SWIG_From_long((long)(GPG_ERR_LDAP_INSUFFICIENT_ACC)));
40868 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_BUSY",SWIG_From_long((long)(GPG_ERR_LDAP_BUSY)));
40869 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_UNAVAILABLE",SWIG_From_long((long)(GPG_ERR_LDAP_UNAVAILABLE)));
40870 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_UNWILL_TO_PERFORM",SWIG_From_long((long)(GPG_ERR_LDAP_UNWILL_TO_PERFORM)));
40871 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_LOOP_DETECT",SWIG_From_long((long)(GPG_ERR_LDAP_LOOP_DETECT)));
40872 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_NAMING_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_NAMING_VIOLATION)));
40873 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_OBJ_CLS_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_OBJ_CLS_VIOLATION)));
40874 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_NOT_ALLOW_NONLEAF",SWIG_From_long((long)(GPG_ERR_LDAP_NOT_ALLOW_NONLEAF)));
40875 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_NOT_ALLOW_ON_RDN",SWIG_From_long((long)(GPG_ERR_LDAP_NOT_ALLOW_ON_RDN)));
40876 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_ALREADY_EXISTS",SWIG_From_long((long)(GPG_ERR_LDAP_ALREADY_EXISTS)));
40877 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_NO_OBJ_CLASS_MODS",SWIG_From_long((long)(GPG_ERR_LDAP_NO_OBJ_CLASS_MODS)));
40878 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_RESULTS_TOO_LARGE",SWIG_From_long((long)(GPG_ERR_LDAP_RESULTS_TOO_LARGE)));
40879 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_AFFECTS_MULT_DSAS",SWIG_From_long((long)(GPG_ERR_LDAP_AFFECTS_MULT_DSAS)));
40880 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_VLV",SWIG_From_long((long)(GPG_ERR_LDAP_VLV)));
40881 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_OTHER",SWIG_From_long((long)(GPG_ERR_LDAP_OTHER)));
40882 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CUP_RESOURCE_LIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_RESOURCE_LIMIT)));
40883 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CUP_SEC_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_SEC_VIOLATION)));
40884 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CUP_INV_DATA",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_INV_DATA)));
40885 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CUP_UNSUP_SCHEME",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_UNSUP_SCHEME)));
40886 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CUP_RELOAD",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_RELOAD)));
40887 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CANCELLED",SWIG_From_long((long)(GPG_ERR_LDAP_CANCELLED)));
40888 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_NO_SUCH_OPERATION",SWIG_From_long((long)(GPG_ERR_LDAP_NO_SUCH_OPERATION)));
40889 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_TOO_LATE",SWIG_From_long((long)(GPG_ERR_LDAP_TOO_LATE)));
40890 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_CANNOT_CANCEL",SWIG_From_long((long)(GPG_ERR_LDAP_CANNOT_CANCEL)));
40891 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_ASSERTION_FAILED",SWIG_From_long((long)(GPG_ERR_LDAP_ASSERTION_FAILED)));
40892 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_LDAP_PROX_AUTH_DENIED",SWIG_From_long((long)(GPG_ERR_LDAP_PROX_AUTH_DENIED)));
40893 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_1",SWIG_From_long((long)(GPG_ERR_USER_1)));
40894 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_2",SWIG_From_long((long)(GPG_ERR_USER_2)));
40895 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_3",SWIG_From_long((long)(GPG_ERR_USER_3)));
40896 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_4",SWIG_From_long((long)(GPG_ERR_USER_4)));
40897 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_5",SWIG_From_long((long)(GPG_ERR_USER_5)));
40898 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_6",SWIG_From_long((long)(GPG_ERR_USER_6)));
40899 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_7",SWIG_From_long((long)(GPG_ERR_USER_7)));
40900 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_8",SWIG_From_long((long)(GPG_ERR_USER_8)));
40901 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_9",SWIG_From_long((long)(GPG_ERR_USER_9)));
40902 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_10",SWIG_From_long((long)(GPG_ERR_USER_10)));
40903 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_11",SWIG_From_long((long)(GPG_ERR_USER_11)));
40904 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_12",SWIG_From_long((long)(GPG_ERR_USER_12)));
40905 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_13",SWIG_From_long((long)(GPG_ERR_USER_13)));
40906 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_14",SWIG_From_long((long)(GPG_ERR_USER_14)));
40907 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_15",SWIG_From_long((long)(GPG_ERR_USER_15)));
40908 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_USER_16",SWIG_From_long((long)(GPG_ERR_USER_16)));
40909 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_MISSING_ERRNO",SWIG_From_long((long)(GPG_ERR_MISSING_ERRNO)));
40910 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_UNKNOWN_ERRNO",SWIG_From_long((long)(GPG_ERR_UNKNOWN_ERRNO)));
40911 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EOF",SWIG_From_long((long)(GPG_ERR_EOF)));
40912 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_E2BIG",SWIG_From_long((long)(GPG_ERR_E2BIG)));
40913 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EACCES",SWIG_From_long((long)(GPG_ERR_EACCES)));
40914 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EADDRINUSE",SWIG_From_long((long)(GPG_ERR_EADDRINUSE)));
40915 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EADDRNOTAVAIL",SWIG_From_long((long)(GPG_ERR_EADDRNOTAVAIL)));
40916 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EADV",SWIG_From_long((long)(GPG_ERR_EADV)));
40917 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EAFNOSUPPORT",SWIG_From_long((long)(GPG_ERR_EAFNOSUPPORT)));
40918 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EAGAIN",SWIG_From_long((long)(GPG_ERR_EAGAIN)));
40919 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EALREADY",SWIG_From_long((long)(GPG_ERR_EALREADY)));
40920 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EAUTH",SWIG_From_long((long)(GPG_ERR_EAUTH)));
40921 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EBACKGROUND",SWIG_From_long((long)(GPG_ERR_EBACKGROUND)));
40922 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EBADE",SWIG_From_long((long)(GPG_ERR_EBADE)));
40923 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EBADF",SWIG_From_long((long)(GPG_ERR_EBADF)));
40924 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EBADFD",SWIG_From_long((long)(GPG_ERR_EBADFD)));
40925 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EBADMSG",SWIG_From_long((long)(GPG_ERR_EBADMSG)));
40926 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EBADR",SWIG_From_long((long)(GPG_ERR_EBADR)));
40927 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EBADRPC",SWIG_From_long((long)(GPG_ERR_EBADRPC)));
40928 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EBADRQC",SWIG_From_long((long)(GPG_ERR_EBADRQC)));
40929 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EBADSLT",SWIG_From_long((long)(GPG_ERR_EBADSLT)));
40930 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EBFONT",SWIG_From_long((long)(GPG_ERR_EBFONT)));
40931 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EBUSY",SWIG_From_long((long)(GPG_ERR_EBUSY)));
40932 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ECANCELED",SWIG_From_long((long)(GPG_ERR_ECANCELED)));
40933 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ECHILD",SWIG_From_long((long)(GPG_ERR_ECHILD)));
40934 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ECHRNG",SWIG_From_long((long)(GPG_ERR_ECHRNG)));
40935 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ECOMM",SWIG_From_long((long)(GPG_ERR_ECOMM)));
40936 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ECONNABORTED",SWIG_From_long((long)(GPG_ERR_ECONNABORTED)));
40937 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ECONNREFUSED",SWIG_From_long((long)(GPG_ERR_ECONNREFUSED)));
40938 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ECONNRESET",SWIG_From_long((long)(GPG_ERR_ECONNRESET)));
40939 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ED",SWIG_From_long((long)(GPG_ERR_ED)));
40940 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EDEADLK",SWIG_From_long((long)(GPG_ERR_EDEADLK)));
40941 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EDEADLOCK",SWIG_From_long((long)(GPG_ERR_EDEADLOCK)));
40942 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EDESTADDRREQ",SWIG_From_long((long)(GPG_ERR_EDESTADDRREQ)));
40943 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EDIED",SWIG_From_long((long)(GPG_ERR_EDIED)));
40944 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EDOM",SWIG_From_long((long)(GPG_ERR_EDOM)));
40945 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EDOTDOT",SWIG_From_long((long)(GPG_ERR_EDOTDOT)));
40946 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EDQUOT",SWIG_From_long((long)(GPG_ERR_EDQUOT)));
40947 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EEXIST",SWIG_From_long((long)(GPG_ERR_EEXIST)));
40948 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EFAULT",SWIG_From_long((long)(GPG_ERR_EFAULT)));
40949 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EFBIG",SWIG_From_long((long)(GPG_ERR_EFBIG)));
40950 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EFTYPE",SWIG_From_long((long)(GPG_ERR_EFTYPE)));
40951 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EGRATUITOUS",SWIG_From_long((long)(GPG_ERR_EGRATUITOUS)));
40952 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EGREGIOUS",SWIG_From_long((long)(GPG_ERR_EGREGIOUS)));
40953 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EHOSTDOWN",SWIG_From_long((long)(GPG_ERR_EHOSTDOWN)));
40954 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EHOSTUNREACH",SWIG_From_long((long)(GPG_ERR_EHOSTUNREACH)));
40955 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EIDRM",SWIG_From_long((long)(GPG_ERR_EIDRM)));
40956 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EIEIO",SWIG_From_long((long)(GPG_ERR_EIEIO)));
40957 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EILSEQ",SWIG_From_long((long)(GPG_ERR_EILSEQ)));
40958 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EINPROGRESS",SWIG_From_long((long)(GPG_ERR_EINPROGRESS)));
40959 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EINTR",SWIG_From_long((long)(GPG_ERR_EINTR)));
40960 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EINVAL",SWIG_From_long((long)(GPG_ERR_EINVAL)));
40961 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EIO",SWIG_From_long((long)(GPG_ERR_EIO)));
40962 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EISCONN",SWIG_From_long((long)(GPG_ERR_EISCONN)));
40963 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EISDIR",SWIG_From_long((long)(GPG_ERR_EISDIR)));
40964 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EISNAM",SWIG_From_long((long)(GPG_ERR_EISNAM)));
40965 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EL2HLT",SWIG_From_long((long)(GPG_ERR_EL2HLT)));
40966 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EL2NSYNC",SWIG_From_long((long)(GPG_ERR_EL2NSYNC)));
40967 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EL3HLT",SWIG_From_long((long)(GPG_ERR_EL3HLT)));
40968 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EL3RST",SWIG_From_long((long)(GPG_ERR_EL3RST)));
40969 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ELIBACC",SWIG_From_long((long)(GPG_ERR_ELIBACC)));
40970 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ELIBBAD",SWIG_From_long((long)(GPG_ERR_ELIBBAD)));
40971 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ELIBEXEC",SWIG_From_long((long)(GPG_ERR_ELIBEXEC)));
40972 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ELIBMAX",SWIG_From_long((long)(GPG_ERR_ELIBMAX)));
40973 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ELIBSCN",SWIG_From_long((long)(GPG_ERR_ELIBSCN)));
40974 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ELNRNG",SWIG_From_long((long)(GPG_ERR_ELNRNG)));
40975 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ELOOP",SWIG_From_long((long)(GPG_ERR_ELOOP)));
40976 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EMEDIUMTYPE",SWIG_From_long((long)(GPG_ERR_EMEDIUMTYPE)));
40977 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EMFILE",SWIG_From_long((long)(GPG_ERR_EMFILE)));
40978 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EMLINK",SWIG_From_long((long)(GPG_ERR_EMLINK)));
40979 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EMSGSIZE",SWIG_From_long((long)(GPG_ERR_EMSGSIZE)));
40980 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EMULTIHOP",SWIG_From_long((long)(GPG_ERR_EMULTIHOP)));
40981 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENAMETOOLONG",SWIG_From_long((long)(GPG_ERR_ENAMETOOLONG)));
40982 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENAVAIL",SWIG_From_long((long)(GPG_ERR_ENAVAIL)));
40983 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENEEDAUTH",SWIG_From_long((long)(GPG_ERR_ENEEDAUTH)));
40984 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENETDOWN",SWIG_From_long((long)(GPG_ERR_ENETDOWN)));
40985 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENETRESET",SWIG_From_long((long)(GPG_ERR_ENETRESET)));
40986 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENETUNREACH",SWIG_From_long((long)(GPG_ERR_ENETUNREACH)));
40987 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENFILE",SWIG_From_long((long)(GPG_ERR_ENFILE)));
40988 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOANO",SWIG_From_long((long)(GPG_ERR_ENOANO)));
40989 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOBUFS",SWIG_From_long((long)(GPG_ERR_ENOBUFS)));
40990 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOCSI",SWIG_From_long((long)(GPG_ERR_ENOCSI)));
40991 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENODATA",SWIG_From_long((long)(GPG_ERR_ENODATA)));
40992 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENODEV",SWIG_From_long((long)(GPG_ERR_ENODEV)));
40993 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOENT",SWIG_From_long((long)(GPG_ERR_ENOENT)));
40994 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOEXEC",SWIG_From_long((long)(GPG_ERR_ENOEXEC)));
40995 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOLCK",SWIG_From_long((long)(GPG_ERR_ENOLCK)));
40996 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOLINK",SWIG_From_long((long)(GPG_ERR_ENOLINK)));
40997 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOMEDIUM",SWIG_From_long((long)(GPG_ERR_ENOMEDIUM)));
40998 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOMEM",SWIG_From_long((long)(GPG_ERR_ENOMEM)));
40999 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOMSG",SWIG_From_long((long)(GPG_ERR_ENOMSG)));
41000 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENONET",SWIG_From_long((long)(GPG_ERR_ENONET)));
41001 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOPKG",SWIG_From_long((long)(GPG_ERR_ENOPKG)));
41002 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOPROTOOPT",SWIG_From_long((long)(GPG_ERR_ENOPROTOOPT)));
41003 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOSPC",SWIG_From_long((long)(GPG_ERR_ENOSPC)));
41004 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOSR",SWIG_From_long((long)(GPG_ERR_ENOSR)));
41005 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOSTR",SWIG_From_long((long)(GPG_ERR_ENOSTR)));
41006 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOSYS",SWIG_From_long((long)(GPG_ERR_ENOSYS)));
41007 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOTBLK",SWIG_From_long((long)(GPG_ERR_ENOTBLK)));
41008 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOTCONN",SWIG_From_long((long)(GPG_ERR_ENOTCONN)));
41009 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOTDIR",SWIG_From_long((long)(GPG_ERR_ENOTDIR)));
41010 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOTEMPTY",SWIG_From_long((long)(GPG_ERR_ENOTEMPTY)));
41011 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOTNAM",SWIG_From_long((long)(GPG_ERR_ENOTNAM)));
41012 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOTSOCK",SWIG_From_long((long)(GPG_ERR_ENOTSOCK)));
41013 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOTSUP",SWIG_From_long((long)(GPG_ERR_ENOTSUP)));
41014 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOTTY",SWIG_From_long((long)(GPG_ERR_ENOTTY)));
41015 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENOTUNIQ",SWIG_From_long((long)(GPG_ERR_ENOTUNIQ)));
41016 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ENXIO",SWIG_From_long((long)(GPG_ERR_ENXIO)));
41017 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EOPNOTSUPP",SWIG_From_long((long)(GPG_ERR_EOPNOTSUPP)));
41018 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EOVERFLOW",SWIG_From_long((long)(GPG_ERR_EOVERFLOW)));
41019 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EPERM",SWIG_From_long((long)(GPG_ERR_EPERM)));
41020 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EPFNOSUPPORT",SWIG_From_long((long)(GPG_ERR_EPFNOSUPPORT)));
41021 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EPIPE",SWIG_From_long((long)(GPG_ERR_EPIPE)));
41022 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EPROCLIM",SWIG_From_long((long)(GPG_ERR_EPROCLIM)));
41023 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EPROCUNAVAIL",SWIG_From_long((long)(GPG_ERR_EPROCUNAVAIL)));
41024 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EPROGMISMATCH",SWIG_From_long((long)(GPG_ERR_EPROGMISMATCH)));
41025 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EPROGUNAVAIL",SWIG_From_long((long)(GPG_ERR_EPROGUNAVAIL)));
41026 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EPROTO",SWIG_From_long((long)(GPG_ERR_EPROTO)));
41027 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EPROTONOSUPPORT",SWIG_From_long((long)(GPG_ERR_EPROTONOSUPPORT)));
41028 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EPROTOTYPE",SWIG_From_long((long)(GPG_ERR_EPROTOTYPE)));
41029 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ERANGE",SWIG_From_long((long)(GPG_ERR_ERANGE)));
41030 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EREMCHG",SWIG_From_long((long)(GPG_ERR_EREMCHG)));
41031 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EREMOTE",SWIG_From_long((long)(GPG_ERR_EREMOTE)));
41032 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EREMOTEIO",SWIG_From_long((long)(GPG_ERR_EREMOTEIO)));
41033 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ERESTART",SWIG_From_long((long)(GPG_ERR_ERESTART)));
41034 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EROFS",SWIG_From_long((long)(GPG_ERR_EROFS)));
41035 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ERPCMISMATCH",SWIG_From_long((long)(GPG_ERR_ERPCMISMATCH)));
41036 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ESHUTDOWN",SWIG_From_long((long)(GPG_ERR_ESHUTDOWN)));
41037 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ESOCKTNOSUPPORT",SWIG_From_long((long)(GPG_ERR_ESOCKTNOSUPPORT)));
41038 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ESPIPE",SWIG_From_long((long)(GPG_ERR_ESPIPE)));
41039 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ESRCH",SWIG_From_long((long)(GPG_ERR_ESRCH)));
41040 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ESRMNT",SWIG_From_long((long)(GPG_ERR_ESRMNT)));
41041 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ESTALE",SWIG_From_long((long)(GPG_ERR_ESTALE)));
41042 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ESTRPIPE",SWIG_From_long((long)(GPG_ERR_ESTRPIPE)));
41043 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ETIME",SWIG_From_long((long)(GPG_ERR_ETIME)));
41044 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ETIMEDOUT",SWIG_From_long((long)(GPG_ERR_ETIMEDOUT)));
41045 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ETOOMANYREFS",SWIG_From_long((long)(GPG_ERR_ETOOMANYREFS)));
41046 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_ETXTBSY",SWIG_From_long((long)(GPG_ERR_ETXTBSY)));
41047 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EUCLEAN",SWIG_From_long((long)(GPG_ERR_EUCLEAN)));
41048 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EUNATCH",SWIG_From_long((long)(GPG_ERR_EUNATCH)));
41049 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EUSERS",SWIG_From_long((long)(GPG_ERR_EUSERS)));
41050 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EWOULDBLOCK",SWIG_From_long((long)(GPG_ERR_EWOULDBLOCK)));
41051 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EXDEV",SWIG_From_long((long)(GPG_ERR_EXDEV)));
41052 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_EXFULL",SWIG_From_long((long)(GPG_ERR_EXFULL)));
41053 23 : SWIG_Python_SetConstant(d, d == md ? public_interface : NULL, "GPG_ERR_CODE_DIM",SWIG_From_long((long)(GPG_ERR_CODE_DIM)));
41054 23 : PyDict_SetItemString(md,(char*)"cvar", SWIG_globals());
41055 23 : SwigPyBuiltin_AddPublicSymbol(public_interface, "cvar");
41056 23 : SWIG_addvarlink(SWIG_globals(),(char*)"pyme_in_tree_build",Swig_var_pyme_in_tree_build_get, Swig_var_pyme_in_tree_build_set);
41057 : #if PY_VERSION_HEX >= 0x03000000
41058 23 : return m;
41059 : #else
41060 : return;
41061 : #endif
41062 : }
41063 :
|
