LCOV - code coverage report
Current view: top level - build/lang/python - gpgme_wrap.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 4525 16473 27.5 %
Date: 2016-09-12 12:35:26 Functions: 230 818 28.1 %

          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             : 

Generated by: LCOV version 1.11